Find Abecedarian Words

Question

An Abecedarian Word is a word whose letters are in alphabetical order. Your goal is to write a program that outputs all abecedarian words from a given lexicon.

Rules:

1. Standard Loopholes are forbidden.

2. If a word contains punctuation, diacritical marks, or any characters other than ASCII alphabet characters (A-Za-z), remove the entire word.

3. Words that are abecedarian in ASCII are not necessarily abecedarian for this challenge. For example 'Maddox' shouldn't be considered abecedarian.

4. Your program should work with any lexicon, but for testing purposes, this one can be used. (If my code works properly) It contains 588 587 abecedarian words that follow the above rules. The lexicon does not count towards your byte total. https://gist.githubusercontent.com/wchargin/8927565/raw/d9783627c731268fb2935a731a618aa8e95cf465/words

5. As per the request of @Olivier Grégoire, here are the Abecedarian words from the lexicon:

   A Abbott Abby Abe Abel Ac Acrux Aden Ag Ainu Al Alps Am Amos Amy Ann Apr Ar Art As At Au Av B BMW Be Begin Bell Bellow Ben Benny Benz Berry Bert Bess Best Betty Bi Biko Bill Billy Bk Blu Boru Br Btu C Cd Celt Cf Chi Chimu Chou Ci Cl Cm Co Coors Cory Cox Coy Cr Crux Cruz Cs Cu D Dee Deimos Deity Del Dell Dem Denny Depp Di Dino Dior Dis Dix Dot Dow Dr E Eggo Elmo Eloy Emmy Emory Enos Er Es Eu F Finn Finns Flo Flory Fm Fox Fr Fry G Gil Gill Ginny Gino Ginsu Gipsy Guy H Hill Hiss Ho Hz I Ill In Io Ir It Ivy J Jo Joy Jr K Knox Kory Kr L Ln Lot Lott Lou Lr Lt Lu Luz M Mn Mo Moor Moors Mort Moss Mott Mr Mrs Ms Mt N Nov Np O Oort Orr Os Oz P Pt Pu Q R Ru Rx S St Stu T Ty U V W X Y Z a abbess abbey abbot abet abhor abhors ably abort abuzz accent accept access accost ace aces achoo achy act ad add adder adders adds adept ado adopt ads adz aegis aery affix afoot aft aglow ago ah ahoy ail ails aim aims air airs airy all allot allow alloy ally almost alms am ammo amp amps an annoy ant any apt art arty as ass at ax ay b be bee beef beefs beefy been beep beeps beer beers bees beet befit beg begin begins begot begs bell bellow bells belly below belt bent berry best bet bevy bill billow billowy bills billy bin bins biopsy bit blot blow boo boor boors boos boost boot booty bop bops boss bossy bow box boy brr buy buzz by c cell cello cellos cells cent chi chill chills chilly chimp chimps chin chino chinos chins chintz chip chips chit choosy chop choppy chops chow city clop clops clot cloy coo coop coops coos coot cop cops copy cost cosy cot cow cox coy crux cry cs d deem deems deep deeps deer deers deft defy deity dell dells demo demos den dens dent deny dew dewy dill dills dilly dim dims din dins dint dip dips dirt dirty dis diss ditty divvy do door doors dopy dory dos dot dotty dry e eel eels eery effort egg eggs egis ego egos eh ell ells elm elms em empty ems emu envy err errs es ex f fill fills filly film films filmy fin finny fins fir firs first fist fit fix fizz floor floors flop floppy flops floss flow flu flux fly foot fop fops for fort forty fox foxy fry fuzz g ghost gill gills gilt gimpy gin gins gipsy girt gist glop glory gloss glossy glow gnu go goo goop gory got gs guy h hi hill hills hilly hilt him hims hint hip hippy hips his hiss hit ho hoop hoops hoot hop hops horsy hos host hot how i ill ills imp imps in inn inns ins is it ivy j jot joy k kW knot knotty know ks l lo loop loops loopy loot lop lops lorry loss lost lot low lox ls m moo moor moors moos moot mop mops moss mossy most mow ms mu my n no nor nosy not now nu o oops opt or ow ox p pry psst q r rs s sty t tux u v w x y z
   

6. This is code-golf, so the shortest code in bytes wins!

Answer 1

Jelly, 9 bytes

fØẠŒlÞ$ƑƇ

Try it online!

-3 bytes thanks to Nick Kennedy

fØẠŒlÞ$ƑƇ  Main Link
        Ƈ  Keep elements that are
       Ƒ   Invariant when
.[][.]$    Last two links combined, but [ØẠ][ŒlÞ] is an LCC, so it takes another
f          Filtered to keep
 ØẠ        Alphabetical characters
     Þ     And sorted by
   Œl      Lowercase

Basically, "keep elements that are invariant when you filter out non-alphabetical characters and sort alphabetically". Jelly's sort is stable.

Answer 2

05AB1E, 6 bytes

Ties a stone arachnid's Vyxal answer for #1.

áʒlD{Q

Try it online!

áʒlD{Q  # full program
áʒ      # all elements of...
        # implicit input...
á       # containing only letters...
 ʒ      # where...
        # (implicit) current element in filter...
  l     # in lowercase...
     Q  # is equal to...
   D    # (implicit) current element in filter...
  l     # in lowercase...
    {   # sorted
        # (implicit) exit filter
        # implicit output

Answer 3

JavaScript (ES6), 68 bytes

a=>a.filter(w=>(w=w.toLowerCase())==w.match(/[a-z]/g).sort().join``)

Try it online!

Answer 4

Raku, 32 36 bytes

*.grep:{!/<-[a..z]>/&[le] .comb}o&lc

Try it online!

*.grep: filters the input list on the provided predicate function, which is combined from two other functions using the o function composition operator. The right function (the first to be applied) is the built-in lowercasing function lc. The left, brace-delimited function contains the main logic for this challenge. That function contains two checks, separated by &.

/<-[a..z]>/ is a regex that matches any character other than the lowercase Latin letters "a" through "z". The leading ! negates that test, matching only words containing no such characters.

.comb splits the input string into individual characters. [le] reduces that list of characters with le, which is the less-than-or-equal operator for strings. That's equivalent to char₁ le char₂ le ... le charₙ, which is true if the sequence of characters is lexically monotonically nondecreasing.

Answer 5

R, 89 76 bytes

function(d,`+`=lapply)d[gsub('[^A-Z]',21,d+toupper)+utf8ToInt+is.unsorted<1]

Try it online!

Implemented as function taking a strings vector and filtering non-abecedarians out

Steps:

1. make the string uppercase
2. replace any non letter character with '21' (i.e. two descending ASCII char)
3. turn strings into ASCII code points
4. take only the strings where the code points are sorted

Answer 6

J, ³⁴ 32 bytes

#~(-:-.&Alpha_j_-.~[/:toupper)&>

Try it online!

^{-2 thanks to xash}

• #~ Filter by...
• (-:]/:toupper)&> Words that are equal to themselves when sorted by their uppercase values...
• -. And then removing...
• -.&Alpha_j_ All characters not in [A-Z][a-z].

Answer 7

><>, 86 bytes

10i::}:0(?;a=?v:'['(?v::'`{'@)@(*@:@1+(@}**{10.
+$0.?v0[>100. >~~31. >' ␕'@
  =0l< o^?

Try it online! (The ␕ represents the character 0x15.)

Verification

It takes a few minutes, but it works:

C:\Users\conorob\Programming\fish
λ time python fish.py abc.fish <words.txt >out.txt

real    5m18.932s
user    0m0.000s
sys     0m0.031s

C:\Users\conorob\Programming\fish
λ wc out.txt
 587  587 3209 out.txt

Process

First, I like to get a functional program working, even if it is not golfy. 133 bytes:

1001.
>i::}:0(?;a=?v:'['(?v    >::'`{'@)@(*@:@1+(@}**{
                    >' '+^
             >~~?v0[ >1001.
                 >l?!^o

There's a lot of wasted whitespace in this one. So, first, I'll flip line 3 up onto line 1. Then, I'll reorganize the last two lines to occupy more of the trailing spaces, including reversing the last line. 113 bytes:

1001.               >' '+v
>i::}:0(?;a=?v:'['(?^    >::'`{'@)@(*@:@1+(@}**{
     0[>1001.>~~?v
      o^!?l      <

Now that the last line is more flexible, we can move even more of the last two lines into the leading whitespace. 101 bytes:

1001.               >' '+v
>i::}:0(?;a=?v:'['(?^    >::'`{'@)@(*@:@1+(@}**{
 ~~?v0[>1001.>
   l< o^!?

I tried reversing lines 3/4, but that ended up longer because the direction changed. But, now that we made more room on line 3, we can reverse the lowercase procedure back onto line 2. However, to do this, we need to make line 3 jump back to its start before it reaches the lowercase procedure. This is easy to do, since we have a spare leading whitespace. 92 bytes:

1001.
>i::}:0(?;a=?v:'['(?v    >::'`{'@)@(*@:@1+(@}**{
 ~~?v0[>1001.>02.   >' '+^
   l< o^!?

We can shave that wasted space in the loop using a very questionable technique. 91 bytes:

1001.
>i::}:0(?;a=?v:'['(?v::'`{'@)@(*@:@1+(@}**{
 ~~?v0[>1001.>02.   >' ␔'@+$1.
   l< o^!?

I've replaced the unprintable 0x14 here with its unicode equivalent ␔. This bit works by generating a string ' ␔', which gives the values on the stack [char, 32, 20]. The original code computed [char+32], then resumed control flow. We want to use a jump instead of arrow directions, and the point we want to jump to is (1, 20) in the codebox. @ permutes these three values to give us [20, char, 32]. We then perform the sum and move it below 20 (+$), giving us [char+32, 20]. Then, we push 1 and jump to (1, 20) (1.).

We can shave 1 more byte, by using the last bit of extra space on line 4 to save on the ! character. 90 bytes:

1001.
>i::}:0(?;a=?v:'['(?v::'`{'@)@(*@:@1+(@}**{
 ~~?v0[>1001.>02.   >' ␔'@+$1.
 =0l< o^?

We can reorganize this once again, to eliminate the first line. This, however, is still, 90 bytes:

10i::}:0(?;a=?v:'['(?v::'`{'@)@(*@:@1+(@}**{10.
  ~~?v0[>100. >01.   >' ␕'@+$0.
  =0l< o^?

However, this gives us a little more whitespace to play with, allowing us to tuck more of our code into the leading whitespace. 86 bytes:

10i::}:0(?;a=?v:'['(?v::'`{'@)@(*@:@1+(@}**{10.
+$0.?v0[>100. >~~31. >' ␕'@
  =0l< o^?

This has reduced our Unnecessary Space Count™ to 5. At this point, I'm not quite sure where to go. By my reckoning, either the logic ('`{'@)@(*@:@1+(@}**{) must be golfed, or the fundamental structure/approach to the problem must be reworked.

Answer 8

Ruby -p, 29 + 1 = 30 bytes

$_=$_[/^#{[*?a..?z]*?*}*\s/i]

Try it online!

Uses a regex composed by the letters "a" to "z" joined by "*" to find the words.

Answer 9

Vyxal a, 9 8 6 bytes

-2 thanks to @Aaron Miller

'⇩:sǍ=

Try it Online!

'⇩:sǍ=   # Full program
         # All inputs (implicit)
'        # where...
 ⇩       # the lowercase version...
     =   # is equal to...
 ⇩:s     # the sorted lowercase version...
    Ǎ    # with only alphabetical characters
         # Implicit output

Answer 10

Java (JDK), 74 bytes

l->l.filter(s->{int p=65,r=1;for(var c:s)r=p>(p=c&95)?0:r;return p<r*91;})

Try it online!

Credits

• -2 bytes thanks to Kevin Cruijssen!

Answer 11

Zsh -F, 28 bytes

grep -xi `printf %s* {a..z}`

Attempt This Online!

An abecederian word is one which matches the regular expression ^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*$ (case insensitively).

This regex is constructed by printf %s* {a..z}, and then matched using grep. The -x implicitly adds the ^ $; the -i option makes matching case-insensitive.

Answer 12

BQN, 28 bytes

("a{"⊸⍋⊸/≡∧)∘+⟜(32×'a'⊸>)¨⊸/

Try it here!

Thanks to @DLosc for 3+4 bytes saved!

Explanation

BQN doesn't have builtins for string manipulation, so I had to manually recreate lowercasing/filtering non-alphabetical chars.

• ...¨⊸/ Filter lexicon of words...
• +⟜(32×'a'⊸>) Lowercase word
• ≡∧ Check if sorted lowercased word matches...
• "a{"⊸⍋⊸/ Remove [^a-z] from unsorted lowercased word

Answer 13

Pip -rl, 14 bytes

$LE"az"JLC_FIg

Try it online!

Explanation

             g  List of lines read from stdin (due to -r flag)
           FI   Filter on this function:
        LC_      The string, lowercased
   "az"J         and inserted between "a" and "z"
$LE              is sorted in ascending ASCII order (fold on string-less-than-or-equal)
                Output each element of the result list on a separate line (-l flag)

Answer 14

APL (Dyalog Extended), 18 14 bytes

-4 bytes thanks to Adám!

⊢⌿⍨(∧≡∩∘⎕A)¨∘⌈

Try it online!

¨∘⌈ for each uppercased word:
∩∘⎕A the word intersected with 'AB ... YZ', keeping duplicate letters.
∧ the word sorted ascending.
≡ are those strings equal?

⊢⌿⍨ select words from the input where the result is a 1.

Answer 15

Python 3.8 (pre-release), 68 bytes

lambda x:[y for y in x if y.isalpha()and sorted(f:=y.upper())==[*f]]

Try it online!

Yeah! now Python ties with Javascript!

-24 thanks to @makonede

-5 thanks to @hyper-neutrino

Answer 16

Factor + math.unicode, 68 bytes

[ [ >upper dup [ LETTER? ] ∀ swap [ <= ] monotonic? and ] filter ]

Try it online!

• [ ... ] filter Take words from the lexicon for which the quotation returns t.
• >upper Uppercase the word so case doesn't mess with the test for monotonicity later.
• dup [ LETTER? ] ∀ Does it only consist of (uppercase) letters?
• swap [ <= ] monotonic? and And is it also sorted?

Answer 17

Retina 0.8.2, 61 bytes

^
$'¶
T`L`l`^.+
^
$%'¶
O`\G.
%)`^(.+¶)(\1|.+¶.+)

Gi`^[A-Z]+$

Try it online! Link includes test cases. Explanation:

^
$'¶

Duplicate the word.

T`L`l`^.+

Lowercase the duplicate.

^
$%'¶

Duplicate the lowercased word.

O`\G.

Sort the letters of the lowercase duplicate.

^(.+¶)(\1|.+¶.+)

If the sorted lowercase equals the lowercase word, delete the lowercase and sorted lowercase, otherwise delete everything.

%)`

Run the above stages on each word separately.

Gi`^[A-Z]+$

Keep only words containing letters.

Answer 18

Charcoal, 18 bytes

ΦＡ⬤↧ι›№βλ∧μ‹λ↧§ι⊖μ

Try it online! Link is to verbose version of code. Explanation:

 Ａ                  Input as an array
Φ                   Filtered where
    ι               Current element
   ↧                Lowercased
  ⬤                 All characters satisfy
      №             Count of
        λ           Current character in
       β            Predefined variable lowercase alphabet
     ›              Is greater than
          μ         Current index
         ∧          Logical And
            λ       Current character
           ‹        Is less than
               ι    Current element
              §     Indexed by
                 μ  Current index
                ⊖   Decremented
             ↧      Lowercased

Answer 19

perl, 59

say if /^[A-Za-z]+$/ and lc($_) eq join "",sort map {lc} @F

Try it online!

Answer 20

Python 3, 68 bytes

lambda x:re.findall(f"^{26*'%c*'}$"%(*range(65,91),),x,10)
import re

Try it online!

Python had already a solution (here) but it didn't worked on tests with char like (éèàÈ...).

How it works :

• re.findall returns all the occurences of a given pattern in a given string.
• f"^{26*'%c*'}$"%(*range(65,91),) produce the pattern ^A*B*C*...Y*Z*$ which will match any upper abecedarian word.
• 10 (=2|8) passed in argument to re.findall sets the flag re.IGNORECASE (=2) to disable caseCheck in the string and the flag re.MULTILINE (=8) which apply the pattern to each line of the string.

Answer 21

Perl 5 + -lF -M5.10.0, 28 bytes

/@{[sort map lc,@F]}/xi&&say

Try it online!

Answer 22

Red, 88 bytes

func[b][a: charset[#"a"-#"z"]remove-each w b[any[w <> sort copy w not parse w[any a]]]b]

Try it online!

Answer 23

Japt v2.0a0 -f, 7 bytes

Not entirely sure I've understood the spec correctly.

¶ñv o\l

Try it

Answer 24

Java 8, 127 bytes

l->l.filter(s->(s=s.toLowerCase()).matches("[a-z]+")&java.util.Arrays.equals(s.chars().toArray(),s.chars().sorted().toArray()))

Full Program (must be run locally)

Java 16, 124 bytes

l->l.filter(s->(s=s.toLowerCase()).matches("[a-z]+")&s.chars().boxed().toList().equals(s.chars().sorted().boxed().toList()))

Java 16 added the Stream#toList method.

Answer 25

Julia, 55 bytes

x->x[@.all(isletter,x)isascii(x)issorted(lowercase(x))]

Try it online!

Answer 26

C (gcc), 164 bytes

#include<stdio.h>
a;main(){for(char*s,w[99];!feof(stdin);!a&&printf("%s\n",w),a=0)for(scanf("%s",s=w);*s;a|=tolower(*s++)>tolower(*s)&&isalpha(*s))a|=!isalpha(*s);}

Try it online!

Answer 27

Wolfram Language (Mathematica), 67 bytes

Assumes the Notebook environment. Otherwise an extra Print needs to be added around the last part of the code (as is done in the TIO link).

f=(a=Characters@ToLowerCase@#;a==AlphabeticSort@a)&/@#&;l~Pick~f[l]

This code assumes a lexicon has been defined previously and saved in the variable l. It maps the function f over each word in the lexicon and keeps only words for which f returns True. f in turn takes in a word, lowercases it, and then puts the letters in the string individually into a list. It returns true if the list does not change when AlphabeticSort is run on it. AlphabeticSort takes in a list of strings and sorts them in alphabetic order into a new list. The ToLowerCase function call is needed because AlphabeticSort sorts lowercase letters before their uppercase version, and so f fails to find "Oort" because it gets sorted into {"o","O","r","t"}, which doesn't match the original character order.

Try it online!

Answer 28

Burlesque, 9 bytes

)zz:aa:so

Try it online!

)zz # Map to lower case
:aa # Filter all alpha
:so # Filter sorted

Answer 29

brev 166 bytes!

(import srfi-13(chicken sort))(for-each print(filter(o(fn(equal? x(strse x "^[a-z]+$"(as-list(fn(sort x(bi-each < char->integer))))#f)))string-downcase)(read-lines)))