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

Prolog (SWI), 36 bytes

\S:-maplist(to_lower,S,L),sort(L,L).

Try it online!

Ungolfed:

\S :-
  maplist(to_lower, S, L), % convert each character code in S to lowercase, putting that in a list called L
  sort(L, L). % Does L sorted and uniquified equal L?

Answer 2

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 3

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!';.

Answer 4

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 5

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 6

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 7

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 8

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 9

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 10

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 11

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 12

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 13

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 14

APL (Dyalog Extended), 6 bytes^SBCS

Anonymous tacit prefix function.

(∧≡∪)⌊

Try it online!

(…)⌊ on the lowercase:

 ∧≡∪ does the ascending sort match the unique?

Answer 15

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 16

><>, 29 20 bytes

Saved 9 bytes thanks to Jo King

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

Try it online!

Answer 17

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 18

Ruby, 29 bytes

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

Try it online!

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

Answer 19

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 20

Jelly, 5 bytes

Œu<ƝẠ

Try it online!

How it works

Œu<ƝẠ - Main link. Takes a string S on the left
Œu    - Uppercase
   Ɲ  - Over overlapping pairs [a, b]:
  <   -   Is a < b?
    Ạ - True for all?

Answer 21

x86 machine code, 15 bytes

Hexdump:

33 c0 ac 24 5f 3a e0 73 05 8a e0 e2 f5 f9 c3

A function which receives a pointer to the string in esi and its length in ecx. Returns in CF.

Disassembly:

10011860 33 C0                xor         eax,eax  
10011862 AC                   lods        byte ptr [esi]  
10011863 24 5F                and         al,5Fh  
10011865 3A E0                cmp         ah,al  
10011867 73 05                jae         bad (1001186Eh)  
10011869 8A E0                mov         ah,al  
1001186B E2 F5                loop        my+2h (10011862h)  
1001186D F9                   stc  
1001186E C3                   ret  

I had arrange the comparison in such a way that for "bad" strings the carry flag gets set to 0.

Test program (works in Visual Studio):

#include <stdio.h>
#include <string.h>

__declspec(naked) char my()
{
    _asm
    {
        xor eax, eax;
    myloop:
        lodsb;
        and al, 0x5f;
        cmp ah, al;
        jae bad;

        mov ah, al;
        loop myloop;
        stc;
    bad:
        ret;
    }
}

__declspec(naked) bool __fastcall caller(const char*, size_t)
{
    _asm
    {
        push esi;
        mov esi, ecx;
        mov ecx, edx;
        call my;
        mov al, 0;
        adc al, 0;
        pop esi;
        ret;
    }
}

bool is_good(const char* s)
{
    printf("%s ", s);
    size_t l = strlen(s);
    return caller(s, l);
}

int main()
{
    printf("%d\n", is_good("abd"));
    printf("%d\n", is_good("a"));
    printf("%d\n", is_good("abcdefGHIjklmnopqrSTUVWXyz"));
    printf("%d\n", is_good("aa"));
    printf("%d\n", is_good("puz"));
    printf("%d\n", is_good("puzz"));
    printf("%d\n", is_good("puzZ"));
    printf("%d\n", is_good("puZ"));
    printf("%d\n", is_good("PuZ"));
    printf("%d\n", is_good("pzu"));
    printf("%d\n", is_good("pzU"));
    printf("%d\n", is_good("abcdABCD"));
    printf("%d\n", is_good("dcba"));
}

It contains a function caller which translates calling conventions.

Answer 22

Pyth, 8 bytes

qKrQ1S{K

Try it online!

qKrQ1S{K
qKrQ1S{KQ  // Implicit input
 KrQ1      // Assign uppercase input to K
q    S{K   // Deduplicate K and sort it
q          // Is original K == deduplicated and sorted

Answer 23

Retina, 33 bytes

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 24

Husk, 7 5 bytes

ΠẊ>ma

Try it online!

Inspired by caird's Jelly answer

   m    # map over all letters of input:
    a   #  make lowercase
 Ẋ      # then for each pair
  >     #  test if R > L
Π       # and get the product of all the results.

Answer 25

Excel ms365, 45 bytes

=CONCAT(SORT(UNIQUE(MID(A1,ROW(1:26),1))))=A1

Answer 26

Vyxal, 3 bytes

⇩Þ⇧

Try it Online!

Answer 27

Julia 1.0, 34 bytes

!x=all(diff(([x...].-'A').%32).>0)

Try it online!

Answer 28

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 29

JavaScript (Node.js), 93 bytes

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

Try it online!

Answer 30

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;