Usando las siguientes listas de palabras separadas por longitud:

https://github.com/Magic Octopus Urn / wordListsByLength

Imprima 1 palabra de cada lista de longitud n desde 1 hasta 20, aquí hay un ejemplo válido:

a
an
and
hand
hands
handle
handles
abandons
abandoned
understand
outstanding
newfoundland
understanding
characteristic
characteristics
characterization
characterizations
characteristically
characterologically
chemotherapeutically

Alternativamente (matriz):

['a', 'an', 'and', 'hand', 'hands', 'handle', 'handles', 'abandons', 'abandoned', 'understand', 'outstanding', 'newfoundland', 'understanding', 'characteristic', 'characteristics', 'characterization', 'characterizations', 'characteristically', 'characterologically', 'chemotherapeutically']

Alternativamente (cualquier separador no alfabético imprimible que no sea \n):

a:an:and:hand:hands:handle:handles:abandons:abandoned:understand:outstanding:newfoundland:understanding:characteristic:characteristics:characterization:characterizations:characteristically:characterologically:chemotherapeutically

Reglas

• Puedes elegir tus propias 20 palabras.
• Las palabras deben ser de la página de github proporcionada, más específicamente:
  • 1 de 1.txt, 1 de 2.txt, etc.
  • Tenga en cuenta que existen archivos por encima de 20.txt, pero no necesita palabras con más de 20 caracteres.
• Los separadores válidos son caracteres no alfabéticos imprimibles en ASCII (números pares, no me importa).
• Solo minúsculas o mayúsculas, elige una, quédate con ella; no se permite el título del caso.
• Por favor, no use una copia del 100% de mi ejemplo 20 palabras ...
  • Puedes, pero eso no es divertido.
  • Es probable que sean subóptimos de todos modos ...
• Si NO desea utilizar los archivos separados y necesita una lista completa:
  • Use unsorted.txt , estos son todos los narchivos .txt en uno, ordenados alfabéticamente.
• Tenga en cuenta que NO PUEDE leer directamente desde la URL, es una laguna común .
• Este es el código de golf , el conteo de bytes más bajo será el ganador.

Como referencia, la salida es de 229 bytes, por lo que todo lo que se encuentre debajo de eso supera la codificación.

Posible meta-etiqueta-discusión:

¿impulsado por el usuario, donde el usuario puede personalizar sus salidas de una lista de posibilidades?

Gelatina ,  49 35 31  30 bytes

ṫ3,⁸Ṗ,$€ẎK
“¤ƈȮⱮ⁴⁷ọḤƁŒ|⁾Ė»ḲÇ€K

Un enlace niládico que devuelve una lista de caracteres, o un programa completo que imprime esa lista como una cadena (las palabras delimitadas por espacios).

Pruébalo en línea!

¿Cómo?

ṫ3,⁸Ṗ,$€ẎK - Helper link: list of characters, word    e.g. "abreacts"
ṫ3         - tail word from index 3                          "reacts"
   ⁸       - chain's left argument, word
  ,        - pair                               ["reacts","abreacts"]
      $€   - last two links as a monad for €ach of the two words:
    Ṗ      -   pop (all but last character)      "react" / "abreact"
     ,     -   pair       ["react","reacts"] / ["abreact","abreacts"]
        Ẏ  - tighten          ["react","reacts","abreact","abreacts"]
         K - join with spaces         "react reacts abreact abreacts"

“¤ƈȮⱮ⁴⁷ọḤƁŒ|⁾Ė»ḲÇ€K - Link: no arguments
“¤ƈȮⱮ⁴⁷ọḤƁŒ|⁾Ė»     - a compressed string using dictionary indexes:
                    -   "agar abreacts acknowledges codeterminations deindustrializations"
               Ḳ    - split at spaces
                Ç€  - call the last link (Helper) as a monad for €ach
                  K - join with spaces

...cuyos rendimientos:

a ar aga agar react reacts abreact abreacts knowledge knowledges acknowledge acknowledges determination determinations codetermination codeterminations industrialization industrializations deindustrialization deindustrializations

Anterior:

@ 35:

“¡Ụıƭz Xj]"Ɱ*AJƤʂạ5ƬṚṪð^ƥỤ»ḲṖ,$€K€K

Usando 10 palabras y sus prefijos longitud-1.

@ 49

“ḊAḥTz¹ỴH¡ṛYẈDƤNŀt#ñ²ĿĊḤlṪnð⁻U+ɦỴĊypṆQ0⁴ṄẉṂi⁻d¤&»

Simplemente 20 palabras comprimidas.

Python 2 , 145 bytes

print'i am now tiny @ @s##s#ed#act#acts#@#@s#@ed#@ing#arguments#accusation#accusations#advertisings'.replace('#',' counter').replace('@','check')

Pruébalo en línea!

Imprime estas palabras, separadas por espacios:

i
am
now
tiny
check
checks
counter
counters
countered
counteract
counteracts
countercheck
counterchecks
counterchecked
counterchecking
counterarguments
counteraccusation
counteraccusations
counteradvertisings

PowerShell , 166 163 bytes

'a
an
and'
'','s','le','ler','lers'|%{"hand$_"}
($a="character")
($x=-split"s ed ful ized istic istics ization izations istically ologically"|%{"$a$_"})
"un"+$x[8]

Pruébalo en línea!

Optimizado a mano, sin algoritmos. Los dos bucles |%{ }agregan el final apropiado al comienzo apropiado. Estoy buscando una manera de ponerlos en un solo ciclo.

Python, 169 bytes

z='odahs princesses acclimatizers cyanocobalamines aerothermodynamics underrepresentations'.split()
print([y[:i+1]for x,y in zip(['']+z,z)for i in range(len(x),len(y))])

Imprime una lista de las palabras.

Pruébalo en línea!

Palabras obtenidas escaneando secuencias de palabras coincidentes, al principio o al final de la palabra y comenzando desde la longitud 1 hacia arriba o desde la longitud 20 palabras descendentes.

Aquí está el guión que solía obtener. _{(el de coincidencia de inicio ascendente)}

Python 2 ,  126 120  112 bytes

-8 bytes gracias a Anders Kaseorg _{(pensé que había migrado esto de Python 3, ¡pero resulta que lo olvidé!)}

Un puerto de mi respuesta Jelly también funciona bien en Python ...

for w in"agar abreacts acknowledges codeterminations deindustrializations".split():print w[2:-1],w[2:],w[:-1],w,

Pruébalo en línea!

Huellas dactilares:

a ar aga agar react reacts abreact abreacts knowledge knowledges acknowledge acknowledges determination determinations codetermination codeterminations industrialization industrializations deindustrialization deindustrializations 

JavaScript, 159 bytes

_='a1an1and}}swwrwrs~~s~ed~ful~ized{{s~|~|s{ally~ologically1misx|s~1x}1hand|ization{~isticxcharacterw}le';for(i of'wx{|}~')with(_.split(i))_=join(pop());f=f=>_

Pruébalo en línea!

Gracias @HyperNeutrino por editar. Pero, estoy volviendo a la publicación anterior (eliminando el indicador "Node.js") porque no tiene nada que ver con Node.js. Funciona perfectamente en los navegadores también.

05AB1E , 51 bytes

’¯Óa‚‡’D“€…€¤Þ¨íʃé¢Ã¥£žÜ¶ß´ç…àçî×Ü»‡ÛೌçÓs²® ÿ ÿs

Pruébalo en línea!

Separador:

Lista de palabras: a, an, ana, anal, house, houses, amazing, criminal, seriously, apparently, accessories, disciplinary, distributions, discrimination, congratulations, responsibilities, characterizations, telecommunications, representationalist, representationalists

Ruby, 120 bytes

j=3
$><<?a
"  5  T &  }   <    ".bytes{|i|puts
8.times{|k|$><<%w{dehydro chlori ge n at ion e s}[k]*(j>>7-k&1)}
j+=i-31}

Imprime lo siguiente. Cada palabra se construye a partir de las 8 cadenas anteriores, utilizando los dígitos binarios de jpara seleccionar. En cada iteración del bucle, jse incrementa el valor ASCII de los caracteres en la cadena entre comillas, menos 31.

a
es
ion
ions
nates
nation
nations
chlorine
chlorines
chlorinate
chlorinates
chlorination
dehydrogenate
dehydrogenates
dehydrogenation
dehydrogenations
dehydrochlorinate
dehydrochlorinates
dehydrochlorination
dehydrochlorinations

Pyth , 74 bytes

Aventuras psicopatológicas

.e:"psychopathologicallyadventuresomenesses"b+bhkiR36"GGGGBKMMKKM6K6M0K0K0

Pruébalo en línea! Produce:

['a', 'al', 'all', 'ally', 'logic', 'advent', 'venture', 'ventures', 'adventure', 'adventures', 'venturesome', 'pathological', 'adventuresome', 'pathologically', 'venturesomeness', 'psychopathologic', 'adventuresomeness', 'psychopathological', 'adventuresomenesses', 'psychopathologically']

Lo cual, una vez formateado produce:

a
al
all
ally
logic
advent
venture
ventures
adventure
adventures
venturesome
pathological
adventuresome
pathologically
venturesomeness
psychopathologic
adventuresomeness
psychopathological
adventuresomenesses
psychopathologically

Explicación

La clave era elegir dos palabras que se complementaran entre sí. Elegí " psicopatológicamente " y " aventuras de aventuras " gracias a una pequeña herramienta que escribí . Usando estas dos palabras, para cualquier longitud podemos encontrar subcadenas que son palabras reales de la lista provista . Todas las posibles descomposiciones son demostradas por:

a al all ally logic psycho logical          logically pathologic             pathological               pathologically                 psychopathologic                   psychopathological                     psychopathologically
a ad ess ness esses advent venture ventures adventure adventures venturesome              adventuresome                venturesomeness                  adventuresomeness                    adventuresomenesses

El siguiente paso es simplemente obtener la lista de los índices para una descomposición dada. Por mi descomposición, he elegido: 16 16 16 16 11 20 22 22 20 20 22 6 20 6 22 0 20 0 20 0, que son índices en las cadenas concatenadas: psychopathologicallyadventuresomenesses.

Finalmente, escriba un programa que simplemente recorra los índices y muestre la subcadena en cada índice dado con una longitud creciente.

Para guardar bytes, almacené los índices en una cadena base 36. En efecto,GGGGBKMMKKM6K6M0K0K0 es la lista de mis índices en la base 36 (porque mi índice más alto es 22, podría haber usado la base 23).

Explicación del programa

.e:"psychopathologicallyadventuresomenesses"b+bhkiR36"GGGGBKMMKKM6K6M0K0K0

                                                 iR36"GGGGBKMMKKM6K6M0K0K0    # For each character in the string, convert from base 36 to base 10
.e                                                                            # Loop over indexes: b are the indexes, h their position
  :"psychopathologicallyadventuresomenesses"b+bhk                             # In "psy...ses", select the substring at index b and of length k + 1

C #, 259 bytes

_=>{var a=new int[7].Select((n,i)=>"abasers".Substring(0,i+1)).ToList();a.Add("abacuses");a.AddRange(new int[12].Select((n,i)=>(i>10?"un":"")+"character"+"|s|ed|ful|ised|istic|istics|isation|isations|istically|ologically|istically|".Split('|')[i]));return a;}

Todavía hay espacio obvio para jugar al golf, pero ahora me he quedado sin tiempo. Sé que es más largo que la codificación rígida, por lo que lo solucionaré cuando tenga tiempo más adelante.

05AB1E , 130 68 bytes

-62 bytes gracias a Erik the Outgolfer

743222’€Ü†š ƒ´aî³eros €‡a•¿f²Ñns …¿en®íizers ‚ÀÙŠs ‡åØŽ’#‚øε`ηRs£R}˜

Pruébalo en línea!

Toma tantos prefijos como sea necesario de cada una de las siguientes palabras:

amusers
carabinero
foraminiferans
photosensitizers
videoconferencings
radiopharmaceuticals

Imprime estas palabras en una matriz:

a
am
amu
amus
amuse
amuser
amusers
carabine
carabiner
carabinero
carabineros
foraminifera
foraminiferan
foraminiferans
photosensitizer
photosensitizers
videoconferencing
videoconferencings
radiopharmaceutical
radiopharmaceuticals 

Chicle , 66 bytes

00000000: 6d8b 410a 0020 0804 bf6a 4407 a134 5aff  m.A.. ...jD..4Z.
00000010: 4fe6 29ac 93ce b0a3 543a ad06 3f6c e769  O.).....T:..?l.i
00000020: 46f3 3ae2 b218 abc4 2cab d389 a805 82aa  F.:.....,.......
00000030: fee1 6e43 2444 62df 0f46 4a1e f356 8cf1  ..nC$Db..FJ..V..
00000040: 73d8                                     s.

Salida:

o`al`res`alit`reset`preset`present`rational`represent`rationales`annotations`connotations`connotational`representation`representations`representational`misrepresentation`misrepresentations`representationalism`representationalisms

Pruébalo en línea!

Las palabras y el separador se seleccionaron mediante recocido simulado:

from __future__ import print_function
import math
import random
import zlib

wordlists = \
    [[chr(x).encode() for x in [9, 10] + list(range(32, 127)) if not chr(x).encode().isalpha()]] + \
    [open('wordListsByLength/{}.txt'.format(n), 'rb').read().splitlines() for n in range(1, 21)]

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

temperature = 10.
score = 9999
best = score

while True:
    old_score = score
    n = random.randrange(len(wordlists))
    old_word = words[n]
    words[n] = random.choice(wordlists[n])
    z = zlib.compressobj(9, zlib.DEFLATED, -zlib.MAX_WBITS, 9)
    score = len(z.compress(words[0].join(words[1:])) + z.flush())
    if score > old_score and random.random() >= math.exp((old_score - score) / temperature):
        words[n] = old_word
        score = old_score
    else:
        temperature *= .99999
        if score < best:
            best = score
            print(best, repr(words[0].join(words[1:])))

Chicle , 78 bytes

00000000: 654b c301 4431 10bd a7cb d876 9a5f efe7  eK..D1.....v._..
00000010: 781e 2080 ee55 0488 ffc8 9f69 e86f a5ff  x. ..U.....i.o..
00000020: ce00 0b98 202e 34ed d701 a464 bf59 35fb  .... .4....d.Y5.
00000030: 23d7 9192 b948 7c79 f351 0c8b f4ee 06e4  #....H|y.Q......
00000040: 8b05 1a33 77c8 1bcf 7f58 7577 e113       ...3w....Xuw..

Pruébalo en línea!

Ruby, 107 bytes

p(z=%w{o or for form ultra})+[z[3],c="centrifug",z[4]+c].product(%w{ed ing ally ation ations}).map{|i|i*""}

Imprime la siguiente matriz.

["o", "or", "for", "form", "ultra", "formed", "forming", "formally", "formation", "formations", "centrifuged", "centrifuging", "centrifugally", "centrifugation", "centrifugations", "ultracentrifuged", "ultracentrifuging", "ultracentrifugally", "ultracentrifugation", "ultracentrifugations"

Cambiar el pparaputs (con espacio final) proporciona lo siguiente a un costo de 4 bytes adicionales.

o
or
for
form
ultra
formed
forming
formally
formation
formations
centrifuged
centrifuging
centrifugally
centrifugation
centrifugations
ultracentrifuged
ultracentrifuging
ultracentrifugally
ultracentrifugation
ultracentrifugations

Japt , 119 bytes

`av„v„dvjvjsvj¤vj¤svfœejvqvqsvq‚vqˆgvqizƒvqÄKcvqÄKcsvqizÂ\nvqizÂ\nsvq‰tkvqologkv·sqizÂ\ns`d'j`Ê@`'k`Åœ§`'q`Ö‹a×` q'v ·

Pruébalo en línea!

Huellas dactilares:

a
an
and
hand
hands
handle
handles
freehand
character
characters
charactered
charactering
characterizes
characteristic
characteristics
characterization
characterizations
characteristically
characterologically
mischaracterizations