Dada uma sequência de entrada S, retorne truthyse todas as letras em S forem Lexically Ordered: seus valores ASCII precisam estar em ordem crescente ou decrescente. Retorno falsyem outros casos.

Entrada

• A entrada será no mesmo caso (todas maiúsculas ou minúsculas). Seu envio deve ser capaz de lidar com ambos.
• A entrada consistirá em ASCII [A-Za-z]apenas no intervalo
• O comprimento da entrada será de pelo menos 1, até o máximo que seu idioma suportar.
• A entrada é uma sequência - não uma lista de caracteres, nem uma matriz de pontos de código ASCII.

Resultado

• A saída deve ser trueou false, ou 0/1, ou qualquer outro true / falseestilo distinto que o seu idioma possa fornecer.
• Todos os casos verdadeiros precisam ter a mesma saída, bem como todos os casos falsos. Não "Falso é 0, verdadeiro é 1, 2 ou 3".

Regras adicionais

• As brechas padrão são proibidas
• A resposta deve ser um programa ou uma função completa, não um trecho de texto ou uma entrada REPL.
• code-golf , a resposta mais curta em bytes vence.

Casos de teste

Truthy

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

Falsy

"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

Â)¤{å

Experimente online!

Explicação

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

Experimente online!

Haskell , 33 bytes

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

Experimente online!

Agradecimentos a Ørjan Johansen por 1 byte com scanl1infixo de aliasing .

Haskell é uma linguagem interessante para os desafios baseados na classificação de golfe, porque ela não tem uma classificação interna, exceto uma longa import Data.List. Isso incentiva a encontrar uma maneira de executar a tarefa manualmente, sem classificar explicitamente.

O código usa scanl1, que dobra uma operação sobre a lista da esquerda para a direita, acompanhando os resultados intermediários. Portanto, scanl1 maxtem o efeito de listar os máximos cumulativos da lista, ou seja, os máximos de prefixos progressivamente mais longos. Por exemplo scanl1 max [3,1,2,5,4] == [3,3,3,5,5],.

O mesmo minocorre com verificações se a lista está diminuindo. O código verifica os dois casos e os combina com ||.

Compare com outras expressões:

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

Como funciona:

• .comb divide a entrada em uma sequência de caracteres.
• lee gesão os operadores de comparação de cadeia "menor ou igual" e "maior ou igual" .
• [ ]ao redor de um operador infix, reduz ("dobra") a lista de argumentos com esse operador. (É inteligente o suficiente retornar True se a entrada tiver apenas zero ou um caractere.)
• or retorna True se as expressões de ambos os lados forem verdadeiras.

JavaScript (ES6), 43 bytes

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

MATL , 7 bytes

dZSuz2<

Experimente online! Ou verifique todos os casos de teste .

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

Eu esperava encontrar uma solução mais curta com base em uma função recursiva, mas não funcionou devido ao requisito de saída. Então, aqui está uma abordagem imperativa. Pelo menos, a precedência do operador de C funciona bem para a instrução de loop interno.

Experimente online!

R, 48 50 61 bytes

Como uma função sem nome

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

Obrigado a @guiseppe por alguns bytes extras.

charToRawleva se se divide em um vetor bruto. Isso é convertido em números inteiros e diffaplicado. signtorna os diffs uma única unidade. rangereduz o vetor ao mínimo e ao máximo. Então, se o desvio padrão sdfor menor que 1, será TRUE

Experimente online!

MATL, 8 bytes

tPvGSXma

Experimente Online!

Explicação

        % 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

Gelatina , 4 5 bytes

Ṣm0ẇ@

Experimente online!

Originalmente tinha Ṣm0wquatro bytes.

Explicação

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

Com base nesta dica . Infelizmente, eu tenho que usar em ToCharacterCodevez de Characters, porque <=e >=não comparar as strings.

PowerShell , 61 bytes

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

Experimente online!

Recebe entrada $ae verifica se é -inuma matriz de dois elementos. A matriz é formada pegando $a, moldando-a como uma charmatriz, armazenando-a $bpara mais tarde, canalizando-a para sort-objectque classifique lexicamente. O outro elemento é $bclassificado em -desordem pendente.

Perl , 35 bytes

Economizou 4 bytes graças a @Xcali diretamente e 4 indiretamente.

31 bytes de código + -pFsinalizador.

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

Experimente online!

O código classifica a entrada e verifica se as entradas correspondem a si mesmas classificadas (ou na ordem inversa).

Geléia , 5 bytes

,Ue@Ṣ

Experimente online!

Quão?

,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

A sequência de entrada é passada como argumento.

A saída é retornada no código de saída (0 para verdade, 1 para falsidade, como de costume), conforme permitido pelos métodos de E / S do PPCG .

PHP, 66 bytes

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

recebe entrada do argumento da linha de comando. Corra com -r.

Ruby , 44 bytes

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

Experimente online!

Raquete , 93 bytes

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

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

Usando a classificação e compare com a abordagem original

Brachylog , 5 bytes

Eu tentei encontrar uma solução de 4 bytes sem sucesso, então, por enquanto, aqui está a solução mais interessante de 5 bytes que encontrei:

:No₎?

Experimente online!

o, a função de pedido, pode usar um parâmetro: 0significa ordem crescente, 1significa ordem decrescente. Definimos esse parâmetro como uma variável não acoplada N. O Brachylog tentará valores diferentes para N(somente 0ou 1são possíveis), tentará unificar o resultado com a entrada e retornará se alguma dessas tentativas foi bem-sucedida.

MATLAB / oitava, 38 bytes

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

Demonstração online

JavaScript (ES6) 74 62 50 47 43 bytes

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

Depois de jogar golfe e corrigir bugs, essa resposta acabou sendo praticamente a mesma da ETHProduction, portanto, verifique sua resposta e dê uma +1.

Haskell, 54 50 bytes

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

Exemplo de uso: t "defggh"-> True. Experimente online! .

Talvez o uso de sortoutras respostas seja mais curto, embora exija import Data.List. Aqui está uma abordagem diferente:

Para todas as funções fde [(=<<),(<*>)], calcule and(zipWith(<=)`f`tail$a)e exija que qualquer um dos resultados seja True. As funções são

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

que tanto realizar comparações de elementos vizinhos da lista de entrada acom <=, mas um com os argumentos virado resultando em um >=. andverifica se todas as comparações são True.

Pushy , 7 bytes

ogoGo|#

Experimente online!

Explicação:

      \ 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

Pitão, 5 bytes

}Q_BS

Um programa que recebe entrada de "quoted string"e imprime Trueou Falseconforme apropriado.

Suíte de teste

Como 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

Oitava, 24 bytes

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

Experimente Online!

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

Se as letras forem ordenadas, o script retornará 1, caso contrário 0. No sed, não há tipos de dados.

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

Para verificar se todas as letras estão organizadas em ordem crescente, faço uma pesquisa de tabela de cada par de letras consecutivas em um alfabeto descendente, ou seja, tento encontrar um exemplo de contador. Observe que, //na verdade, repete a última correspondência de expressão regular! (ver linhas 2 e 3)

Exemplo de execução: o script pode testar várias palavras de entrada, uma por linha

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

CJam , 12 11 bytes

q_$_W%+\#)g

Experimente online!

Explicação

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

Montado a partir 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