Schreiben Sie eine Funktion / ein Programm, die / das eine Folge von Klein- / Großbuchstaben [A-Za-z] als Eingabe akzeptiert, die prüft, ob die vorkommenden Buchstaben eindeutig und in alphabetischer Reihenfolge sind (Groß- und Kleinbuchstaben werden ignoriert) oder nicht. Die Ausgabe muss wahr sein, wenn sie eindeutig und in alphabetischer Reihenfolge ist, und falsch, wenn nicht.

Hier einige Testfälle

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

Wenn du willst, starte dein Programm mit allen Wörtern einer Wortliste wie dieser und poste einige interessante =).

Ergebnis

Die niedrigste Anzahl von Bytes gewinnt.

CJam, 8 Bytes

lel_$_&=

Hier ist ein Testgeschirr für alle Beispiele in der Herausforderung. Dies ergibt 0oder 1(was in CJam falsch bzw. wahr ist).

Und hier ist ein Skript zum Filtern der Wortliste in der Frage (dauert einige Sekunden). Sie müssen die Wortliste manuell in das Eingabefeld kopieren, da sie für einen Permalink zu lang ist.

Erläuterung

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

Regex (beliebiger Geschmack), 55 Bytes

Einige Leute halten Regex nicht für eine Programmiersprache, aber es wurde schon früher verwendet und es ist nicht annähernd die kürzeste.

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

Ich habe ein Byte für das iFlag (ohne Berücksichtigung der Groß- / Kleinschreibung) hinzugefügt . Dies ist sehr einfach und kann im laufenden Betrieb kürzer sein.

Wenn Regex alleine nicht erlaubt ist, können Sie dieses 56-Byte- Retina- Programm verwenden, das von Martin Büttner vorgeschlagen wurde:

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

Wenn Sie dies in der oben verlinkten Wortliste ausführen, werden 10 Wörter mit 6 Buchstaben in alphabetischer Reihenfolge angezeigt.

["verabscheut", "fast", "beginnt", "begirt", "bijoux", "biopsie", "chimps", "chinos", "chintz", "ghosty"]

Python 3, 44 Bytes

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

Ein einfacher Ansatz - überprüfen Sie die Eindeutigkeit, überprüfen Sie die Sortierbarkeit.

> <> , 52 42 39 Bytes

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

Diese Art von Frage ist eine der wenigen Arten, mit denen> <> ziemlich vertraut ist, da wir immer nur mit einem Buchstaben zu tun haben.

Erläuterung

Verirre dich nicht! Hier wird viel gewickelt.

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

Vorherige Lösung, 42 Bytes

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

Das Interessante ist, dass trotz scheinbar gleicher Funktionalität die Alternative ist

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

(Die Änderung ist in den Pfeilen und Spiegeln ganz rechts)

Gibt tatsächlich falsche Ergebnisse aus, da der Interpreter von> <> ein Python-Standardgebot verwendet. Was passiert, ist, dass beim Durchlaufen des leeren Bereichs am Ende der zweiten Zeile implizit Nullen in die leeren Bereiche eingefügt werden, wenn> <> versucht, auf die Zelle zuzugreifen. Dies führt dann zu Problemen mit dem ?bedingten Trampolin am Anfang derselben Zeile, da die neu platzierten Nullen übersprungen werden und nicht die vam Ende.

Haskell, 52 Bytes

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

Verwendung: (and.(zipWith(>)=<<tail).map toLower) "abcd"welche Ausgänge True.

C, 67 65 57 54 (52) Zeichen

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

etwas kürzer:

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

und noch kürzer:

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

Hier ist ein kleiner Test: http://ideone.com/ZHd0xl

Nach den neuesten Vorschlägen sind hier noch zwei kürzere Versionen:

// 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;}

Auch dieser Code beruht auf der Tatsache, dass sich in ASCII Klein- und Großbuchstaben nur um das 5. Bit (32) unterscheiden, das ich herausfiltere. Dies funktioniert also möglicherweise offensichtlich nicht mit anderen Codierungen.

BEARBEITEN: Die neueste Version setzt immer das 5. Bit als |32kürzer als &~32.

Ruby, 33

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

Überprüft, ob die sortierten eindeutigen Zeichen mit allen Zeichen übereinstimmen.

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}

Verbessert auf 87 von edc95:

stimme seinem Kommentar zu :)

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

Übrigens sind die aktuell im OP befindlichen Testfälle erfüllt, wenn ein Programm nur die Eindeutigkeit prüft und dabei die Reihenfolge außer Acht lässt.

Da ich noch keine Kommentare schreiben kann, beantworte ich hier einige Bemerkungen:

@ edc65: Danke! Ich habe versucht, es mit some()umzuschreiben, aber ich konnte keine kürzere Lösung finden, denn obwohl es so aussieht, als würde es mir ermöglichen, die überflüssige Variable b loszuwerden, müssen Sie "return" zweimal eingeben (dasselbe mit reduce()), und Sie Das Ergebnis des Vergleichs kann nicht einfach direkt zurückgegeben werden, da das letzte Zeichen nach dem Vergleich gespeichert werden muss.

@ edc65: Das ist eine nette Verwendung des Komma-Operators für 87! Ich habe es in meine Antwort für mehr Sichtbarkeit bearbeitet.

Haskell, 90 Bytes

Liefert die Funktion f :: String -> Bool

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

Verwendung (vorausgesetzt, es wird als golf.hs gespeichert). ...wird verwendet, um ghcidie ausführlichen Lademeldungen von zu ersetzen .

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

Wenn jemand eine lowercaseMethode hat, die kürzer als diese import Distribution.Simple.Utilsist, kommentieren Sie bitte.

Wolfram Mathematica, 49 37 Bytes

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

PS Kürzere Lösung von Martin Büttner:

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

J, 17 Bytes

Überprüft, ob die kleingeschriebene sortierte /:~Zeichenfolge -:der kleingeschriebenen NUB- ~.Zeichenfolge entspricht.

   (/:~-:~.)@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

Da in J eine 1-Zeichen lange "Zeichenfolge", die als reguläre Zeichenfolge (mit Anführungszeichen) dargestellt wird, nur ein Zeichenatom und keine echte Zeichenfolge ist, habe ich die Eingabe entsprechend formatiert, sodass alle Eingaben echte Zeichenfolgen wären. (Im obigen Beispiel habe ich verwendet 1$'a'.)

MATLAB, 29 27 Bytes

Jetzt zu einem Einzeiler, der auch außerhalb des Codegolfs Sinn macht.

Als anonyme Funktion (Verwendung als o('yourstring'))

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

Ich denke, diese Funktion ist ziemlich selbsterklärend, da sie sich wie eine Zeitungsanzeige liest.

Vorherige Version (29 Bytes):

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

Die Eingabe muss zwischen den 'Markierungen erfolgen, z 'Potato'.

Brachylog , 3 Bytes

ḷ⊆Ạ

Probieren Sie es online!

Das Vergleichselement ist erfolgreich, wenn die Eingabe die angegebenen Anforderungen erfüllt, und schlägt fehl, wenn sie nicht gedruckt true.oder false.als Programm ausgeführt wird.

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

Die erste Version, die ich mir ausgedacht habe, bezieht sich nicht explizit auf das Alphabet:

Brachylog , 4 Bytes

ḷ≠.o

Probieren Sie es online!

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

J, 21 Zeichen

Dies ist zu lang. Das Argument muss einen Rang haben 1, dh es muss ein String oder ein Vektor sein.

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

• tolower y- yin Kleinbuchstaben.
• /:~ y- yin lexikalischer Reihenfolge.
• ~. y- der Knoten von y, dh ymit entfernten Duplikaten.
• x ; y- xund yin Kisten legen und dann verketten.
• < y- yIn eine Kiste legen.
• x = y- x Elementweise verglichen mit y.
• (< y) = (~. y) ; (/:~ y)- Ein Vektor, der angibt, ob yer seinem Knoten entspricht und selbst sortiert ist.
• */ y- das Produkt der Items von yoder sein logisches und wenn die Items Boolesche Werte sind.
• */ (< y) = (~. y) ; (/:~ y)- Ein Boolescher Wert, der die gewünschte Eigenschaft für Kleinbuchstaben angibt y.

Julia, 44 Bytes

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

Dadurch wird eine anonyme Funktion erstellt, die ein einzelnes Argument sin Kleinbuchstaben konvertiert und mit der eindeutigen sortierten Version der Zeichenfolge vergleicht. Es gibt einen Booleschen Wert zurück, dh trueoder false. Wenn du es ausprobieren willst, ordne es gerne zu f=s->...und rufe dann an f("PuZ"), etc.

Pure Bash 4.x, 37

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

Eingabe als Befehlszeilenparameter. Gemäß der Standard-Shell-Semantik bedeutet der Exit-Code 0 true (alphabetisch) und der Exit-Code! = 0 false (nicht alphabetisch).

Der printf erstellt den regulären Ausdruck wie in der @ hsl-Lösung . Die Eingabezeichenfolge wird zu Kleinbuchstaben erweitert und mit dem regulären Ausdruck verglichen.

Vorherige Antwort:

Bash + Coreutils, 52

Einfache Lösung:

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

C # 6, 18 + 82 76 = 94 Bytes

Benötigt (18 Bytes):

using System.Linq;

Code (76 Bytes):

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

C # 6 unterstützt Lambdas, um eine Funktion zu definieren, die für das Golfen nützlich ist.

Nicht-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);
}

JavaScript (ES6) 54

Konvertieren Sie in Großbuchstaben, dann in Array und sortieren. Wenn beim Sortieren zwei Elemente in der falschen Reihenfolge oder gleich sind, gebe 0 (falsch) zurück, sonst 1 (wahr)

Bearbeiten Verkürzte thx to @Optimizer (aber immer noch 2 mehr als die @Tamas Lösung in ES6 umgesetzt: 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 der Firefox / FireBug-Konsole

;['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"]

C (44 Bytes)

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

Testen Sie es hier: http://ideone.com/q1LL3E

Posting dies, weil ich noch nicht kommentieren kann, sonst wäre es ein Vorschlag, die vorhandene C-Antwort zu verbessern, weil ich die Idee der Groß- und Kleinschreibung aus der vorhandenen C-Antwort vollständig gestohlen habe.

Gibt 0 zurück, wenn die Zeichenfolge nicht geordnet ist, und einen Wert ungleich Null, wenn geordnet.

Golang (65 Bytes)

Go ist keine golffreundliche Sprache, außerdem sauge ich am Golf ...

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

Führen Sie es hier aus: http://play.golang.org/p/xXJX8GjDvr

edit 106-> 102

edit 102-> 96

edit 96-> 91

edit 91-> 87

edit 87-> 65

Ich habe die Java-Version geschlagen, ich kann für heute aufhören

Java 8 - 90 89 87 85 Zeichen

Die Idee hier ist, eine 'Reduzieren'-Funktion zu verwenden, die das letzte Zeichen verfolgt und "aufgibt", wenn erkannt wird, dass die Sequenz nicht streng aufsteigend ist.

Golf gespielt:

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

Beispiel:

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

Ausgabe:

99
-1
122
122
122
-1

Perl 6, 35 Bytes

{my@c=.uc.comb;@c eq@c.sort.unique}

Dies erzeugt einen aufrufbaren Block; Wenn ich nur annehmen könnte, dass $_bereits das gewünschte Wort gesetzt ist, könnte ich die umgebenden geschweiften Klammern löschen und zwei weitere Bytes verlieren, aber wahrscheinlich ist die einzige vernünftige Möglichkeit, diese Annahme zu treffen, -ndas Wort als Standardeingabe auszuführen und zu füttern , was die zwei Bytes gleich wieder hinzufügen würde.

R , 37 Bytes

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

Probieren Sie es online!

Das Posten ist wesentlich anders und kürzer als Michals R-Antwort .

Konvertiert die Buchstaben mit in ASCII-Codepunkte utf8ToIntund nimmt dann modulo 32, so dass die unteren und oberen Buchstaben in die gleichen Zahlen 1 ... 26 konvertiert werden. Berechnet die paarweisen Differenzen und prüft, ob sie alle positiv sind.

Perl, 27

@ hsls reguläre Ausdrücke werden dynamisch erstellt.

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

Wir können auch eine umgekehrte Übereinstimmung durchführen: Konvertieren Sie die Eingabe in einen regulären Ausdruck: PuZ=> .*p.*u.*z.*und ordnen Sie diese dann einer Buchstabenfolge in alphabetischer Reihenfolge zu. Ergebnis - auch 27 Zeichen.

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

k (6 Bytes)

&/>':_

& Gibt true zurück, wenn beide Argumente true sind

/ändert &, um "über" eine Liste anzuwenden, wie eine Falte in funktionalen Sprachen

> größer als

':ändert >, um "each-prior" anzuwenden, und gibt so einen Vektor von Booleschen Werten zurück, der angibt, welche Elemente größer sind als ihre Vorgänger

_ macht es Argument Kleinbuchstaben

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

( 0bbedeutet boolean false)

q (13 Bytes)

all(>':)lower

q ist nur syntaktischer Zucker auf k. allist definiert als &/und niedriger ist_

Python, 50 Bytes

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

Versuchen Sie es online hier: http://repl.it/c5Y/2

VBA (161 Byte)

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  

Vergleicht den ASCII-Wert mit dem vorherigen Buchstaben in Kleinbuchstaben und gibt 0 (false) zurück, wenn der Wert kleiner / gleich ist, und beendet die Funktion

Python 2 , 43 Bytes

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

Probieren Sie es online!

Setzt <Symbole zwischen alle Buchstaben (in Kleinbuchstaben umgewandelt) und evals es dann. Die verketteten Vergleichsoperatoren von Python bewerten das Ganze gerne als einen großen booleschen Ausdruck.

Erlang, 51

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

Verwendet einen geordneten Satz (analog zu java.util.TreeSet), um die Zeichen zu sortieren und alle Duplikate zu verwerfen. Die neue Liste wird dann mit der Eingabezeichenfolge verglichen.

Testfunktion:

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

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

Ziemlich einfach hier. Wandle einfach alle in niedrigere um und vergleiche sie mit dem vorherigen Zeichen.