En utilisant les listes de mots séparés par une longueur suivants:

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

Imprimez 1 mot de chaque liste de longueur n de 1 à 20, en voici un exemple valable:

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

Alternativement (tableau):

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

Autre possibilité (tout séparateur non alphabétique imprimable autre que \n):

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

Règles

• Vous pouvez choisir vos 20 mots.
• Les mots doivent provenir de la page github fournie, plus précisément:
  • 1 à partir de 1.txt, 1 à partir de 2.txt, etc ...
  • Remarque: les fichiers supérieurs à 20.txt existent, mais vous n'avez pas besoin de mots supérieurs à 20 caractères.
• Les séparateurs valides sont des caractères non alphabétiques imprimables en ASCII (même les chiffres, peu importe).
• En minuscule ou en majuscule seulement, choisissez-en un, restez-y! aucun titre n'est autorisé.
• S'il vous plaît ne pas utiliser une copie à 100% de mon exemple 20 mots ...
  • Vous pouvez, mais ce n'est pas amusant.
  • Ils sont probablement sous-optimaux de toute façon ...
• Si vous ne voulez PAS utiliser les fichiers séparés et avez besoin d'une liste complète:
  • Utilisez unsorted.txt , c’est tous les nfichiers .txt en un, classés par ordre alphabétique.
• Notez que vous ne pouvez pas lire directement à partir de l'URL, c'est une faille commune .
• C'est le code-golf , le plus petit nombre d'octets sera le gagnant.

Pour référence, la sortie est de 229 octets;

Méta-tag-discussion possible:

orienté utilisateur où l'utilisateur peut personnaliser ses sorties à partir d'une liste de possibilités?

Jelly ,  49 35 31  30 octets

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

Un lien niladique renvoyant une liste de caractères, ou un programme complet imprimant cette liste sous forme de chaîne (les mots sont délimités par des espaces).

Essayez-le en ligne!

Comment?

ṫ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

... qui donne:

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

Précédent:

@ 35:

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

En utilisant 10 mots et leurs préfixes de longueur-1.

@ 49

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

Simplement 20 mots compressés.

Python 2 , 145 octets

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

Essayez-le en ligne!

Imprime ces mots, séparés par des espaces:

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

PowerShell , 166 163 octets

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

Essayez-le en ligne!

Optimisé à la main, aucun algorithme. Les deux boucles |%{ }pointent vers la fin appropriée jusqu'au début approprié. Je cherche un moyen de les mettre dans une boucle.

Python, 169 octets

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 une liste des mots.

Essayez-le en ligne!

Mots obtenus en balayant des séquences de mots correspondants, par début ou fin de mot, à partir de la longueur 1 ou de la longueur 20 mots.

Voici le script que j'ai utilisé pour l'obtenir. _{(le jumelage ascendant correspondant)}

Python 2 ,  126 120  112 octets

-8 octets grâce à Anders Kaseorg _{(je pensais que je l'avais migré de Python 3, mais finalement j'avais oublié!)}

Un portage de ma réponse de gelée fonctionne également bien en Python ...

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

Essayez-le en ligne!

Impressions:

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

JavaScript, 159 octets

_='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=>_

Essayez-le en ligne!

Merci @HyperNeutrino pour l'édition. Mais je reviens à l'ancien message (en retirant l'indicateur "Node.js") car il n'a rien à voir avec Node.js. Cela fonctionne parfaitement dans les navigateurs aussi.

05AB1E , 51 octets

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

Essayez-le en ligne!

Séparateur:

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

Ruby, 120 octets

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 ce qui suit. Chaque mot est construit à partir des 8 chaînes ci-dessus, en utilisant les chiffres binaires de jpour sélectionner. À chaque itération de la boucle, jest incrémentée de la valeur ASCII des caractères de la chaîne entre guillemets, moins 31.

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

Pyth , 74 octets

Aventures psychopathologiquement

.e:"psychopathologicallyadventuresomenesses"b+bhkiR36"GGGGBKMMKKM6K6M0K0K0

Essayez-le en ligne! Il produit:

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

Lequel, une fois formaté, donne:

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

Explication

La clé était de choisir deux mots qui se complètent. J'ai choisi " psychopathologiquement " et " aventuriers " grâce à un petit outil que j'ai écrit . En utilisant ces deux mots, pour toute longueur, nous pouvons trouver des sous-chaînes qui sont des mots réels de la liste fournie . Toutes les décompositions possibles sont démontrées par:

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

La prochaine étape consiste simplement à obtenir la liste des index pour une décomposition donnée. Pour ma décomposition, j'ai choisi: 16 16 16 16 11 20 22 22 20 20 22 6 20 6 22 0 20 0 20 0, qui sont des index dans les chaînes concaténées: psychopathologicallyadventuresomenesses.

Enfin, écrivez un programme qui boucle sur les index et affiche la sous-chaîne à chaque index donné avec une longueur croissante.

Pour sauvegarder des octets, j'ai stocké les index dans une chaîne de base. Effectivement,GGGGBKMMKKM6K6M0K0K0 la liste de mes index est en base 36 (mon index le plus élevé étant 22, j'aurais pu utiliser la base 23).

Explication du programme

.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 octets

_=>{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;}

Il reste encore une marge de manœuvre pour jouer au golf, mais je n’ai plus de temps maintenant. Je sais que c'est plus long que le codage dur, donc je vais le réparer quand j'aurai un peu de temps plus tard.

05AB1E , 130 à 68 octets

-62 octets grâce à Erik l'Outgolfer

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

Essayez-le en ligne!

Prend autant de préfixes que nécessaire de chacun des mots suivants:

amusers
carabinero
foraminiferans
photosensitizers
videoconferencings
radiopharmaceuticals

Imprime ces mots dans un tableau:

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

Bubblegum , 66 octets

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.

Sortie:

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

Essayez-le en ligne!

Les mots et le séparateur ont été sélectionnés par recuit simulé:

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:])))

Bubblegum , 78 octets

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

Essayez-le en ligne!

Ruby, 107 octets

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 le tableau suivant.

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

La modification de pfor puts(avec un espace de fin) génère les éléments suivants pour un coût de 4 octets supplémentaires.

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

Japt , 119 octets

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

Essayez-le en ligne!

Impressions:

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