15
\$\begingroup\$

As a follow up to my previous challenge Count to 20 with Words!, we will once again be using the word list from that challenge to perform another task. This time, you will be exclusively using:

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

To choose 26 different words, each starting with a unique letter, and output them in ascending order from A to Z. Here's a valid example:

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

This is an aardwolf, this is a hawfinch, this is a kalanchoe, this is a nudibranch and a wentletrap.


Rules

  • No reading directly from the repository, or any other loopholes.
  • You may select any 26 of the words provided in the link.
    • You choose words and these are the words your program should output every time.
  • One word beginning with each of the following letters must be selected:
    • [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]
  • This is , lowest byte-count wins.

Any other suggestions for spin-offs using the word lists?

Also, feel free to steal my word-lists and make challenges.

\$\endgroup\$
  • 1
    \$\begingroup\$ hey, just a small nitpick, the "previous challenge link" links to an answer, not to the challenge itself \$\endgroup\$ – Rod Jul 27 '17 at 16:41
  • 1
    \$\begingroup\$ Is the output required to be separated with newlines, or can the output be an array/separated with another delimiter? \$\endgroup\$ – Herman L Jul 27 '17 at 17:10
  • \$\begingroup\$ I'm disappointed that a nudibranch isn't a bank in a nudist colony. \$\endgroup\$ – Draco18s Jul 27 '17 at 17:34
  • 5
    \$\begingroup\$ The rules include 'q' but the example does not. \$\endgroup\$ – trichoplax Jul 27 '17 at 17:53
  • \$\begingroup\$ Aardwolves are freaking adorable. \$\endgroup\$ – MikeTheLiar Jul 27 '17 at 20:25

12 Answers 12

6
\$\begingroup\$

Bubblegum, 100 99 bytes

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

Try it online!

Output:

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

The words were again selected with simulated annealing:

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)))
\$\endgroup\$
  • \$\begingroup\$ uglinesses is a possibility for the letter U that you missed, but this doesn't help much, since you still have Q, X, and Y to deal with. Nothing comes to mind for those. \$\endgroup\$ – Cody Gray Jul 28 '17 at 4:36
  • \$\begingroup\$ @CodyGray The program chose all the words automatically from the entire dictionary, so no missing was involved, but I think it likes uneasiness for compressing well with easinesses and queasiness. It’s very consistent about those choices. \$\endgroup\$ – Anders Kaseorg Jul 28 '17 at 4:54
5
\$\begingroup\$

JavaScript (ES6), 168 bytes

For each starting letter, outputs either the first word ending in -inesses or the first available word.

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

Demo

let f =

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

o.innerHTML = f()
<pre id=o></pre>

\$\endgroup\$
4
\$\begingroup\$

Jelly, 69 bytes

This is the naive approach it may be improvable by some clever ticks

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

Try it online!

(Assumes that "Valid separators are ASCII-printable non-alphabetical characters (even numbers, don't care)" holds from the previous challenge)

\$\endgroup\$
4
\$\begingroup\$

Jelly, 49 bytes

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

Try it online! (Takes about 22 seconds on TIO)

Outputs:

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

How it Works

“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
\$\endgroup\$
3
\$\begingroup\$

Python 2, 256 231 220 bytes

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

Saved 36 bytes thanks to Jonathan Allan, who did most of the hard work for this (I just found the words :P)

Try it online!

\$\endgroup\$
  • \$\begingroup\$ Some changes here using your approach to save 25 bytes. (move to Python 2 to save one more with print) \$\endgroup\$ – Jonathan Allan Jul 27 '17 at 17:55
  • \$\begingroup\$ Actually even more here \$\endgroup\$ – Jonathan Allan Jul 27 '17 at 17:58
  • 1
    \$\begingroup\$ 'ACK! Fishses!' - First thing I saw when looking at this code heh. \$\endgroup\$ – Magic Octopus Urn Jul 28 '17 at 13:45
3
\$\begingroup\$

Japt, 169 107 bytes

`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

Try it online!

I wrote a program that helps me optimize the compression. It sorts a list by its shoco compression size.

\$\endgroup\$
  • 1
    \$\begingroup\$ Wow, that optimization program is really cool. You forgot to replace inesses with 1 when calculating the compression length though ;) liminesses \$\endgroup\$ – ETHproductions Jul 28 '17 at 23:23
3
\$\begingroup\$

Japt, 85 bytes

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

where the two pairs of backticks represent strings of seemingly random printable and unprintable characters. Try it online! Output:

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

Explanation

The basic technique is:

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.

I found cozinesses by starting with nesses as some other answers have used and repeatedly finding the previous letter that appeared the among the most of the 26 letters. Since greedy techniques are not often optimal, I later wrote a script to find the real optimal word:

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

(I don't care that it's incredibly ugly. This is how PPCG has taught me to code :P Don't worry, I don't do this in production.)

Anyway, when run in the browser console on the 10-letter word list, this outputs

[ "ozinesses", 57 ]

The 57 being the number of letters that would have to appear in the multiline string. It also took about 17 seconds on my computer, so be patient when you run it.

By replacing the f= line with

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

you can get all suffixes within 20 chars of the optimal one. (Change the 20 at the end to something else to adjust this. Note: this function probably only works in Firefox.) You can find a list of all suffixes under 100 here.

Anyway, from there on it's just a task of finding the word for each letter of the alphabet that has the longest suffix in common with ozinesses. I wrote a Japt script to do this, as well as compress the necessary prefixes for me and tell me how long the resulting program will be. (You'll have to manually paste the word list between the quotation marks though.)

This explanation was probably somewhat confusing, so please feel free to ask any questions you may have.

\$\endgroup\$
2
\$\begingroup\$

Bubblegum, 110 106 bytes

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

Try it online!

Prints:

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
\$\endgroup\$
2
\$\begingroup\$

Javascript (ES6), 163 bytes

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

\$\endgroup\$
  • \$\begingroup\$ Nice! This translates to 144 bytes in Retina. \$\endgroup\$ – Neil Jul 27 '17 at 19:08
  • \$\begingroup\$ Heh, I just noticed this is exteremely similar to the technique in my Japt answer--I've even proven this wordlist optimal for this technique. Can you save a byte by changing /.+/g to /.*/g, -ozinesses to cozinesses, and removing the lone c? \$\endgroup\$ – ETHproductions Jul 31 '17 at 2:12
  • \$\begingroup\$ @ETHproductions that would add "cozinesses" to the end of each line, since /.*/g matches a group of 0 characters after each line. \$\endgroup\$ – Herman L Jul 31 '17 at 8:46
1
\$\begingroup\$

Python 2,  168  166 bytes

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

Try it online!

How?

Initialises i to 97 (the ordinal of the character a) then loops through a list formed by splitting a string at spaces forming and printing the words, incrementing i as it goes. Most of the entries, w, in the list are of length two, these are words that start with the alphabetic letter and end in inesses, i.e. of the form:
chr(i)+w+'inesses'.
The entries of length 6 are of the form:
chr(i)+w+'ies'
This means a formatting may be used to prepend the alphabetic letter and add an ending with the 'ness' inserted like 'i'+?+'es' when w is short like so:
"%c%si%ses"%(i,w,"ness"*(len(w)<3))
- %c converts i to a character; the two %s insert w and "ness"*(len(w)<3), where the latter is "ness" if w is short or "" if w is long.

\$\endgroup\$
  • \$\begingroup\$ Even nicer! This translates to 140 bytes in Retina. \$\endgroup\$ – Neil Jul 27 '17 at 19:14
1
\$\begingroup\$

SOGL V0.12, 66 bytes

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

Try it Here!

A simple dictionary compession with the problem that no word that starts with X was in SOGLs dictionary, so I compensated with xenotropic - tropic was in the dictionary. And I needed to add the starting quote because otherwise the parser thought that [ started a loop :/

\$\endgroup\$
0
\$\begingroup\$

Charcoal, 84 bytes

UOχ²⁶”m⌈⎚∧³δ¤↶””|↖⧴=P“⪪šl¢‘υKBSAD ⁶⁸ςz↧\–~⎇V▷–ê"℅ ž⟲‹‹⮌0Bff5Y⪪E?Þ¹@)⟦£δT⪪⌕↙]\RZ_Q‹″”

Try it online! Uses @HermanLauenstein's wordlist, but I saved one byte because I can miss out the f. For once, somewhat competitive even in in verbose mode, which is only 166 bytes. Try it 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")
\$\endgroup\$
  • 2
    \$\begingroup\$ Why did you score this as 166 instead of 84? \$\endgroup\$ – Conor O'Brien Jul 29 '17 at 0:44
  • \$\begingroup\$ @ConorO'Brien I just thought it was amusing that I was still tying with Python. \$\endgroup\$ – Neil Jul 29 '17 at 9:53

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.