Come seguito alla mia precedente sfida, conta fino a 20 con Words! , utilizzeremo ancora una volta l'elenco di parole di quella sfida per svolgere un'altra attività. Questa volta, utilizzerai esclusivamente:

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

Per scegliere 26 parole diverse, ognuna che inizia con una lettera univoca e le emette in ordine crescente dalla A alla Z. Ecco un esempio valido:

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

Questo è un aardwolf , questo è un hawfinch , questo è un kalanchoe , questo è un nudibranch e un goletrap .

Regole

• Nessuna lettura direttamente dal repository o altre scappatoie.
• Puoi selezionare 26 parole tra quelle fornite nel link .
  • Scegli le parole e queste sono le parole che il tuo programma dovrebbe emettere ogni volta.
• È necessario selezionare una parola che inizia con ciascuna delle seguenti lettere:
  • [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]
• Questo è code-golf , vince il conteggio dei byte più basso.

Qualche altro suggerimento per gli spin-off usando gli elenchi di parole?

Inoltre, sentiti libero di rubare i miei elenchi di parole e fare sfide.

Bubblegum , 100 99 byte

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

Provalo online!

Produzione:

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

Le parole sono state nuovamente selezionate con ricottura simulata:

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 byte

Per ogni lettera iniziale, genera la prima parola che termina in -inesses o la prima parola disponibile.

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

dimostrazione

let f =

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

o.innerHTML = f()

<pre id=o></pre>

Gelatina , 69 byte

Questo è l'approccio ingenuo che può essere migliorabile da alcune zecche intelligenti

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

Provalo online!

(Suppone che "I separatori validi sono caratteri non alfabetici stampabili ASCII (numeri pari, non importa)" vale per la sfida precedente)

Gelatina , 49 byte

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

Provalo online!(Richiede circa 22 secondi su TIO)

Uscite:

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

Come funziona

“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 byte

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

Ho salvato 36 byte grazie a Jonathan Allan, che ha fatto la maggior parte del duro lavoro per questo (ho appena trovato le parole: P)

Provalo online!

Japt , 169 107 byte

`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

Provalo online!

Ho scritto un programma che mi aiuta a ottimizzare la compressione. Ordina un elenco in base alle dimensioni di compressione shoco .

Japt , 85 byte

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

dove le due coppie di backtick rappresentano stringhe di caratteri stampabili e non stampabili apparentemente casuali. Provalo online! Produzione:

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

Spiegazione

La tecnica di base è:

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.

Ho scoperto cozinessescominciando da nessescome altre risposte hanno usato e trovando ripetutamente la lettera precedente che appariva tra la maggior parte delle 26 lettere. Poiché le tecniche avide non sono spesso ottimali, in seguito ho scritto una sceneggiatura per trovare la vera parola ottimale:

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

^{(Non mi interessa che sia incredibilmente brutto. Ecco come PPCG mi ha insegnato a programmare: P Non preoccuparti, non lo faccio in produzione.)}

Ad ogni modo, quando eseguito nella console del browser nell'elenco di parole di 10 lettere , questo genera

[ "ozinesses", 57 ]

Il 57essendo il numero di lettere che avrebbero dovuto comparire nella stringa multilinea. Inoltre ci sono voluti circa 17 secondi sul mio computer, quindi sii paziente quando lo esegui.

Sostituendo la f=linea 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]];

puoi ottenere tutti i suffissi entro 20 caratteri da quello ottimale. (Cambiare il 20alla fine per qualcos'altro per regolare questo. Nota: questa funzione probabilmente funziona solo in Firefox). È possibile trovare un elenco di tutti i suffissi sotto 100 qui .

Ad ogni modo, da lì in poi è solo un compito trovare la parola per ogni lettera dell'alfabeto con il suffisso più lungo in comune ozinesses. Ho scritto una sceneggiatura di Japt per farlo, oltre a comprimere i prefissi necessari per me e dirmi quanto tempo sarà il programma risultante. (Dovrai incollare manualmente l'elenco delle parole tra virgolette.)

Questa spiegazione è stata probabilmente un po 'confusa, quindi sentiti libero di porre qualsiasi domanda tu possa avere.

Bubblegum , 110 106 byte

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

Provalo online!

stampe:

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 byte

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

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

Provalo online!

Come?

Inizializza isu 97(l'ordinale del personaggio a) quindi scorre un elenco formato da splituna stringa formata da spazi negli spazi che formano e printingingua le parole, incrementando iman mano che procede. La maggior parte delle voci,w , nella lista sono di lunghezza due, queste sono le parole che iniziano con la lettera alfabetica e fine a se inesses, cioè della forma:
chr(i)+w+'inesses'.
Le voci di lunghezza 6 sono nel formato:
chr(i)+w+'ies'
Questo significa che una formattazione può essere utilizzata per anteporre la lettera alfabetica e aggiungere una fine con il 'ness'tipo inserito 'i'+?+'es'quando wè breve in questo modo:
"%c%si%ses"%(i,w,"ness"*(len(w)<3))
-% c converte iin un carattere; i due %sinserti we "ness"*(len(w)<3), dove quest'ultimo è "ness"se wè corto o""se wè lungo.

SOGL V0.12 , 66 byte

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

Provalo qui!

Una semplice combinazione del dizionario con il problema che nessuna parola che inizia con X era nel dizionario SOGL, quindi ho compensato con xenotropico - il tropico era nel dizionario. E avevo bisogno di aggiungere la citazione iniziale perché altrimenti il ​​parser pensava che avesse [avviato un ciclo: /

Carbone , 84 byte

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

Provalo online! Usa la lista di parole di HermanLauenstein, ma ho salvato un byte perché mi manca f. Per una volta, un po 'competitivo anche in modalità dettagliata, che è solo 166 byte. Provalo online!

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