Verwenden der folgenden durch Längen getrennten Wortlisten:

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

Drucken Sie 1 Wort aus jeder Liste mit einer Länge n von 1 bis 20, hier ein gültiges Beispiel:

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

Alternativ (Array):

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

Alternativ (jedes druckbare nicht-alphabetische Trennzeichen außer \n):

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

Regeln

• Sie können Ihre eigenen 20 Wörter wählen.
• Die Wörter müssen von der angegebenen Github-Seite stammen, genauer gesagt:
  • 1 von 1.txt, 1 von 2.txt, etc ...
  • Beachten Sie, dass Dateien über 20.txt vorhanden sind, Sie jedoch keine Wörter über 20 Zeichen benötigen.
• Gültige Trennzeichen sind ASCII-druckbare nicht alphabetische Zeichen (gerade Zahlen, egal).
• Nur Klein- oder Großbuchstaben, wählen Sie einen aus und bleiben Sie dabei. keine titel-case erlaubt.
• Bitte verwenden Sie keine 100% Kopie meines Beispiels mit 20 Wörtern ...
  • Sie können, aber das macht keinen Spaß.
  • Sie sind wahrscheinlich sowieso suboptimal ...
• Wenn Sie die getrennten Dateien NICHT verwenden möchten und eine vollständige Liste benötigen:
  • Verwenden Sie unsorted.txt . Dies sind alle nTXT-Dateien in einer, alphabetisch sortiert.
• Beachten Sie, dass Sie NICHT direkt von der URL lesen können, da dies eine allgemeine Lücke darstellt .
• Dies ist Code-Golf , die niedrigste Byteanzahl ist der Gewinner.

Als Referenz ist die Ausgabe 229 Bytes, also schlägt alles, was darunter kommt, die Hardcodierung.

Mögliche Meta-Tag-Diskussion:

Benutzergesteuert, wo der Benutzer seine Ausgaben aus einer Liste von Möglichkeiten anpassen kann?

Jelly ,  49 35 31  30 Bytes

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

Ein niladischer Link, der eine Liste von Zeichen zurückgibt, oder ein vollständiges Programm, das diese Liste als Zeichenfolge druckt (die durch Leerzeichen getrennten Wörter).

Probieren Sie es online!

Wie?

ṫ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

... was ergibt:

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

Bisherige:

@ 35:

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

Verwenden von 10 Wörtern und ihren Präfixen der Länge 1.

@ 49

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

Einfach 20 komprimierte Wörter.

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

Probieren Sie es online!

Druckt diese Wörter, getrennt durch Leerzeichen:

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

PowerShell , 166 163 Byte

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

Probieren Sie es online!

Handoptimiert, keine Algorithmen. Die beiden Schleifen verbinden |%{ }das entsprechende Ende mit dem entsprechenden Anfang. Ich suche nach einer Möglichkeit, sie in eine Schleife zu bringen.

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

Druckt eine Liste der Wörter.

Probieren Sie es online!

Wörter, die durch Scannen von Sequenzen übereinstimmender Wörter, nach Wortanfang oder -ende und ab Länge 1 oder ab Länge 20 erhalten wurden.

Hier ist das Skript, mit dem ich es bekommen habe. _{(der Aufwärts-Start-Matching)}

Python 2 ,  126 120  112 Bytes

-8 Bytes dank Anders Kaseorg _{(Ich dachte, ich hätte dies von Python 3 migriert, aber es stellte sich heraus, dass ich es vergessen hatte!)}

Ein Port meiner Jelly-Antwort funktioniert auch in Python ...

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

Probieren Sie es online!

Drucke:

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

Probieren Sie es online!

Danke @HyperNeutrino für die Bearbeitung. Ich kehre jedoch zum alten Post zurück (Entfernen des Flags "Node.js"), da dies nichts mit Node.js zu tun hat. Es funktioniert auch perfekt in Browsern.

05AB1E , 51 Bytes

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

Probieren Sie es online!

Separator:

Liste der Wörter: 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}

Druckt Folgendes. Jedes Wort wird aus den 8 obigen Zeichenfolgen unter Verwendung der Binärziffern von jzur Auswahl erstellt. Wird bei jeder Iteration der Schleife jin Anführungszeichen minus 31 um den ASCII-Wert der Zeichen in der Zeichenfolge erhöht.

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

Pyth , 74 Bytes

Psychopathologisch abenteuerlustig

.e:"psychopathologicallyadventuresomenesses"b+bhkiR36"GGGGBKMMKKM6K6M0K0K0

Probieren Sie es online! Es gibt aus:

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

Welche, einmal formatiert ergibt:

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

Erläuterung

Der Schlüssel war, zwei Wörter zu wählen, die sich ergänzen. Ich habe mich dank eines kleinen Tools, das ich geschrieben habe, für " psychopathologisch " und " abenteuerlustig " entschieden . Unter Verwendung dieser beiden Wörter können wir für jede Länge Teilzeichenfolgen finden, die tatsächliche Wörter der bereitgestellten Liste sind . Alle möglichen Zersetzungen werden demonstriert durch:

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

Der nächste Schritt besteht darin, die Liste der Indizes für eine bestimmte Zerlegung abzurufen. Für meine Zersetzung, entschied ich mich: 16 16 16 16 11 20 22 22 20 20 22 6 20 6 22 0 20 0 20 0, die Indizes in den verketteten Strings sind: psychopathologicallyadventuresomenesses.

Schreiben Sie schließlich ein Programm, das nur die Indizes durchläuft und die Teilzeichenfolge bei jedem angegebenen Index mit zunehmender Länge anzeigt.

Um Bytes zu sparen, habe ich die Indizes in einer Base-36-Zeichenfolge gespeichert. In GGGGBKMMKKM6K6M0K0K0der Tat ist die Liste meiner Indizes in der Basis 36 (da mein höchster Index 22 ist, hätte ich die Basis 23 verwenden können).

Programm Erklärung

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

Offensichtlicher Raum zum Golfen, aber mir ist jetzt die Zeit ausgegangen. Ich weiß, dass es länger ist als das harte Codieren, also wird es behoben, wenn ich später etwas Zeit bekomme.

05AB1E , 130 68 Bytes

-62 Bytes dank Erik dem Outgolfer

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

Probieren Sie es online!

Nimmt von jedem der folgenden Wörter so viele Präfixe wie nötig:

amusers
carabinero
foraminiferans
photosensitizers
videoconferencings
radiopharmaceuticals

Druckt diese Wörter in einem Array:

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

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

Ausgabe:

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

Probieren Sie es online!

Die Wörter und das Trennzeichen wurden durch simuliertes Tempern ausgewählt:

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

Probieren Sie es online!

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*""}

Druckt das folgende Array.

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

Das Ändern von pfor puts(mit nachfolgendem Leerzeichen) ergibt das Folgende zu einem Preis von zusätzlichen 4 Bytes.

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 ·

Probieren Sie es online!

Drucke:

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