39

Utilizzando i seguenti elenchi di parole separati in lunghezza:

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

Stampa 1 parola da ogni elenco di lunghezza n da 1 fino a 20, ecco un esempio valido:

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

In alternativa (array):

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

In alternativa (qualsiasi separatore non alfabetico stampabile diverso da \n):

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

Regole

Puoi scegliere le tue 20 parole.
Le parole devono provenire dalla pagina di github fornita, in particolare:
- 1 da 1.txt, 1 da 2.txt, ecc ...
- Nota, esistono file sopra 20.txt, ma non hai bisogno di parole oltre 20 caratteri.
I separatori validi sono caratteri non alfabetici stampabili ASCII (numeri pari, non importa).
Solo lettere minuscole o maiuscole, scegline una, mantieni; nessuna custodia del titolo consentita.
Per favore, non usare una copia al 100% del mio esempio di 20 parole ...
- Puoi, ma non è divertente.
- Probabilmente sono comunque non ottimali ...
Se NON vuoi usare i file separati e hai bisogno di un elenco completo:
- Usa unsorted.txt , si tratta di tutti i nfile .txt in uno, ordinati alfabeticamente.
Nota, NON PUOI leggere direttamente dall'URL, è una scappatoia comune .
Questo è code-golf , il conteggio di byte più basso sarà il vincitore.

Per riferimento, l'output è di 229 byte, quindi tutto ciò che viene superato batte il hardcoding.

Possibile discussione con meta-tag:

guidato dall'utente in cui l'utente può personalizzare i propri output da un elenco di possibilità?

code-golf kolmogorov-complexity natural-language

— Urna di polpo magico
fonte

4

Come qualcuno di Terranova, apprezzo lo shoutout. :)

— scatter il

6

@Christian Potresti dire che ... ( •_•)>⌐■-■ capisco l'eccezionale terranova(⌐■_■)

— Magic Octopus Urn

1

@Riley che lo sta allungando, 1 delimitatore tra ogni parola, anche se posso vedere molte situazioni in cui ciò potrebbe aiutare: P.

— Magic Octopus Urn il

1

@JonathanAllan ha appena fatto :).

— Magic Octopus Urn,

1

Utilità per la scelta delle parole.

— Jim,

19

Gelatina , 49 35 31 30 byte

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

Un collegamento niladico che restituisce un elenco di caratteri o un programma completo che stampa tale elenco come una stringa (le parole delimitate da spazi).

Provalo online!

Come?

ṫ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

... che produce:

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

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

Usando 10 parole e i loro prefissi di lunghezza 1.

@ 49

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

Semplicemente 20 parole compresse.

— Jonathan Allan
fonte

Darn dizionario Jelly! +1

— Erik the Outgolfer,

Non sapevo che Jelly avesse un dizionario, a dire il vero.

— Magic Octopus Urn,

3

30 BYTES! ?? !! ??! Sono appena andato a dormire e mi sono svegliato ed è basso quanto 30 BYTES? !! ??!?! 11 O_O_O

— Erik the Outgolfer

30 BYTES!?!?! ??! HO DIMENTICATO DI QUESTA SFIDA PER UN MESE E HA VINTO CON 30 BYTES!?!?!

— Magic Octopus Urn,

27

Python 2 , 145 byte

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

Provalo online!

Stampa queste parole, separate da spazi:

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

— Lynn
fonte

18

"I am now tiny" - Mi piace il codice auto-descrittivo ...

— trichoplax,

16

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]

Provalo online!

Ottimizzato a mano, senza algoritmi. I due loop |%{ }puntano sulla conclusione appropriata all'inizio appropriato. Sto cercando un modo per metterli in un ciclo.

— AdmBorkBork
fonte

Caspita, il mio esempio sembra ancora più stupido ora xD! characterful > newfoundland

— Magic Octopus Urn,

10

Python, 169 byte

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

Stampa un elenco delle parole.

Provalo online!

Parole ottenute scansionando sequenze di parole corrispondenti, all'inizio o alla fine della parola e partendo dalla lunghezza 1 verso l'alto o dalla lunghezza 20 parole chiave.

Ecco lo script che ho usato per ottenerlo. _{(quello verso l'alto-inizio-corrispondente)}

— Uriel
fonte

171 byte (sembra che dovrebbe essere più breve, ma non lo è): provalo online!

— Stephen,

8

Python 2 , 126 120 112 byte

-8 byte grazie ad Anders Kaseorg _{(pensavo di averlo migrato da Python 3, ma alla fine mi ero dimenticato!)}

Un port della mia risposta Jelly funziona bene anche in Python ...

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

Provalo online!

stampe:

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

— Jonathan Allan
fonte

Python 2 consente di terminare con print w[2:-1],w[2:],w[:-1],w,−8 byte.

— Anders Kaseorg,

Oh, oops mi sono dimenticato di questo o pensavo di averlo fatto - ho una pagina TIO aperta da qualche parte con quello!

— Jonathan Allan,

Grazie per quello però!

— Jonathan Allan,

6

JavaScript, 159 byte

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

Provalo online!

Grazie @HyperNeutrino per la modifica. Ma sto tornando al vecchio post (rimuovendo il flag "Node.js") perché non ha nulla a che fare con Node.js. Funziona perfettamente anche nei browser.

f=f=>_mi ha buttato via, ero tipo "non avrebbe annullato la funzione" (impedirebbe solo la ricorsione)

— Stephen

@Stefano. Non sono sicuro che sia permesso lasciare una stringa semplice. Come ho capito, il codice dovrebbe rappresentare una funzione (o l'intero programma), ecco perché l'ho aggiunto alla fine. La variabile _contiene già la stringa.

Hai ragione, ero davvero confuso su ciò che ha fatto, dal momento che hai riutilizzato il nome della variabile ( fsia come nome della funzione che (ignorato) nome del parametro)

— Stephen

6

05AB1E , 51 byte

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

Provalo online!

Separatore:

Elenco di parole: a, an, ana, anal, house, houses, amazing, criminal, seriously, apparently, accessories, disciplinary, distributions, discrimination, congratulations, responsibilities, characterizations, telecommunications, representationalist, representationalists

— Erik the Outgolfer
fonte

1

vuole partecipare alla propria sfida si intensifica

— Magic Octopus Urn il

Sto indovinando 05AB1E non ha parole di 20 lunghezze nel dizionario: P? Devo ancora controllare me stesso.

— Magic Octopus Urn,

@MagicOctopusUrn Nope .

— Adnan,

@adnan wow, quell'approccio ... in realtà potrebbe essere una buona idea se riesci a trovare un modo per generare tutti i punti di codice del dizionario in 1-10byte simili ...

— Magic Octopus Urn

1

@adnan è stato il mio primo tentativo, sono sicuro che potresti buttarlo fuori dal parco.

— Magic Octopus Urn,

5

Rubino, 120 byte

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}

Stampa quanto segue. Ogni parola è costruita dalle 8 stringhe sopra, usando le cifre binarie di jper selezionare. Ad ogni iterazione del ciclo, jviene incrementato del valore ASCII dei caratteri nella stringa tra virgolette, meno 31.

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

— Level River St
fonte

4

Pyth , 74 byte

Psicopatologicamente avventure

.e:"psychopathologicallyadventuresomenesses"b+bhkiR36"GGGGBKMMKKM6K6M0K0K0

Provalo online! Emette:

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

Che, una volta formattato, produce:

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

Spiegazione

La chiave era scegliere due parole che si completano a vicenda. Ho scelto " psicopatologicamente " e " avventure " grazie a un piccolo strumento che ho scritto . Usando queste due parole, per qualsiasi lunghezza possiamo trovare sottostringhe che sono parole effettive dell'elenco fornito . Tutte le possibili decomposizioni sono dimostrate da:

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

Il prossimo passo è solo quello di ottenere l'elenco degli indici per una data decomposizione. Per il mio decomposizione, ho scelto: 16 16 16 16 11 20 22 22 20 20 22 6 20 6 22 0 20 0 20 0, quali sono gli indici delle stringhe concatenate: psychopathologicallyadventuresomenesses.

Infine, scrivi un programma che si sposta semplicemente sugli indici e visualizza la sottostringa in corrispondenza di ciascun indice con lunghezza crescente.

Per salvare i byte, ho archiviato gli indici in una stringa 36 base. In effetti, GGGGBKMMKKM6K6M0K0K0è l'elenco dei miei indici nella base 36 (poiché il mio indice più alto è 22, avrei potuto usare la base 23).

Spiegazione del programma

.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

— Jim
fonte

psicopatologicamente - "In termini di studio scientifico dei disturbi mentali". Interessante.

— Magic Octopus Urn,

3

C #, 259 byte

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

Qualche spazio ovvio per giocare a golf, ma ormai ho poco tempo. So che è più lungo della codifica difficile, quindi lo risolverò quando avrò un po 'di tempo dopo.

— TheLethalCoder
fonte

Woops in realtà è ancora più lungo perché devo includereusing System.Linq;

— TheLethalCoder il

4

Restituirli in una stringa divisa per spazi è come 245.

— Magic Octopus Urn

@MagicOctopusUrn So che è quello che ho detto nella mia risposta ...

— TheLethalCoder

3

05AB1E , 130 68 byte

-62 byte grazie a Erik the Outgolfer

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

Provalo online!

Prende tutti i prefissi necessari da ciascuna delle seguenti parole:

amusers
carabinero
foraminiferans
photosensitizers
videoconferencings
radiopharmaceuticals

Stampa queste parole in un array:

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

— Riley
fonte

È possibile giocare a golf in modo significativo (-43).

— Erik the Outgolfer,

E un altro -13.

— Erik the Outgolfer,

Qualche altro -6 troppo ... (purtroppo non posso sostituire 743222con •B/™•)

— Erik l'Outgolfer

Sì, non è necessario, Squindi sono -62 byte. ;)

— Erik the Outgolfer,

@EriktheOutgolfer Grazie! Stavo cercando di fare qualcosa del genere, ma non riuscivo a farlo funzionare. Ti dispiace spiegare come funzionano le stringhe compresse?

— Riley,

3

Bubblegum , 66 byte

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.

Produzione:

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

Provalo online!

Le parole e il separatore sono stati selezionati mediante ricottura simulata:

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

— Anders Kaseorg
fonte

2

Bubblegum , 78 byte

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

Provalo online!

— OVS
fonte

2

Rubino, 107 byte

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

Stampa il seguente array.

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

La modifica di pfor puts(con spazio finale) comporta quanto segue al costo di ulteriori 4 byte.

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

— Level River St
fonte

1

Japt , 119 byte

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

Provalo online!

stampe:

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

— Oliver
fonte

Conta fino a 20 con Words!

Regole

Gelatina , 49 35 31 30 byte

Come?

Python 2 , 145 byte

PowerShell , 166 163 byte

Python, 169 byte

Python 2 , 126 120 112 byte

JavaScript, 159 byte

05AB1E , 51 byte

Rubino, 120 byte

Pyth , 74 byte

C #, 259 byte

05AB1E , 130 68 byte

Bubblegum , 66 byte

Bubblegum , 78 byte

Rubino, 107 byte

Japt , 119 byte

stampe: