Avec une chaîne d'entrée S, renvoie truthysi toutes les lettres de S sont ordonnées lexicalement: leurs valeurs ASCII doivent être dans un ordre croissant ou décroissant. Retour falsydans les autres cas.

Contribution

• La saisie se fera dans le même cas (majuscules ou minuscules). Votre soumission devrait pouvoir gérer les deux.
• L'entrée consistera en ASCII dans la plage [A-Za-z]seulement
• La longueur d’entrée sera d’au moins 1, jusqu’à concurrence de votre langue.
• L'entrée est une chaîne - pas une liste de caractères, pas un tableau de points de codage ASCII.

Sortie

• Le résultat devrait être trueou false, ou 0/1, ou tout autre true / falsestyle de sortie que votre langage peut fournir.
• Tous les vrais cas doivent avoir la même sortie, ainsi que tous les faux cas. Non "False est 0, true est 1, 2 ou 3".

Règles supplémentaires

• Les échappatoires standard sont interdites
• La réponse doit être un programme complet ou une fonction, pas un extrait de code ni une entrée REPL.
• code-golf , la réponse la plus courte en octets l'emporte.

Cas de test

Vérité

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

Fausseté

"ABCDC"
"yes"
"deed"

Invalide

"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 octets

Â)¤{å

Essayez-le en ligne!

Explication

Â)     # 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 octets

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

Essayez-le en ligne!

Haskell , 33 octets

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

Essayez-le en ligne!

Merci à Ørjan Johansen pour 1 octet avec scanl1infixe de repliement .

Haskell est un langage intéressant pour les défis basés sur le tri du golf, car il n’a pas de tri intégré, à l’exception de long import Data.List. Cela encourage à trouver un moyen de faire la tâche à la main sans trier explicitement.

Le code utilise scanl1, qui replie une opération sur la liste de gauche à droite, en gardant une trace des résultats intermédiaires. Ainsi, scanl1 maxa pour effet d’énumérer les maxima cumulés de la liste, c’est-à-dire les maxima de préfixes de plus en plus longs. Par exemple, scanl1 max [3,1,2,5,4] == [3,3,3,5,5].

La même chose avec minvérifie si la liste diminue. Le code vérifie les deux cas et les combine avec ||.

Comparez avec d'autres expressions:

(%)=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 octets

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

Comment ça marche:

• .comb divise l'entrée en une séquence de caractères.
• leet gesont les opérateurs de comparaison de chaînes "inférieur ou égal" et "supérieur ou égal à" .
• [ ]autour d'un opérateur infixe, réduit ("plie") la liste d'arguments avec cet opérateur. (Il est assez intelligent pour renvoyer True si l'entrée n'a que zéro ou un caractère.)
• or renvoie True si les expressions de chaque côté sont vraies.

JavaScript (ES6), 43 octets

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

MATL , 7 octets

dZSuz2<

Essayez-le en ligne! Ou vérifiez tous les cas de test .

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 octets

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

C (gcc) , 70 octets

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

J'espérais trouver une solution plus courte basée sur une fonction récursive, mais cela n'a pas fonctionné en raison des exigences de sortie. Alors, voici une approche impérative. Au moins, la priorité de l'opérateur C fonctionne bien pour l'instruction de boucle interne.

Essayez-le en ligne!

R, 48 50 61 octets

En tant que fonction non nommée

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

Merci à @guiseppe pour quelques octets supplémentaires.

charToRawprend set se divise en un vecteur brut. Ceci est converti en entiers et diffappliqué. signrend les diffs une seule unité. rangeréduit le vecteur à son minimum et maximum. Ensuite, si l'écart type sdest inférieur à 1, il est VRAI

Essayez-le en ligne!

MATL, 8 octets

tPvGSXma

Essayez-le en ligne!

Explication

        % 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

Gelée , 4 à 5 octets

Ṣm0ẇ@

Essayez-le en ligne!

À l'origine était Ṣm0wà quatre octets.

Explication

Ṣ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 octets

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

Basé sur cette astuce . Malheureusement, je dois utiliser à la ToCharacterCodeplace de Characters, car <=et >=ne compare pas les chaînes.

PowerShell , 61 octets

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

Essayez-le en ligne!

Prend l'entrée $a, puis vérifie s'il s'agit d' -inun tableau à deux éléments. Le tableau est formé en prenant $a, en le chartransformant en un tableau, en le stockant $bpour plus tard, en le dirigeant vers un tri lexical sort-object. L'autre élément est $btrié dans l' -desordre croissant.

Perl , 35 octets

Sauvegardé 4 octets grâce à @Xcali directement, et 4 autres indirectement.

31 octets de code + -pFdrapeau.

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

Essayez-le en ligne!

Le code trie l'entrée et vérifie si les entrées correspondent elles-mêmes triées (ou dans l'ordre inverse).

Gelée , 5 octets

,Ue@Ṣ

Essayez-le en ligne!

Comment?

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

Bash + coreutils, 59 octets

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

La chaîne d'entrée est transmise en tant qu'argument.

La sortie est renvoyée dans le code de sortie (0 pour la vérité, 1 pour la fausseté, comme d'habitude), comme le permettent les méthodes d'E / S PPCG .

PHP, 66 octets

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

prend en entrée l'argument de la ligne de commande. Courez avec -r.

Ruby , 44 octets

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

Essayez-le en ligne!

Raquette , 93 octets

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

Essayez-le en ligne!

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

Utiliser le tri puis comparer à l'approche originale

Brachylog , 5 octets

J'ai essayé de trouver une solution de 4 octets sans succès, donc pour l'instant voici la solution de 5 octets la plus intéressante que j'ai trouvée:

:No₎?

Essayez-le en ligne!

o, la fonction de classement peut prendre un paramètre: 0signifie ordre croissant, 1signifie ordre décroissant. Nous définissons ce paramètre sur une variable non liée N. Brachylog essaiera différentes valeurs pour N(seulement 0ou 1est possible), tentera d'unifier le résultat avec l'entrée et retournera si l'une de ces tentatives a réussi.

MATLAB / Octave, 38 octets

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

Démo en ligne

JavaScript (ES6) 74 62 50 47 43 octets

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

Après avoir joué au golf et corrigé des bugs, cette réponse s’est avérée être à peu près la même que celle d’ETHProduction. Veuillez donc consulter sa réponse et donner une réponse +1.

Haskell, 54 à 50 octets

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

Exemple d'utilisation: t "defggh"-> True. Essayez-le en ligne! .

Peut-être que l’utilisation de la sortmême chose peut être plus courte, bien que cela exige import Data.List. Voici une approche différente:

Pour chaque fonction fde [(=<<),(<*>)], calculez and(zipWith(<=)`f`tail$a)et demandez à l’un des résultats d’être True. Les fonctions sont

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

qui sont tous deux effectuer des comparaisons des éléments voisins de la liste d'entrée aavec <=, mais avec les arguments retourné résultant en une >=. andvérifie si toutes les comparaisons sont True.

Pushy , 7 octets

ogoGo|#

Essayez-le en ligne!

Explication:

      \ 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 octets

}Q_BS

Un programme qui prend une entrée "quoted string"et imprime Trueou Falseselon le cas.

Suite de tests

Comment ça marche

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

Octave, 24 octets

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

Essayez-le en ligne!

GNU sed, 97 + 1 (indicateur r) = 98 octets

Si les lettres sont ordonnées, le script revient 1, sinon 0. Dans sed, il n'y a pas de types de données.

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

Pour vérifier si toutes les lettres sont classées par ordre croissant, je fais une recherche sous forme de tableau de chaque paire de lettres consécutives dans un alphabet décroissant, c’est-à-dire que j’essaie de trouver un exemple de compteur. Notez que //répète en fait la dernière correspondance d'expression régulière! (voir lignes 2 et 3)

Exemple d'exécution: le script peut tester plusieurs mots d'entrée, un par ligne.

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

CJam , 12 à 11 octets

q_$_W%+\#)g

Essayez-le en ligne!

Explication

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 code machine, 68 61 48 46 45 39 octets

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

Assemblé de:

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 octets

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