Dada una cadena de entrada S, regrese truthysi todas las letras en S están ordenadas léxicamente: sus valores ASCII deben estar en orden ascendente o descendente. Regreso falsyen otros casos.

Entrada

• La entrada será en el mismo caso (todo en mayúsculas o minúsculas). Su presentación debe ser capaz de manejar ambos.
• La entrada consistirá en ASCII en el rango [A-Za-z]solamente
• La longitud de entrada será al menos 1, hasta el máximo que admita su idioma.
• La entrada es una cadena, no una lista de caracteres, no una matriz de puntos de código ASCII.

Salida

• La salida debe ser trueo false, o 0/1, o cualquier otra true / falsesalida de estilo distinto que pueda proporcionar su idioma.
• Todos los casos verdaderos deben tener la misma salida, así como todos los casos falsos. No "Falso es 0, verdadero es 1, 2 o 3".

Reglas adicionales

• Las lagunas estándar están prohibidas
• La respuesta debe ser un programa completo o una función, no un fragmento o una entrada REPL.
• code-golf , la respuesta más corta en bytes gana.

Casos de prueba

Verdad

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

Falsa

"ABCDC"
"yes"
"deed"

Inválido

"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

Â)¤{å

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Haskell , 33 bytes

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

Pruébalo en línea!

Gracias a Ørjan Johansen por 1 byte con scanl1infijo de alias .

Haskell es un lenguaje interesante para los desafíos basados ​​en la clasificación del golf porque no tiene un tipo incorporado, salvo mucho tiempo import Data.List. Esto alienta a encontrar una manera de hacer la tarea a mano sin ordenarla explícitamente.

El código utiliza scanl1, que pliega una operación sobre la lista de izquierda a derecha, haciendo un seguimiento de los resultados intermedios. Entonces, scanl1 maxtiene el efecto de enumerar los máximos acumulativos de la lista, es decir, los máximos de prefijos progresivamente más largos. Por ejemplo, scanl1 max [3,1,2,5,4] == [3,3,3,5,5].

Lo mismo con los mincontroles si la lista está disminuyendo. El código verifica los dos casos y los combina con ||.

Compare con otras expresiones:

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

Cómo funciona:

• .comb divide la entrada en una secuencia de caracteres.
• ley geson los operadores de comparación de cadenas "menor o igual" y "mayor o igual" .
• [ ]alrededor de un operador infijo, reduce ("pliega") la lista de argumentos con ese operador. (Es lo suficientemente inteligente como para devolver True si la entrada tiene solo cero o un carácter).
• or devuelve True si las expresiones a cada lado son verdaderas.

JavaScript (ES6), 43 bytes

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

MATL , 7 bytes

dZSuz2<

Pruébalo en línea! O verificar todos los casos de prueba .

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

Esperaba encontrar una solución más corta basada en una función recursiva, pero no funcionó debido al requisito de salida. Así que aquí hay un enfoque imperativo. Al menos, la precedencia del operador de C funciona bien para la declaración del bucle interno.

Pruébalo en línea!

R, 48 50 61 bytes

Como una función sin nombre

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

Gracias a @guiseppe por algunos bytes adicionales.

charToRawtoma sy divide en un vector sin procesar. Esto se convierte en enteros y se diffaplica. signhace que el diffs sea una sola unidad. rangereduce el vector a su mínimo y máximo. Entonces, si la desviación estándar sdes menor que 1, es VERDADERO

Pruébalo en línea!

MATL, 8 bytes

tPvGSXma

Pruébalo en línea!

Explicación

        % 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

Jalea , 4 5 bytes

Ṣm0ẇ@

Pruébalo en línea!

Originalmente estaba Ṣm0wen cuatro bytes.

Explicación

Ṣ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@#&

Basado en este consejo . Desafortunadamente, tengo que usar en ToCharacterCodelugar de Characters, porque <=y >=no comparar cadenas.

PowerShell , 61 bytes

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

Pruébalo en línea!

Toma entrada $a, luego verifica si se trata de -inuna matriz de dos elementos. El conjunto se forma tomando $a, charconvirtiéndolo en una matriz, almacenando eso $bpara más tarde, canalizándolo a lo sort-objectque se ordena léxicamente. El otro elemento se $bordena en -desorden descendente.

Perl , 35 bytes

Guardado 4 bytes gracias a @Xcali directamente, y 4 más indirectamente.

31 bytes de código + -pFbandera.

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

Pruébalo en línea!

El código ordena la entrada y comprueba si las entradas coinciden ordenadas (o en orden inverso).

Jalea , 5 bytes

,Ue@Ṣ

Pruébalo en línea!

¿Cómo?

,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

La cadena de entrada se pasa como argumento.

La salida se devuelve en el código de salida (0 para verdadero, 1 para falso, como de costumbre), según lo permitido por los métodos de E / S PPCG .

PHP, 66 bytes

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

toma datos del argumento de la línea de comando. Corre con -r.

Ruby , 44 bytes

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

Pruébalo en línea!

Raqueta , 93 bytes

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

Pruébalo en línea!

Sin golf:

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

Usando el ordenamiento luego compara con el enfoque original

Brachylog , 5 bytes

Intenté encontrar una solución de 4 bytes sin éxito, así que por ahora esta es la solución de 5 bytes más interesante que he encontrado:

:No₎?

Pruébalo en línea!

o, la función de ordenamiento, puede tomar un parámetro: 0significa orden ascendente, 1significa orden descendente. Establecemos ese parámetro en una variable independiente N. Brachylog intentará diferentes valores para N(solo 0o 1son posibles), intentará unificar el resultado con la entrada y devolverá si alguno de esos intentos tuvo éxito.

MATLAB / Octave, 38 bytes

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

Demostración en línea

JavaScript (ES6) 74 62 50 47 43 bytes

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

Después de jugar al golf y corregir errores, esta respuesta terminó siendo más o menos la misma que la de ETHProduction, así que por favor revise su respuesta y dele un +1 .

Haskell, 54 50 bytes

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

Ejemplo de uso: t "defggh"-> True. Pruébalo en línea! .

Tal vez usar sortcomo muchas otras respuestas es más corto, aunque requiere import Data.List. Aquí hay un enfoque diferente:

Para cada función fde [(=<<),(<*>)], calcular and(zipWith(<=)`f`tail$a)y requerir cualquiera de los resultados para ser True. Las funciones son

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

ambos realizan comparaciones de elementos vecinos de la lista de entrada acon <=, pero uno con los argumentos volteados dando como resultado a >=. andcomprueba si todas las comparaciones son True.

Pushy , 7 bytes

ogoGo|#

Pruébalo en línea!

Explicación:

      \ 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

Un programa que toma la entrada de "quoted string"ay imprime TrueoFalse según corresponda.

Banco de pruebas

Cómo funciona

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

Octava, 24 bytes

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

¡Pruébelo en línea!

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

Si las letras están ordenadas, el guión regresa 1, de lo contrario 0. En sed no hay tipos de datos.

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

Para verificar si todas las letras están ordenadas en orden ascendente, hago una búsqueda en la tabla de cada par de letras consecutivas en un alfabeto descendente, es decir, trato de encontrar un contraejemplo. Tenga en cuenta que en //realidad repite la última coincidencia de expresión regular.(ver líneas 2 y 3)

Ejemplo de ejecución: el script puede probar múltiples palabras de entrada, una por línea

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

CJam , 12 11 bytes

q_$_W%+\#)g

Pruébalo en línea!

Explicación

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)

Código de máquina 8086, 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

Ensamblado 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 bytes

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