Como acompanhamento do meu desafio anterior, conte até 20 com palavras! , usaremos novamente a lista de palavras desse desafio para executar outra tarefa. Desta vez, você estará usando exclusivamente:

https://github.com/Magic Octopus Urn / wordListsByLength / blob / master / 10.txt

Para escolher 26 palavras diferentes, cada uma começando com uma letra única e imprimindo-as em ordem crescente de A a Z. Aqui está um exemplo válido:

aardwolves
babbitting
caravaning
debilitate
evaporator
fantasized
geographer
hawfinches
imbecility
juvenility
kalanchoes
lamaseries
malodorous
nudibranch
oligophagy
pantywaist
quarreling
russetting
scantiness
teetotaler
undercount
voodooisms
wentletrap
xenophobic
yeomanries
zwitterion

Este é um lobo - marinho , este é um hawfinch , este é um kalanchoe , este é um nudibrânquios e um pedaço de galinha .

Regras

• Nenhuma leitura diretamente do repositório ou de outras brechas.
• Você pode selecionar 26 das palavras fornecidas no link .
  • Você escolhe as palavras e estas são as palavras que seu programa deve produzir sempre.
• Uma palavra começando com cada uma das seguintes letras deve ser selecionada:
  • [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]
• Isso é código-golfe , vitórias mais baixas na contagem de bytes.

Alguma outra sugestão de spin-offs usando as listas de palavras?

Além disso, fique à vontade para roubar minhas listas de palavras e fazer desafios.

Chiclete , 100 99 bytes

00000000: 45ce 4502 0420 0800 c0bb bfb4 3bc1 adcf  E.E.. ......;...
00000010: 6f23 b7a1 910b 63b3 0016 84da 40d4 fd41  o#....c.....@..A
00000020: 344c 2b81 e824 e09f 9e19 e4e9 8d3a 1353  4L+..$.......:.S
00000030: 3f7c c3fc 59b8 b732 5b07 62e7 c383 4fcc  ?|..Y..2[.b...O.
00000040: 4d5f 88c5 bd60 6f44 8c8d b87d 215e 78c3  M_...`oD...}!^x.
00000050: 359e ec4d 360c bd4a 94e2 6e25 e06f ef43  5..M6..J..n%.o.C
00000060: d286 17                                  ...

Experimente online!

Resultado:

artinesses
businesses
cozinesses
dozinesses
easinesses
fastnesses
gastnesses
hazinesses
ickinesses
jokinesses
kindnesses
lazinesses
mazinesses
nosinesses
oozinesses
pastnesses
queasiness
rosinesses
sexinesses
tininesses
uglinesses
vastnesses
wilinesses
xanthomata
yeastiness
zaninesses

As palavras foram novamente selecionadas com recozimento simulado:

from __future__ import print_function
import math
import random
import zopfli.zlib

wordlists = [[] for n in range(26)]
for word in open('wordListsByLength/10.txt', 'rb').read().splitlines():
    wordlists[ord(word[:1]) - ord('a')].append(word)

words = [random.choice(wordlist) for wordlist in wordlists]

temperature = 1.
score = 9999
best = score

while True:
    old_score = score
    n = random.randrange(len(wordlists))
    old_word = words[n]
    words[n] = random.choice(wordlists[n])
    score = len(zopfli.zlib.compress(b'\n'.join(words)) - 6
    if score > old_score and random.random() >= math.exp((old_score - score) / temperature):
        words[n] = old_word
        score = old_score
    else:
        temperature *= .9999
        if score < best:
            best = score
            print(best, repr(b'\n'.join(words)))

JavaScript (ES6), 168 bytes

Para cada letra inicial, gera a primeira palavra que termina em -inesses ou a primeira palavra disponível.

_=>`ash0bus0coz0doz0eer0foz0gor0hom0ink0jok0kaiserdoms
log0mir0nos0ooz0pun0quackeries
ros0siz0tin0ugl0vacantness
wir0xanthomata
yardmaster
zan0`.split`0`.join`inesses
`

Demo

let f =

_=>`ash0bus0coz0doz0eer0foz0gor0hom0ink0jok0kaiserdoms
log0mir0nos0ooz0pun0quackeries
ros0siz0tin0ugl0vacantness
wir0xanthomata
yardmaster
zan0`.split`0`.join`inesses
`

o.innerHTML = f()

<pre id=o></pre>

Geléia , 69 bytes

Esta é a abordagem ingênua que pode ser improvável por alguns tiques inteligentes

“6)ọʋtL⁺%ḍʠ9ƲȮṆ'ṫZpɲṇḃb7ṗ³ðʠ©q€©[ẠṾṠɠ+ȯ!?^_iṘ©ð⁴ạ'8œÐṣTP³ḃXŻDƭƇM⁽H>Ỵ»

Experimente online!

(Supõe que "Separadores válidos são caracteres não alfabéticos imprimíveis em ASCII (números pares, não se importam)" se mantém do desafio anterior)

Geléia , 49 bytes

“J9,⁹FṾ»ŒVŒlµL=⁵µÐf
¢Ḣ€OIT+“¢&ĠUṗɓṃ€~ƙṂ’D¤;@0‘ị¢Y

Experimente online!(Demora cerca de 22 segundos no TIO)

Saídas:

aardwolves
babbitting
cabalettas
daftnesses
earlywoods
fabricants
gadgetries
habiliment
iatrogenic
jaborandis
kaiserdoms
labialized
macadamize
naboberies
oafishness
pacemaking
quackeries
rabbinical
sabadillas
tabernacle
ubiquinone
vacantness
wadsetting
xanthomata
yardmaster
zabaglione

Como funciona

“J9,⁹FṾ»ŒVŒlµL=⁵µÐf           - all length 10 Jelly dictionary words
“J9,⁹FṾ»                        - literal string "dictionary.long"
        ŒV                      - Python eval: get list of long words
          Œl                    - set all to lowercase 
            µ   µÐf             - filter keep only those which meet:
             L                  - length
              =                 - equal to
               ⁵                - 10

¢Ḣ€OIT+“¢&ĠUṗɓṃ€~ƙṂ’D¤;@0‘ị¢Y - main link
¢                               - length 10 Jelly dictionary words from helper
 Ḣ€                             - first letter of each.
   O                            - ord: character values
    I                           - difference between consecutive elements
     T                          - indices of nonzero elements
                            (gets indices of first word starting with each letter)
      +                         - add
       “¢&ĠUṗɓṃ€~ƙṂ’D¤          - the list [2,0,5,9,1,3,3,1,1,6,1,2,0,0,0,0,2,1,1,1,0,3,1,8,0]
                      ;@0       - append 0 to beginning (golfable?)
                         ‘      - increment each element
                          ị¢    - index into the above length 10 words
                            Y   - join by newlines

Python 2 , 256 231 220 bytes

i=97
for w in"uto ibli aco emo ntom utur laci olo deo ackfishes ymo exic alac omo cean alyn uaternion eno eri omo rban eno avelessly ero outhfully witterion".split():print chr(i)+(w+["graphy","ology"][w[3:]>''])[:9];i+=1

Economizei 36 bytes graças a Jonathan Allan, que fez a maior parte do trabalho duro para isso (acabei de encontrar as palavras: P)

Experimente online!

Japonês , 169 107 bytes

`a®
¾n
¯g
¸w
e
fox
g
z

jo
ê]
¦m
µt
nos
oil
po
qua×@i
c
 x
d
ugl
void
°r
xopb
yeÇ
z`·£`ê£`hX

Experimente online!

Eu escrevi um programa que me ajuda a otimizar a compactação. Classifica uma lista por seu tamanho de compactação shoco .

Japt , 85 bytes

97
`...`£`...`hXiU°d}R

onde os dois pares de reticulares representam cadeias de caracteres imprimíveis e imprimíveis aparentemente aleatórios. Experimente online! Resultado:

achinesses
boninesses
cozinesses
dozinesses
easinesses
fozinesses
gorinesses
hazinesses
ickinesses
jokinesses
keennesses
lazinesses
mazinesses
nosinesses
oozinesses
pipinesses
quadrantes
riminesses
sizinesses
tininesses
uglinesses
vainnesses
warinesses
xylotomies
yeomanries
zaninesses

Explicação

A técnica básica é:

97             Set U to 97
`ch
on
...`£  }R      Map each line X in this multiline string to:
U°d              Take U.toCharCode() and increment U.  ["a", "b", "c", ...]
Xi               Prepend this to X.  ["ach", "bon", "c", ...]
`cozinesses`h    Overwrite this onto the beginning of "cozinesses".
                 ["achinesses", "boninesses", "cozinesses", ...]
    £  }R      Rejoin with newlines and implicitly output.

Descobri cozinessescomeçando com nessesoutras respostas que foram usadas e encontrando repetidamente a letra anterior que apareceu entre as 26 letras com mais frequência. Como as técnicas gananciosas geralmente não são ótimas, mais tarde escrevi um script para encontrar a palavra ideal real:

alphabet="abcdefghijklmnopqrstuvwxyz".split``;
wordlist=alphabet.map(x=>[]);
document.body.innerText.split`\n`.slice(0,-1).map(x=>wordlist[x.charCodeAt()-97].push(x));
f=(q="",n=7,s=0,words=wordlist,z=n&&alphabet.map(x=>[x+q,words.map(y=>[y=y.filter(z=>z[n]==x),t+=0 in y][0],t=0),t]))=>n?z.filter(x=>x[2]>=Math.max(1,...z.map(x=>(x[2]-2)*2/3))).map(x=>f(x[0],n-1,s+26-x[2],x[1])).sort((a,b)=>a[1]-b[1])[0]:[q,s];

console.time("find optimal word");
console.log(f());
console.timeEnd("find optimal word");

^{(Não me importo que seja incrivelmente feio. Foi assim que o PPCG me ensinou a codificar: P Não se preocupe, não faço isso na produção.)}

De qualquer forma, quando executado no console do navegador na lista de 10 letras , isso gera

[ "ozinesses", 57 ]

A 57sendo o número de cartas que teriam de aparecer na seqüência de várias linhas. Também levou cerca de 17 segundos no meu computador; portanto, seja paciente ao executá-lo.

Substituindo a f=linha por

f=(q="",n=9,s=0,words=wordlist,z=n&&alphabet.map(x=>[x+q,words.map(y=>[y=y.filter(z=>z[n]==x),t+=0 in y][0],t=0),t]))=>n?[for(x of z.filter(x=>x[2]>=Math.max(1,...z.map(x=>(x[2]-2)*2/3))))for(y of f(x[0],n-1,s+26-x[2],x[1]))y].sort((a,b)=>a[1]-b[1]).filter((x,i,a)=>x[1]<=a[0][1]+20):[[q,s]];

você pode obter todos os sufixos dentro de 20 caracteres do ideal. (Altere 20no final para outra coisa para ajustar isso. Nota: esta função provavelmente só funciona no Firefox.) Você pode encontrar uma lista de todos os sufixos abaixo de 100 aqui .

De qualquer forma, a partir daí é apenas uma tarefa de encontrar a palavra para cada letra do alfabeto com o maior sufixo em comum ozinesses. Eu escrevi um script japt para fazer isso, além de comprimir os prefixos necessários para mim e me dizer quanto tempo o programa resultante será. (Você precisará colar manualmente a lista de palavras entre as aspas.)

Essa explicação provavelmente foi um pouco confusa; portanto, fique à vontade para fazer qualquer pergunta que possa ter.

Chiclete , 110 106 bytes

Hexdump:

0000000: 45cc 4116 8240 0c83 e1bd b72c 50a1 0ed3  E.A..@.....,P...
0000010: 2015 454e 2fcf 4727 bb6f 91fc 1293 b946   .EN/.G'.o.....F
0000020: 68dc 3aec c91e 4772 2055 2279 e776 94aa  h.:...Gr U"y.v..
0000030: 1727 695b f392 7ca0 b1b8 f445 573b 39f3  .'i[..|....EW;9.
0000040: 5679 7344 1236 2717 169e 5b2b acdc 0663  VysD.6'...[+...c
0000050: 2f72 1b5b e10d 1b2e 7ed8 ddd5 b14c e84e  /r.[....~....L.N
0000060: 7e15 55fc df3d c473 f003                 ~.U..=.s..

Experimente online!

Impressões:

ashinesses
boxinesses
cozinesses
dozinesses
easinesses
foxinesses
gamenesses
hazinesses
inkinesses
jokinesses
knackeries
lamenesses
mazinesses
nosinesses
oilinesses
pokinesses
quackeries
rosinesses
samenesses
tamenesses
uglinesses
voidnesses
wilinesses
xenophobes
yeomanries
zaninesses

Javascript (ES6), 163 bytes

_=>`ach
bon
c
d
eas
f
gam
ha
ick
jok
keen
la
ma
nos
o
pip
quackeri
rac
si
tid
ugl
vain
war
xenogami
yeomanri
zan`.replace(/.+/g,s=>s+"-ozinesses".substr(s.length))

f=
_=>`ach
bon
c
d
eas
f
gam
ha
ick
jok
keen
la
ma
nos
o
pip
quackeri
rac
si
tid
ugl
vain
war
xenogami
yeomanri
zan`.replace(/.+/g,s=>s+"-ozinesses".substr(s.length))
o.innerText = f()

<pre id=o>

Python 2 ,  168  166 bytes

i=97
for w in"ch on ag ew as ox am az ck ok azatsk ac at os il ip uacker ac ex id gl agilit ar enogam eomanr an".split():print"%c%si%ses"%(i,w,"ness"*(len(w)<3));i+=1

Experimente online!

Quão?

Inicializa iem 97(o ordinal do caractere a), em seguida, percorre uma lista formada por splitting uma string em espaços formando e printdigitando as palavras, aumentandoi medida que avança. A maioria das entradas, wna lista são de comprimento dois, estas são palavras que começam com a letra alfabética e terminam em inesses, ou seja, da forma:
chr(i)+w+'inesses'.
As entradas de comprimento 6 estão no formato:
chr(i)+w+'ies'
Isso significa que uma formatação pode ser usada para acrescentar a letra alfabética e adicionar um final com o 'ness'inserido como 'i'+?+'es'quando wé curto assim:
"%c%si%ses"%(i,w,"ness"*(len(w)<3))
-% c converte iem um caractere; as duas %sinserções we "ness"*(len(w)<3), onde esta estiver "ness"se wfor curta ou""se wé longo.

SOGL V0.12 , 66 bytes

"⅟μ█X§¡Ψ}|μ⁾k,²9γ↑č─[╝B4mh|c↑′ρ╤τnE╗Ζ±$ņ¦Pγ9¬oΘ′`║F→█#▲xpņRe└ωηηƨ‘

Experimente aqui!

Uma simples compilação de dicionário com o problema de que nenhuma palavra que começa com X estava no dicionário SOGLs, então eu compensei com xenotrópico - trópico estava no dicionário. E eu precisava adicionar a citação inicial porque, caso contrário, o analisador pensava que[ iniciou um loop: /

Carvão , 84 bytes

ＵＯχ²⁶”m⌈⎚∧³δ¤↶””｜↖⧴=P“⪪šl¢‘υKBＳＡＤ ⁶⁸ςz↧\–～⎇Ｖ▷–ê"℅ ž⟲‹‹⮌0Bff5Ｙ⪪Ｅ？Þ¹@)⟦£δＴ⪪⌕↙]\ＲＺ_Ｑ‹″”

Experimente online! Usa a lista de palavras de @ HermanLauenstein, mas salvei um byte porque posso perder o f. Pela primeira vez, um pouco competitivo, mesmo no modo detalhado, que é de apenas 166 bytes. Experimente online!

Oblong(c 26 "fozinesses")Print("ach\nbon\nc\nd\neas\n\ngam\nha\nick\njok\nkeen\nla\nma\nnos\no\npip\nquackeri\nrac\nsi\ntid\nugl\nvain\nwar\nxenogami\nyeomanri\nzan")