Wenn eine Eingabezeichenfolge S gegeben ist, geben Sie zurück, truthyob alle Buchstaben in S lexikalisch sortiert sind: Ihre ASCII-Werte müssen entweder in aufsteigender oder absteigender Reihenfolge vorliegen. Rückgabe falsyin anderen Fällen.

Eingang

• Die Eingabe erfolgt in der gleichen Groß- oder Kleinschreibung. Ihre Einreichung sollte beides verarbeiten können.
• Eingang wird im Bereich von ASCII besteht [A-Za-z]nur
• Die Eingabelänge beträgt mindestens 1, bis zu dem von Ihrer Sprache unterstützten Maximum.
• Die Eingabe ist eine Zeichenfolge - keine Liste von Zeichen, kein Array von ASCII-Codepunkten.

Ausgabe

• Ausgabe soll trueoder false, oder 0/1, oder jede andere eindeutige true / falseStil Ausgabe Ihrer Sprache zur Verfügung stellen kann.
• Alle wahren Fälle müssen dieselbe Ausgabe haben, ebenso wie alle falschen Fälle. Nein "Falsch ist 0, wahr ist 1, 2 oder 3".

Zusätzliche Regeln

• Standardlücken sind verboten
• Die Antwort muss ein vollständiges Programm oder eine Funktion sein, kein Snippet oder ein REPL-Eintrag.
• Code-Golf , die kürzeste Antwort in Bytes gewinnt.

Testfälle

Wahrheit

"ABCDEF"
"ZYX"
"no"
"tree"   --> the multiple 'e's don't break the order
"q"

Falsch

"ABCDC"
"yes"
"deed"

Ungültig

"Hello" --> invalid input - mixed case-, does not have to be handled
""      --> invalid input - length 0-, does not have to be handled
"\n
  "     --> invalid input - newline is not in range [A-Za-z]-, does not have to be handled

05AB1E , 5 Bytes

Â)¤{å

Probieren Sie es online!

Erläuterung

Â)     # pair the input with it's reverse in a list
  ¤{   # get a copy of the reverse and sort it
    å  # check if the sorted copy is in the list of [input,reverse_input]

Python 2 , 53 44 40 39 Bytes

lambda a:`sorted(a)`[2::5]in(a,a[::-1])

Probieren Sie es online!

Haskell , 33 Bytes

(%)=scanl1
f s=s==max%s||s==min%s

Probieren Sie es online!

Dank an Ørjan Johansen für 1 Byte mit Aliasing- scanl1Infix.

Haskell ist eine interessante Sprache für Herausforderungen, die auf Golfsortierung basieren, da es keine eingebaute Sortierung gibt, es sei denn, es ist langwierig import Data.List. Dies fördert die Suche nach einer Möglichkeit, die Aufgabe von Hand zu erledigen, ohne sie explizit zu sortieren.

Der Code verwendet scanl1, der eine Operation von links nach rechts über die Liste faltet, um die Zwischenergebnisse zu verfolgen. Hat scanl1 maxalso den Effekt, die kumulativen Maxima der Liste aufzulisten, dh die Maxima von progressiv längeren Präfixen. Zum Beispiel scanl1 max [3,1,2,5,4] == [3,3,3,5,5].

Dasselbe gilt für die minÜberprüfung, ob die Liste abnimmt. Der Code überprüft die beiden Fälle und kombiniert sie mit ||.

Vergleichen Sie mit anderen Ausdrücken:

(%)=scanl1;f s=s==max%s||s==min%s

f s=or[s==scanl1 q s|q<-[min,max]]
f s=s==scanl1 max s||s==scanl1 min s
f s=any(\q->scanl1 q s==s)[min,max]
f s=any((==s).(`scanl1`s))[min,max]
f s=elem s$(`scanl1`s)<$>[min,max]

Perl 6 , 25 Bytes

{[le] .comb or[ge] .comb}

Wie es funktioniert:

• .comb teilt die Eingabe in eine Folge von Zeichen auf.
• leund gesind die Vergleichsoperatoren "kleiner oder gleich" und "größer oder gleich" .
• [ ]Reduziert ("faltet") die Argumentliste um einen Infix-Operator mit diesem Operator. (Es ist klug genug, True zurückzugeben, wenn die Eingabe nur null oder ein Zeichen enthält.)
• or Gibt True zurück, wenn die Ausdrücke auf beiden Seiten wahr sind.

JavaScript (ES6), 43 Byte

([...s],q=s+"")=>q==s.sort()|q==s.reverse()

MATL , 7 Bytes

dZSuz2<

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

d     % Implicitly input string. Push array of consecutive differences of code points
ZS    % Sign. Transforms each entry into 1, 0 or -1
u     % Unique
z     % Number of nonzeros
2<    % Is it less than 2? Implicit display

Clojure, 47 Bytes

#(let[c(map int %)a apply](or(a <= c)(a >= c)))

C (gcc) , 70 Bytes

o(s,a)char*s;{for(a=0;s[1];s++)a|=s[1]-*s&64|*s-s[1]&32;return a!=96;}

Ich hatte gehofft, eine kürzere Lösung zu finden, die auf einer rekursiven Funktion basiert, aber sie hat aufgrund der Ausgabeanforderung nicht funktioniert. Hier ist also ein zwingender Ansatz. Zumindest funktioniert die Operatorrangfolge von C für die innere Schleifenanweisung gut.

Probieren Sie es online!

R, 48 50 61 Bytes

Als unbenannte Funktion

function(s)sd(range(sign(diff(utf8ToInt(s)))))<1

Vielen Dank an @guiseppe für ein paar zusätzliche Bytes.

charToRawNimmt sund teilt sich in einen rohen Vektor. Dies wird in Ganzzahlen umgewandelt und diffangewendet. signmacht das diffs zu einer einheit. rangereduziert den Vektor auf Minimum und Maximum. Wenn die Standardabweichung sdkleiner als 1 ist, ist sie WAHR

Probieren Sie es online!

MATL, 8 Bytes

tPvGSXma

Probieren Sie es online!

Erläuterung

        % Implicitly grab the input as a string
tP      % Create a copy that is reversed
v       % Vertically concatenate these
GS      % Grab the input again and sort it
Xm      % Check if each row of the normal and reversed matrix is equal to the sorted one
a       % Check if either row matched
        % Implicitly display the result

Gelee , 4 5 Bytes

Ṣm0ẇ@

Probieren Sie es online!

Ursprünglich war Ṣm0wbei vier Bytes.

Erläuterung

Ṣm0ẇ@  Input: string S
Ṣ      Sort S
 m0    Concatenate sort(S) with reverse(sort(S))
   ẇ@  Sublist exists? Check if S is contained in the previous result

Mathematica, 33 Bytes

0<=##||##>=0&@@ToCharacterCode@#&

Basierend auf diesem Tipp . Leider muss ich ToCharacterCodeanstatt verwenden Characters, weil <=und >=Zeichenfolgen nicht vergleichen.

PowerShell , 61 Byte

param($a)$a-in-join(($b=[char[]]$a)|sort),-join($b|sort -des)

Probieren Sie es online!

Übernimmt die Eingabe $aund prüft dann, ob es sich um -inein Array mit zwei Elementen handelt. Das Array wird gebildet, indem man $aes als char-array aufnimmt, es $bfür später speichert und es sort-objectlexikalisch sortiert. Das andere Element ist $bin -desaufsteigender Reihenfolge sortiert .

Perl , 35 Bytes

Sparte 4 Bytes dank @Xcali direkt und 4 weitere indirekt.

31 Byte Code + -pFFlag.

@b=reverse@a=sort@F;$_=/@a|@b/x

Probieren Sie es online!

Der Code sortiert die Eingabe und überprüft, ob die Eingaben selbst sortiert (oder in umgekehrter Reihenfolge) übereinstimmen.

Gelee , 5 Bytes

,Ue@Ṣ

Probieren Sie es online!

Wie?

,Ue@Ṣ - Main link: string
,     - pair string with
 U    - reverse(string)
    Ṣ - sorted(string)
  e@  - exists in with reversed arguments

Bash + Coreutils, 59 Bytes

f()(sed 's/\(.\)/\1\
/g'<<<$s|grep .|sort -c$1)
s=$1
f||f r

Die Eingabezeichenfolge wird als Argument übergeben.

Die Ausgabe wird im Exit-Code zurückgegeben (0 für Wahrheit, 1 für Falschheit, wie üblich), wie von PPCG-E / A-Methoden zugelassen .

PHP, 66 Bytes

$a=$s=$r=str_split($argv[1]);sort($s);rsort($r);echo$s==$a|$r==$a;

Nimmt Eingaben vom Kommandozeilenargument entgegen. Laufen Sie mit -r.

Ruby , 44 Bytes

->s{[s,s.reverse].include?s.chars.sort.join}

Probieren Sie es online!

Schläger , 93 Bytes

(define(f s)(let([t(string->list s)])(or(equal?(sort t char<=?)t)(equal?(sort t char>=?)t))))

Probieren Sie es online!

Ungolfed:

(define (lex-sorted? string)
  (let ([char-list (string->list string)])
    (or
     (equal? (sort char-list char<=?) char-list)
     (equal? (sort char-list char>=?) char-list))))

Verwenden Sie die Sortierung und vergleichen Sie sie mit dem ursprünglichen Ansatz

Brachylog , 5 Bytes

Ich habe erfolglos versucht, eine 4-Byte-Lösung zu finden. Im Moment ist dies die interessanteste 5-Byte-Lösung, die ich gefunden habe:

:No₎?

Probieren Sie es online!

oDie Sortierfunktion kann einen Parameter annehmen: 0bedeutet aufsteigende Reihenfolge, 1bedeutet absteigende Reihenfolge. Wir setzen diesen Parameter auf eine ungebundene Variable N. Brachylog versucht verschiedene Werte für N(nur 0oder 1möglich), versucht, das Ergebnis mit der Eingabe zu vereinheitlichen, und gibt zurück, ob einer dieser Versuche erfolgreich war.

MATLAB / Octave, 38 Bytes

@(x)any(all([x;flip(x)]'==sort(x)',1))

Online-Demo

JavaScript (ES6) 74 62 50 47 43 Byte

([...a],b=a+'')=>b==a.sort()|b==a.reverse()

Nach einigem Golfen und Bugfixing entsprach diese Antwort fast der von ETHProduction. Bitte überprüfen Sie seine Antwort und geben Sie eine +1.

Haskell, 54 50 Bytes

t a=or[and(zipWith(<=)`f`tail$a)|f<-[(=<<),(<*>)]]

Anwendungsbeispiel: t "defggh"-> True. Probieren Sie es online! .

Vielleicht ist die Verwendung sortanderer Antworten kürzer, obwohl dies erforderlich ist import Data.List. Hier ist ein anderer Ansatz:

Für jede Funktion faus [(=<<),(<*>)], berechnet and(zipWith(<=)`f`tail$a)und bedarf keines der Ergebnisse zu sein True. Die Funktionen sind

((=<<) (zipWith(<=)) tail) a
((<*>) (zipWith(<=)) tail) a

die beide Vergleiche von Nachbarelementen der Eingabeliste amit durchführen <=, aber eines mit gespiegelten Argumenten, was zu a führt >=. andprüft, ob alle Vergleiche vorhanden sind True.

Aufdringlich , 7 Bytes

ogoGo|#

Probieren Sie es online!

Erläuterung:

      \ Implicit: Input on stack as charcodes
og    \ Check if the stack is sorted ascendingly (Push 0/1)
oG    \ Check if the stack is sorted descendingly (Push 0/1)
      \   - Note that this will work regardless of the first check, as input
      \     is guaranteed to be /[A-Za-z]+/
o|    \ Bitwise OR
#     \ Print the result

Pyth, 5 Bytes

}Q_BS

Ein Programm, das a eingibt "quoted string"und druckt Trueoder Falseentsprechend.

Testsuite

Wie es funktioniert

}Q_BS   Program. Input: Q
}Q_BSQ  Implicit variable fill
 Q      Is Q
}       in
    SQ  Q sorted
   B    or
  _     Q sorted reversed?
        Implicitly print

Oktave, 24 Bytes

@(s)issorted(s,'either')

Probieren Sie es online!

GNU sed, 97 + 1 (r flag) = 98 Bytes

Wenn die Buchstaben bestellt sind, kehrt das Skript 1ansonsten zurück 0. In sed gibt es keine Datentypen.

s:$: zyxwvutsrqponmlkjihgfedcba:
s:(.*(.)(.).* ).*\2.*\3.*:\1abcdefghijklmnopqrstuvwxyz:i
//c0
c1

Um zu überprüfen, ob alle Buchstaben in aufsteigender Reihenfolge angeordnet sind, mache ich eine Tabellensuche für jedes Paar aufeinanderfolgender Buchstaben in einem absteigenden Alphabet, dh ich versuche, ein Gegenbeispiel zu finden. Beachten Sie, dass //tatsächlich die letzte Übereinstimmung mit regulären Ausdrücken wiederholt wird! (siehe Zeilen 2 und 3)

Beispiel ausführen: Das Skript kann mehrere Eingabewörter testen, eines pro Zeile

me@LCARS:/PPCG$ echo -e "tree\nABCDC" | sed -rf word_ordered.sed
1
0

CJam , 12 11 Bytes

q_$_W%+\#)g

Probieren Sie es online!

Erläuterung

q            Push the input
 _$          Duplicate and sort
   _W%       Duplicate and reverse
      +      Concatenate the sorted and the reversed strings
       \     Bring input to the top
        #    Find the index of the input in the other string; returns -1 if not found
         )   Increment
          g  Signum (coerces to 0 or 1)

8086 Maschinencode, 68 61 48 46 45 39 Bytes

00000000  b2 31 be 82 00 ac 9f 88  c3 ac 3c 0d 74 14 38 c3  |.1........<.t.8.|
00000010  74 f5 e3 03 b1 00 9f 77  05 9e 76 ea eb 03 9e 77  |t......w..v....w|
00000020  e5 4a b4 02 cd 21 c3                              |.J...!.|
00000027

Zusammengesetzt aus:

org 0x100
use16
    mov dl, 0x31
    mov si, 0x82
    lodsb
a:  lahf
b:  mov bl, al
    lodsb
    cmp al, 0x0d
    je y
    cmp bl, al
    je b
    jcxz @f
    mov cl, 0
    lahf
@@: ja @f
    sahf
    jbe a
    jmp n
@@: sahf
    ja a
n:  dec dx
y:  mov ah, 0x02
    int '!'
    ret

Scala, 47 Bytes

def f(x:String)=x==x.sorted|x==x.sorted.reverse