Check whether letters of word are in alphabetical order

Question

Write a function/program that accepts a string of lower/uppercase letters [A-Za-z] as input, that checks whether the occuring letters are unique and in alphabetical order (ignoring lower and uppercase) or not. The output must be truthy if they are unique and in alphabetical order and falsy if not.

Here some testcases

a                           true
abcdefGHIjklmnopqrSTUVWXyz  true     
aa                          false
puz                         true
puzz                        false
puzZ                        false
puZ                         true
PuZ                         true
pzu                         false
pzU                         false
abcdABCD                    false
dcba                        false

If you want, run your program on all words of a wordlist like this one and and post some interesting ones =).

Score

Lowest number of bytes wins.

Answer 1

CJam, 8 bytes

lel_$_&=

Here is a test harness for all examples in the challenge. This returns 0 or 1 (which are falsy and truthy, respectively, in CJam).

And here is a script to filter the word list in the question (takes a few seconds to run). You'll have to copy the word list into the input field manually, because it's too long for a permalink.

Explanation

l        "Read input.";
 el      "Convert to lower case.";
   _$    "Get a copy and sort it.";
     _&  "Remove duplicates (by computing the set intersection with itself).";
       = "Check for equality with original (lower case) word.";

Answer 2

Regex (any flavor), 55 bytes

Some people don't consider regex to be a programming language, but it's been used before, and it's not close to being the shortest.

^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?$

I've added one byte for the i (case-insensitive) flag. This is very straightforward and might be shorter to generate on the fly.

If regex alone are not allowed, you can use this 56-byte Retina program suggested by Martin Büttner:

i`^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?$

Running this on the wordlist linked above yielded 10 6-letter words in alphabetical order.

["abhors", "almost", "begins", "begirt", "bijoux", "biopsy", "chimps", "chinos", "chintz", "ghosty"]

Answer 3

Python 3, 44 bytes

*s,=input().lower()
print(sorted(set(s))==s)

A simple approach - check uniqueness, check sortedness.

Answer 4

><>, 52 42 39 bytes

0>i:1+?v1n;
? )'`':/'@'v
0v?){:-<'`'/;n

This type of question is one of the few types that ><> is pretty comfortable with, since we only need to deal with one char at a time.

Explanation

Don't get lost! There's a lot of wrapping here.

0            Push 0. We'll be mapping a-z to 1-26, so 0 will be smaller than everything

(loop)
i            Read a char of input
:1+? 1n;     If there's no more input, print 1
:'`')?       If the char is bigger than backtick...
  '`'          Push backtick  (which is one before 'a'), else...
  '@'          Push an @ sign (which is one before 'A')
-            Subtract, mapping a-z to 1-26
:{)?         If the new char is bigger than the previous char...
               Repeat from the beginning of the loop, else...
  0n;          Print 0

Previous solution, 42 bytes

0i:1+?v1n;n0/\!
?)'`':/'@'v
? ){:-<'`'/ vv

The interesting thing is that, despite appearing to have the same functionality, the alternative

0i:1+?v1n;n0\/!
?)'`':/'@'v
? ){:-<'`'/ ^^

(The change is in the arrows and mirrors on the far right)

actually gives incorrect results, due to ><>'s interpreter using a Python defaultdict. What happens is that, by traversing through the empty space at the end of the second row, 0s are implicitly placed into the blank spaces when ><> tries to access the cell. This then messes with the ? conditional trampoline at the beginning of the same row, as the newly placed 0s are skipped rather than the v at the end.

Answer 5

Haskell, 52 Bytes

import Data.Char
and.(zipWith(>)=<<tail).map toLower

Usage: (and.(zipWith(>)=<<tail).map toLower) "abcd" which outputs True.

Answer 6

C, 67 65 57 54 (52) characters

f(char*s){int c,d=0;for(;(c=*s++)&&(c&~32)>(d&~32);d=c);return!c;}

a little shorter:

f(char*s){int c,d=0;for(;(c=*s++)&&(c&~32)>d;d=c&~32);return!c;}

and even shorter:

f(char*s){int d=32;for(;(*s|32)>d;d=*s++|32);return!*s;}

Here's a little test: http://ideone.com/ZHd0xl

After the latest suggestions here are still two shorter versions:

// 54 bytes
f(char*s){int d=1;for(;(*s&=95)>d;d=*s++);return!*s;}

// 52, though not sure if valid because of global variable
d;f(char*s){d=1;for(;(*s&=95)>d;d=*s++);return!*s;}

Also this code relies on the fact, that in ASCII lowercase and uppercase only differ by the 5th bit (32) which I filter out. So this might not work with other encodings obviously.

EDIT: The latest version always sets the 5th bit as |32 is shorter than &~32.

Answer 7

Ruby, 33

->s{c=s.upcase.chars
c==c.sort|c}

Checks to see if the sorted unique characters are the same as all the characters.

Answer 8

Javascript (ES5), 101

function i(s){b=0;l=''.a
s.toUpperCase().split('').forEach(function(c){if(c<=l)b=1
l=c})
return!b}

Improved to 87 by edc95:

upvote his comment :)

function i(s){return!s.toUpperCase().split(l='').some(function(c){return(u=l,l=c)<=u})}

Btw, the test cases currently in OP are fulfilled if a program is only checking uniqueness, disregarding order.

---

I cant write comments yet, so I'll answer some remarks here:

@edc65: Thanks! I tried rewriting it using some(), but I couldn't get a shorter solution, because even though it looks like it would enable me to get rid of the superflous b variable, you need to type "return" twice (same with reduce()), and you can't just return the comparison's result directly, because the last character needs to be saved after the comparison with it.

@edc65: That's a nice use of the comma operator for 87! I edited it into my answer for more visibility.

Answer 9

Brachylog, 3 bytes

ḷ⊆Ạ

Try it online!

The predicate succeeds if the input meets the requirements outlined and fails if it does not, printing true. or false. if run as a program.

       The input,
ḷ      lowercased,
 ⊆     is a not-necessarily-contiguous sub-list of
  Ạ    "abcdefghijklmnopqrstuvwxyz".

The first version I came up with, not explicitly referencing the alphabet:

Brachylog, 4 bytes

ḷ≠.o

Try it online!

        The input,
ḷ       lowercased,
 ≠      in which every character is distinct,
  .     is the output variable,
   o    which sorted,
        is still the output variable.

Answer 10

Haskell, 90 bytes

Supplies the function f :: String -> Bool

import Data.List
import Distribution.Simple.Utils
f l=g$lowercase l
g l=sort l==l&&l==nub l

Usage (assuming it is saved as golf.hs). ... is used to replace ghci's verbose loading messages.

$ ghci golf.hs
...
*Main> f "as"
...
True
*Main> f "aa"
False

If someone has a lowercase method shorter than import Distribution.Simple.Utils then please comment.

Answer 11

Wolfram Mathematica, 49 37 bytes

f[x_]:=(l=Characters[ToLowerCase[x]];Union[l]==l)

P.S. Shorter solution by Martin Büttner:

Union[l=Characters@ToLowerCase@#]==l&

Answer 12

J, 17 bytes

Checks if the lowercase sorted /:~ string equals -: the lowercase nub ~. string.

   (/:~-:~.)@tolower

   NB. testing with the example inputs
   ((/:~-:~.)@tolower) every (1$'a');'abcdefGHIjklmnopqrSTUVWXyz';'aa';'puz';'puzz';'puzZ';'puZ';'PuZ'
1 1 0 1 0 0 1 1

As in J a 1-charater long "string" represented as a regular string (with quotes) is just a character atom not a real string I formatted the input appropriately so all input would be real strings. (In the example above I used 1$'a'.)

Answer 13

MATLAB, 29 27 bytes

Now for a one-liner which even makes sense outside of code-golf.

As an anonymous function (use as o('yourstring'))

o=@(s)all(diff(lower(s))>0)

I guess this function is pretty self-explanatory since it reads like a newspaper ad.

Previous version (29 bytes):

all(diff(lower(input('')))>0)

Input must be presented between ' marks, e.g. 'Potato'.

Answer 14

R, 37 bytes

all(diff(utf8ToInt(scan(,''))%%32)>0)

Try it online!

Posting since this is substantially different and shorter than Michal's R answer.

Converts the letters to ASCII codepoints with utf8ToInt, then takes modulo 32 so that lower and upper letters are converted to the same numbers 1...26. Computes the pairwise differences, and checks that they are all positive.

Answer 15

Pure Bash 4.x, 37

[[ ${1,,} =~ ^`printf %s? {a..z}`$ ]]

Input taken as a command-line parameter. As per standard shell semantics, exit code 0 means true (alphabetic) and exit code != 0 means false (not alphabetic).

The printf creates the regex as in @hsl's solution. The input string is expanded to lowercase and compared against the regex.

---

Previous answer:

Bash + coreutils, 52

Straightforward solution:

a=`fold -1<<<${1,,}`
cmp -s <(sort -u<<<"$a")<<<"$a"

Answer 16

JavaScript (ES6) 54

Convert to uppercase, then to array and sort. If during sort two element are in the wrong order or equal, return 0 (falsy) else 1 (truthy)

Edit Shortened thx to @Optimizer (but still 2 more than the @Tamas solution implemented in ES6: F=s=>[...s.toUpperCase()].every(c=>(u=l,l=c)>u,l=''))

F=s=>[...s.toUpperCase(x=1)].sort((a,b)=>a<b?1:x=0)&&x

Test in Firefox / FireBug console

;['a','abcdefGHIjklmnopqrSTUVWXyz','aa','puz','puzz','puzZ','puZ','PuZ']
.map(w=>w+' '+F(w))

["a 1", "abcdefGHIjklmnopqrSTUVWXyz 1", "aa 0", "puz 1", "puzz 0", "puzZ 0", "puZ 1", "PuZ 1"]

Answer 17

C# 6, 18 + 82 76 = 94 bytes

Requires (18 bytes):

using System.Linq;

Code (76 bytes):

bool a(string s)=>(s=s.ToLower()).Distinct().OrderBy(x=>x).SequenceEqual(s);

C# 6 supports lambdas to define a function, which is useful for golfing.

Non-C# 6 version:

bool a(string s){return (s=s.ToLower()).Distinct().OrderBy(x=>x).SequenceEqual(s);}

Ungolfed code:

bool IsInAlphabeticalOrder(string s)
{
    s = s.ToLower();
    return s.Distinct()
            .OrderBy(x => x)
            .SequenceEqual(s);
}

Answer 18

J, 21 characters

This is too long. The argument must have rank 1, i.e. it must be a string or vector.

*/@(<=~.;/:~)@tolower

• tolower y – y in lower case.
• /:~ y – y in lexical order.
• ~. y – the nub of y, that is, y with duplicates removed.
• x ; y – x and y put into boxes and then concatenated.
• < y – y put into a box.
• x = y – x compared element-wise with y.
• (< y) = (~. y) ; (/:~ y) – a vector indicating if y is equal to its nub and itself sorted.
• */ y – the product of the items of y, or its logical and if the items are booleans.
• */ (< y) = (~. y) ; (/:~ y) – a boolean indicating the desired property for lowercase y.

Answer 19

Julia, 44 bytes

s->(l=lowercase(s);l==join(sort(unique(l))))

This creates an anonymous function that takes a single argument s, converts it to lower case, and compares it to the unique sorted version of the string. It returns a boolean, i.e. true or false. If you want to test it out, assign it like f=s->... and then call f("PuZ"), etc.

Answer 20

Perl 6, 35 bytes

{my@c=.uc.comb;@c [e-mail]}

This produces a callable block; if I could just assume that $_ is already set to the desired word, I could delete the surrounding curly braces and lose two more bytes, but probably the only reasonable way to make that assumption would be to run it with -n and feed the word as standard input, which would add the two bytes right back.

Answer 21

Golang (65 bytes)

Go is not a golf friendly language, also, i suck at golf...

func a(s[]byte)(bool){return len(s)<2||s[0]|32<s[1]|32&&a(s[1:])}

Run it here: http://play.golang.org/p/xXJX8GjDvr

edit 106->102

edit 102->96

edit 96->91

edit 91->87

edit 87->65

I beat the java version, I can stop for today

Answer 22

C (44 bytes)

f(char*s){return(*s&=95)?f(s+1)>*s?*s:0:96;}

Test it here: http://ideone.com/q1LL3E

Posting this because I can't comment yet, otherwise it would be a suggestion to improve the existing C answer because I completely stole the case-insensitive idea from the existing C answer.

Returns 0 if the string is not ordered, and a non-zero value if ordered.

Answer 23

Java 8 - 90 89 87 85 chars

The idea here is to use a 'reduce' function that tracks the last char and "gives up" when it detects the sequence is not strictly ascending.

golfed:

int f(String s){return s.toLowerCase().chars().reduce(0,(v,c)->(v<0)?v:(c>v)?c:-1);}

ungolfed:

int f(String s){
    return s.toLowerCase()
            .chars()
            .reduce(0, (v,c) -> (v<0)? v : (c>v)?c:-1);
}

example:

System.out.println(new Quick().f("abc"));
System.out.println(new Quick().f("aa"));
System.out.println(new Quick().f("abcdefGHIjklmnopqrSTUVWXyz"));
System.out.println(new Quick().f("puZ"));
System.out.println(new Quick().f("Puz"));
System.out.println(new Quick().f("cba"));

output:

99
-1
122
122
122
-1

Answer 24

Python 2, 43 bytes

lambda s:eval('"%s"'%'"<"'.join(s.lower()))

Try it online!

Puts < symbols between all the letters (converted to lowercase), and then evals it. Python's chained comparison operators are perfectly happy to evaluate the whole thing as one big boolean expression.

Answer 25

Perl, 27

@hsl's regexp dynamically build.

#!perl -p
$"="?";@x=a..z;$_=/^@x?$/i

Also we can do a reverse match: convert the input into a regexp: PuZ => .*p.*u.*z.* and then match this to a string of letters in alphabetical order. Result - also 27 characters.

#!perl -lp
$_=join(s//.*/g,a..z)=~lc

Answer 26

k (6 bytes)

&/>':_

& returns true if both args are true

/ modifies & to apply "over" a list, like a fold in functional languages

> greater than

': modifies > to apply "each-prior", so returns a vector of booleans stating which elements are greater than their predecessor

_ makes it argument lower case

  _"puzZ"
"puzz"
  >':_"puzZ"
1110b
  &/>':_"puzZ"
0b

(0b means boolean false)

q (13 bytes)

all(>':)lower

q is just syntactic sugar on k. all is defined as &/, and lower is _

Answer 27

Python, 50 bytes

f=lambda x:sorted(set(x.lower()))==list(x.lower())

Try online here: http://repl.it/c5Y/2

Answer 28

VBA (161 bytes)

Function t(s As String)
t = 0
For i = 2 To Len(s)
a = Left(LCase(s), i)
    If Asc(Right(a, 1)) <= Asc(Right(a, 2)) Then Exit Function
Next
t = 1
End Function  

Compares ascii value with previous letter in lowercase, return 0 (false) when its value is smaller / equal and exit function

Answer 29

Python 2, 62 bytes (thank to Shaggy)

def a(w):
    v=w.lower()
    print v==''.join(sorted(set(v)))

I know I can not beat anyone but here is my solution.

PoC: https://repl.it/repls/UnderstatedDecimalSales

Answer 30

Japt, 6 bytes

v ä< e

Try it online!

Explanation:

v         #Convert to all lowercase
  ä  e    #For every pair of consecutive letters:
   <      # Check that the second letter is later in the alphabet than the first

Answer 31

APL (Dyalog Extended), 6 bytes^SBCS

Anonymous tacit prefix function.

(∧≡∪)⌊

Try it online!

(…)⌊ on the lowercase:

 ∧≡∪ does the ascending sort match the unique?

Answer 32

><>, 29 20 bytes

Saved 9 bytes thanks to Jo King

0\0=n;
!\i1+48*%:r)?

Try it online!

Answer 33

Ruby, 29 bytes

->s{s=~/^#{[*?a..?z]*??}?$/i}

Try it online!

Returns 0 if in order, or false if not in order.

Answer 34

Erlang, 51

f(S)->G=string:to_lower(S),ordsets:from_list(G)==G.

Uses an ordered set (analogous to java.util.TreeSet) to sort the characters and discard any duplicates. The new list is then compared with the input string.

Test Function:

test() ->
    [io:format("~p ~p~n", [S, f(S)]) || S <- ["a","abcdefGHIjklmnopqrSTUVWXyz","aa","puz","puzz","puzZ","puZ","PuZ"]].

Answer 35

Java, 96

boolean a(char[]a){int i=-1,l=0;for(;++i<a.length;l+=i>0&&a[i]<=a[i-1]?1:0)a[i]|=32;return l<1;}

Pretty straightforward here. Just convert all to lower and compare each to the previous character.

Answer 36

PowerShell, 37

-join(($x="$input")[0..26]|sort)-eq$x

Can be shortened by another byte by using command-line arguments instead of stdin ($args instead of $input).

Tricks used:

• PowerShell is case-insensitive by default, simplifying the check.
• Getting a char[] from the input is a bit shorter if we know an upper bound for the length [0..x] instead of [char[]]

Answer 37

Rebol - 26 25

(s: input)= sort unique s

NB. Above works fine in Rebol 2. However in Rebol 3 sort isn't case insensitive (yet) so for now it would need to be written has (s: input)= sort lowercase unique s

Answer 38

R, 62 Bytes

s=strsplit(tolower(word),"")[[1]]
all(s[order(unique(s))]==s)

This will throw a warning if there is a repeating character.

To avoid this, I inserted zeros to make both strings the same length. I assumed this is OK since we are only using letters and not numbers.

s <- strsplit(tolower(word), "")[[1]]
all(c(s[order(unique(s))],rep('0',length(s)-length(unique(s)) )) == s) 

Answer 39

Clojure, 69

(let[s(seq(.toLowerCase (read-line)))](= s(seq(apply sorted-set s))))

Run in the REPL, enter a string and press return. Prints true or false. E.g.

user=> (let[s(seq(.toLowerCase (read-line)))](= s(seq(apply sorted-set s))))
puZ
true
user=> (let[s(seq(.toLowerCase (read-line)))](= s(seq(apply sorted-set s))))
puzz
false

Answer 40

PHP (89 76 72 63 bytes)

I'm pretty horrible at golfing, but I thought I'd give it a shot.

<?=(join(array_unique(str_split($a=strtolower($argv[1]))))==$a)+0;

I had to cast the output to an integer, since booleans aren't printed in php.

I was able to remove the echo by using <?=, I also removed the $b.

[edit]

Removed the space after <?= and followed manatwork's suggestion to cut 4 bytes.

Also, replacing the implode with join and omitting the glue parameter saved another 9 bytes. Thanks manatwork.

Answer 41

Javascript, 147 145 bytes

function(a){b=[];a=a.toLowerCase().split('');while(a.length)b.push(a.pop().charCodeAt(0));while(c=b.pop()){if(c>=b[b.length-1])return 0}return 1}

An anonymous function that converts to lowercase, creates an array of char codes, then checks them from right to left.

Answer 42

Retina, 33 bytes (non-competing)

Uses features newer than the challenge. Byte count assumes ISO 8859-1 encoding.

T`L`l
^
$_¶
O`\G.
D`\G.
^(.*)¶\1$

Try it online

Translate uppercase to lowercase, duplicate input, sort the first line, deduplicate first line, then check if the lines are equal.

Answer 43

C++14, 59 58 bytes

-1 byte for int instead of auto in range-based for-loop.

As unnamed lambda returning via reference parameter. 64 (>0) for true, 0 for false. Input s may be std::string or char[].

[](auto&s,int&r){int b=r=64;for(int c:s)r*=b<(c&=95),b=c;}

The &=95 is from this answer.

Ungolfed and usage:

#include<string>
#include<iostream>

auto f=
[](auto&s,int&r){
  int b=r=64;
  for(int c:s)
    r*=b<(c&=95),
    b=c;
}
;

int main(){
  std::string s;
  int r;
  s="ABC";
  f(s,r); std::cout << s << ", " << r << std::endl;
  s="AbC";
  f(s,r); std::cout << s << ", " << r << std::endl;
  s="ACB";
  f(s,r); std::cout << s << ", " << r << std::endl;
  s="AcB";
  f(s,r); std::cout << s << ", " << r << std::endl;
}

Answer 44

MathGolf, 6 bytes

mδ_s▀=

Try it online!

Explanation

m        explicit map (per character)
 δ       capitalize string
         these two commands transforms the input string to uppercase
  _      duplicate the uppercase string
   s     sort(array)
    ▀    unique elements of string
     =   check if equal to the uppercased input

Answer 45

C# (Visual C# Interactive Compiler), 44 bytes

n=>n.Aggregate((a,b)=>a>1&a%32<b%32?b:'')>1

Can be 42 bytes if I return a SOH char for non-alphabetic and anything else for alphabetic.

Try it online!

Answer 46

JavaScript (Node.js), 93 bytes

w=>new Set(w).size==w.length&&[...w.toLowerCase()].sort().join``==[...w.toLowerCase()].join``

Try it online!

Answer 47

Perl 6, 30 14 bytes

{[<] .uc.ords}

Try it online!

Gets the ordinal values of the uppercased string and checks if they are in strictly increasing order.

Answer 48

PHP, 42 bytes

for(;$c=_&$argn[$i++];$p=$c)$c<$p&&die(1);

exits with 1 (error) for falsy, exit code 0 for truthy.
Run as pipe with -nR or try it online.

If you absolutely need visible output, take these 51 bytes:

for(;$c=_&$argn[$i++];$p=$c)$c<$p&&die("0");echo 1;

Answer 49

Bash+coreutils, 27 bytes

grep -Ei ^1`echo ?{a..z}?`$

Try it online!

There was an earlier answer with pure Bash, but this one is cool because it saves space by making a much "worse" regular expression. The command substitution expands to the regular expression

^1?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?$

which accepts many things that we don't care about (1's at the beginning and spaces almost anywhere) but that's okay because it selects correctly when limited to things in the input specification. This lets us avoid a printf %s and just accept the spaces that Bash gives when it expands ?{a..z}?

Answer 50

APL(NARS), 32 char, 64 bytes

{(k≡∪k)∧k≡k[⍋k←26∣¯1+(⎕A,⎕a)⍳⍵]}

how to use and test (note that "'a'" is a char type and ",'a'" is one type array chars):

  h←{(k≡∪k)∧k≡k[⍋k←26∣¯1+(⎕A,⎕a)⍳⍵]}
  h ,'a'
1
  h 'abcdefGHIjklmnopqrSTUVWXyz'
1
  h 'aa'
0
  h 'puz'
1
  h 'puzz'
0
  h 'puzZ'
0

Possible there is something more short.

Answer 51

05AB1E, 4 bytes

lDêQ

Try it online or verify all test cases.

Explanation:

      #  i.e. input: "Test"
l     # Convert the (implicit) input-string to lowercase
      #  STACK: ["test"]
 D    # Duplicate it
      #  STACK: ["test", "test"]
  ê   # Uniquify and sort the characters in the duplicated string
      #  STACK: ["test", "est"]
   Q  # Check if both strings are equal
      #  STACK: [0]
      # (after which the top of the stack is output implicitly as result)

Answer 52

PHP (52 bytes)

This is an answer based on @HSL's regex (sorry dude).

The idea is to grab the regex and generate it instead of having it hard-coded.

Here is the code:

echo preg_match("@^".join('?',range(a,z))."?$@",$s);

Since this answer isn't entirely of my authority, I have marked it as "Community Wiki".

To use this, simply add a line before with $s='String!';.