Como seguimiento de mi desafío anterior, ¡ cuente hasta 20 con palabras! , una vez más, utilizaremos la lista de palabras de ese desafío para realizar otra tarea. Esta vez, usarás exclusivamente:

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

Para elegir 26 palabras diferentes, cada una comenzando con una letra única, y emitiéndolas en orden ascendente de la A a la Z. Aquí hay un ejemplo 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 es un lobo hormiguero , este es un jilguero , este es un kalanchoe , este es un nudibranquio y una goletrap .

Reglas

• No se puede leer directamente desde el repositorio, ni ninguna otra laguna.
• Puede seleccionar cualquiera de las 26 palabras proporcionadas en el enlace .
  • Eliges palabras y estas son las palabras que tu programa debería generar cada vez.
• Se debe seleccionar una palabra que comience con cada una de las siguientes letras:
  • [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]
• Este es el código de golf , el menor recuento de bytes gana.

¿Alguna otra sugerencia para spin-offs usando las listas de palabras?

Además, siéntase libre de robar mis listas de palabras y hacer desafíos.

Chicle , 100 99 bytes

00000000: 45ce 4502 0420 0800 c0bb bfb4 3bc1 adcf  E.E.. ......;...
00000010: 6f23 b7a1 910b 63b3 0016 84da 40d4 fd41  o#[email protected]
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                                  ...

Pruébalo en línea!

Salida:

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

Las palabras fueron nuevamente seleccionadas con recocido 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, genera la primera palabra que termina en -inesses o la primera palabra disponible.

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

Manifestación

let f =

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

o.innerHTML = f()

<pre id=o></pre>

Jalea , 69 bytes

Este es el enfoque ingenuo que puede ser mejorado por algunas garrapatas inteligentes

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

Pruébalo en línea!

(Se supone que "los separadores válidos son caracteres no alfabéticos imprimibles en ASCII (números pares, no me importa)" del desafío anterior)

Jalea , 49 bytes

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

Pruébalo en línea! (Toma unos 22 segundos en TIO)

Salidas:

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

Cómo 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

Ahorré 36 bytes gracias a Jonathan Allan, quien hizo la mayor parte del trabajo duro por esto (acabo de encontrar las palabras: P)

Pruébalo en línea!

Japt , 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

Pruébalo en línea!

Yo escribí un programa que me ayuda a optimizar la compresión. Ordena una lista por su tamaño de compresión shoco .

Japt , 85 bytes

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

donde los dos pares de backticks representan cadenas de caracteres imprimibles y no imprimibles aparentemente aleatorios. Pruébalo en línea! Salida:

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

Explicación

La técnica básica es:

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.

Encontré cozinessescomenzando con nessesalgunas respuestas que he usado y encontrando repetidamente la letra anterior que apareció entre la mayoría de las 26 letras. Como las técnicas codiciosas no suelen ser óptimas, más tarde escribí un guión para encontrar la palabra óptima 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");

^{(No me importa que sea increíblemente feo. Así es como PPCG me ha enseñado a codificar: P No te preocupes, no hago esto en producción).}

De todos modos, cuando se ejecuta en la consola del navegador en la lista de palabras de 10 letras , esto genera

[ "ozinesses", 57 ]

los 57 ser el número de letras que tendrían que aparecer en la cadena multilínea. También tardó unos 17 segundos en mi computadora, así que tenga paciencia cuando lo ejecute.

Al reemplazar la f=línea con

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]];

Puede obtener todos los sufijos dentro de los 20 caracteres del óptimo. (Cambie 20al final a algo más para ajustar esto. Nota: esta función probablemente solo funcione en Firefox) . Aquí puede encontrar una lista de todos los sufijos menores de 100 .

De todos modos, a partir de ahí, es solo una tarea encontrar la palabra para cada letra del alfabeto que tenga el sufijo más largo en común ozinesses. Escribí un script Japt para hacer esto, así como comprimir los prefijos necesarios para mí y decirme cuánto tiempo durará el programa resultante. (Sin embargo, deberá pegar manualmente la lista de palabras entre comillas).

Esta explicación probablemente fue algo confusa, así que no dude en hacer cualquier pregunta que pueda tener.

Bubblegum , 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..

Pruébalo en línea!

Huellas dactilares:

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

Pruébalo en línea!

¿Cómo?

Inicializa ia 97(el ordinal del carácter a) y luego recorre una lista formada splitmarcando una cadena en los espacios que forman e printing de las palabras, incrementándose a imedida que avanza. La mayoría de las entradas, wen la lista son de longitud dos, estas son las palabras que comienzan con la letra del alfabeto y terminan en inesses, es decir, de la forma:
chr(i)+w+'inesses'.
Las entradas de longitud 6 son de la forma:
chr(i)+w+'ies'
Esto significa que se puede usar un formato para anteponer la letra alfabética y agregar un final con el 'ness'insertado como 'i'+?+'es'cuando wes corto así:
"%c%si%ses"%(i,w,"ness"*(len(w)<3))
-% c se convierte ien un carácter; los dos %sinsertos wy "ness"*(len(w)<3), donde este último es "ness"si wes corto o""si wes largo

SOGL V0.12 , 66 bytes

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

Pruébalo aquí!

Una simple competencia del diccionario con el problema de que ninguna palabra que comienza con X estaba en el diccionario SOGL, por lo que compensé con xenotropic - tropic estaba en el diccionario. Y necesitaba agregar la cita de inicio porque de lo contrario el analizador pensó que [comenzó un ciclo: /

Carbón , 84 bytes

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

Pruébalo en línea! Utiliza la lista de palabras de @ HermanLauenstein, pero guardé un byte porque puedo perderme el f. Por una vez, algo competitivo incluso en modo detallado, que solo tiene 166 bytes. Pruébalo en línea!

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")