作为我先前挑战的跟进，单词数达到20！，我们将再次使用该挑战中的单词列表来执行其他任务。这次，您将专门使用：

https://github.com/魔术八爪鱼缸/wordListsByLength/blob/master/10.txt

要选择26个不同的单词，每个单词都以一个唯一的字母开头，并按从A到Z的升序输出。这是一个有效的示例：

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

这是一个阿德沃夫，这是一种蜡嘴鸟，这是一个长寿，这是一个裸鳃亚目和海蛳螺科。

规则

• 不能直接从存储库中读取内容，也不能发现任何其他漏洞。
• 您可以从链接中选择任何26个单词。
  • 您选择单词，这些是您的程序每次应输出的单词。
• 必须选择一个以以下每个字母开头的单词：
  • [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]
• 这是代码高尔夫球，最低字节数获胜。

关于使用单词列表进行分拆的其他建议吗？

另外，请随时窃取我的单词列表并提出挑战。

泡泡糖，100 99字节

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

在线尝试！

输出：

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

通过模拟退火再次选择单词：

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个字节

对于每个起始字母，输出以-inesses结尾的第一个单词或第一个可用单词。

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

演示版

let f =

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

o.innerHTML = f()

<pre id=o></pre>

果冻，69 字节

这是一种幼稚的方法，有些聪明的some子可能会改善它

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

在线尝试！

（假定“有效分隔符是ASCII可打印的非字母字符（偶数，无关紧要）”成立于上一个挑战）

果冻，49字节

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

在线尝试！（在TIO上花费约22秒）

输出：

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

怎么运行的

“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字节

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

多亏了乔纳森·艾伦（Jonathan Allan）节省了36个字节，乔纳森·艾伦（Jonathan Allan）为此做了大部分辛苦的工作（我刚刚发现了：P）

在线尝试！

Japt，169个 107字节

`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

在线尝试！

我写了一个程序来帮助我优化压缩。它按shoco压缩大小对列表进行排序。

Japt，85字节

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

其中两对反引号代表看似随机的可打印和不可打印字符的字符串。在线尝试！输出：

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

说明

基本技术是：

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.

我发现cozinesses从使用nesses其他答案开始，然后反复找到出现在26个字母中最多的一个字母。由于贪婪的技巧通常不是最优的，我后来写了一个脚本来寻找真正的最优词：

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

^{（我不在乎它的丑陋如何。PPCG就是这样教我编码的：P不用担心，我不在生产中这样做。）}

无论如何，当在浏览器控制台中的10个字母的单词列表上运行时，此输出

[ "ozinesses", 57 ]

的57地位，这将不得不出现在多串的字母数。在我的计算机上也花费了大约17秒的时间，因此请耐心等待。

通过更换f=带有线

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

您可以在最佳字符数的20个字符以内获得所有后缀。（20将末尾的更改为其他内容以对此进行调整。注意：此功能可能仅在Firefox中有效。）您可以在此处找到100以下所有后缀的列表。

无论如何，从那里开始，只是为与后缀相同的最长字母的每个字母查找单词ozinesses。我编写了一个Japt脚本来执行此操作，以及为我压缩必要的前缀，并告诉我所生成的程序将持续多长时间。（不过，您必须手动将单词列表粘贴在引号之间。）

这种解释可能有些混乱，所以请随时问您可能有的任何问题。

泡泡糖，110个 106字节

十六进制转储：

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

在线尝试！

印刷品：

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个字节

_=>`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字节

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

在线尝试！

怎么样？

初始化 i为97（字符的序数a），然后循环遍历一个列表，该列表是通过split在形成和print输入单词的空格处键入字符串而形成的，并i随其递增。w列表中的大多数条目的长度为2，这些单词以字母开头并以结束inesses，即形式为：
chr(i)+w+'inesses'。
长度为6的条目采用以下形式：
chr(i)+w+'ies'
这意味着可以使用格式设置在字母前面加上一个结尾（'ness'例如，'i'+?+'es'当wshort 时），例如：
"%c%si%ses"%(i,w,"ness"*(len(w)<3))
-％c转换i为字符；两个%s插入件w和"ness"*(len(w)<3)，其中是后者"ness"，如果w是短或""如果w很长。

SOGL V0.12，66 个字节

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

在这里尝试！

一个简单的字典转换存在以下问题：SOGLs字典中没有以X开头的单词，因此我用异质补偿了-tropic在字典中。而且我需要添加起始引号，因为否则解析器认为[启动了循环：/

木炭，84字节

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

在线尝试！使用@HermanLauenstein的单词表，但我节省了一个字节，因为我可能会错过f。一次，即使在冗长的模式（仅166字节）中也有些竞争力。在线尝试！

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