(inspirado nesta postagem sobre Puzzling. CUIDADO: SPOILERS PARA ESSE ENIGMA ESTÃO ABAIXO.)

O teclado padrão do telefone correlaciona letras com números da seguinte maneira:

1 ->
2 -> ABC
3 -> DEF
4 -> GHI
5 -> JKL
6 -> MNO
7 -> PQRS
8 -> TUV
9 -> WXYZ
0 ->

Uma determinada palavra de entrada é definida como uma Palavra Ordenada se, quando traduzida para o teclado pressiona usando o acima, o número resultante é não decrescente ou não crescente. Em outras palavras, o número resultante não pode aumentar e diminuir.

Por exemplo, a palavra se CATtraduz em 228, que não diminui e, portanto, em uma palavra ordenada. No entanto, a palavra DOGé 364, que aumenta e diminui e, portanto, não é uma Palavra Ordenada.

O desafio

Dada uma palavra, faça a saída, seja ordenada ou não.

Entrada

• Uma palavra (não necessariamente uma palavra do dicionário) que consiste apenas no alfabeto ASCII ( [A-Z]ou [a-z]), em qualquer formato adequado .
• Sua escolha se a entrada for toda maiúscula ou minúscula, mas deve ser consistente.
• A palavra terá pelo menos três caracteres.

Saída

Um valor truthy / falsey consistente para se a palavra de entrada é Ordered (truthy) ou não Ordered (falsey).

Regras

• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• Se possível, inclua um link para um ambiente de teste on-line para que outras pessoas possam experimentar seu código!
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

Exemplos

Aqui estão algumas palavras ordenadas (ou seja, verdade), e há mais sobre o quebra-cabeça enigmático vinculado.

CAT
TAC
AAA
DEMONS
SKID
LKJONMSRQP
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Aqui estão algumas palavras não ordenadas (ie falsey)

DOG
GOD
ROSE
COFFEE
JKLMNOGHI

Python 2 , 164 148 132 77 bytes

-16 bytes graças à sugestão de Rod em outro lugar . A -55 bytes graças a Arnold Palmer.

n=[min(int((ord(i)-58)/3.13),9)for i in input()]
print sorted(n)in[n,n[::-1]]

Experimente online!

A entrada deve estar em maiúsculas. Saídas Trueou com Falsebase em sua ordem.

Explicação

A primeira linha mapeia cada letra para um número.

                               for i in input()   # iterate over the input string
            ord(i)                                # take the ASCII ordinal
                  -58                             # subtract 58
           (         )/3.13                       # divide by 3.13
       int(                )                      # chop off the fractional part
   min(                     ,9)                   # choose the minimum between the number and 9
n=[                                            ]  # assign the resulting list to n

Isso funciona com base em:

          | 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
----------+------------+------------+------------+------------+------------+----------------+------------+-----------------
ord(x)    | 65  66  67 | 68  69  70 | 71  72  73 | 74  75  76 | 77  78  79 | 80  81  82  83 | 84  85  86 | 87  88  89  90
----------+------------+------------+------------+------------+------------+----------------+------------+-----------------
x - 58    | 7   8   9  | 10  11  12 | 13  14  15 | 16  17  18 | 19  20  21 | 22  23  24  25 | 26  27  28 | 29  30  31  32
----------+------------+------------+------------+------------+------------+----------------+------------+-----------------
x ÷ 3.13* | 2.2 2.6 2.9| 3.2 3.5 3.8| 4.2 4.5 4.8| 5.1 5.4 5.8| 6.1 6.4 6.7| 7.0 7.3 7.7 7.9| 8.3 8.6 8.9| 9.3 9.6 9.9 10.2
----------+------------+------------+------------+------------+------------+----------------+------------+-----------------
int(x)    | 2   2   2  | 3   3   3  | 4   4   4  | 5   5   5  | 6   6   6  | 7   7   7   7  | 8   8   8  | 9   9   9   10
----------+------------+------------+------------+------------+------------+----------------+------------+-----------------
min(x, 9) | 2   2   2  | 3   3   3  | 4   4   4  | 5   5   5  | 6   6   6  | 7   7   7   7  | 8   8   8  | 9   9   9   9

_{* Os valores são arredondados. : P}

A segunda linha será exibida se a lista de números estiver em ordem crescente ou decrescente.

print                                             # print whether...
      sorted(n)                                   # n sorted...
               in[n,n[::-1]]                      # is equivalent to n or n reversed

JavaScript (ES6),  83 ... 71  70 bytes

Retorna um booleano.

x=>[...x].every(c=>v&=~(k=x,x=parseInt(c,35)*.32|0||10,x<k?2:x>k),v=3)

Casos de teste

let f =

x=>[...x].every(c=>v&=~(k=x,x=parseInt(c,35)*.32|0||10,x<k?2:x>k),v=3)

test = a => a.forEach(s => console.log(f(s) + " for '" + s + "'"))

console.log('[Truthy]')
test(["AAA", "CAT", "TAC", "DEMONS", "SKID", "LKJONMSRQP", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"])

console.log('[Falsy]')
test(["DOG", "GOD", "ROSE", "COFFEE", "JKLMNOGHI"])

Quão?

Conversão de letras

Usamos parseInt(c, 35)para converter cada letra da string de entrada em algum número em [ 10 .. 34 ]. Por ser base 35, "Z" é convertido em NaNvez disso.

A expressão * .32 | 0mapeia esse número no intervalo [ 3 .. 10 ], levando a 8 grupos de letras corretos para "A" a "Y" . Precisamos || 10obter o valor correto para "Z" .

           | 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
-----------+--------+--------+--------+--------+--------+-----------+--------+------------
parseInt   |10 11 12|13 14 15|16 17 18|19 20 21|22 23 24|25 26 27 28|29 30 31|32 33 34 NaN
-----------+--------+--------+--------+--------+--------+-----------+--------+------------
*.32|0||10 | 3  3  3| 4  4  4| 5  5  5| 6  6  6| 7  7  7| 8  8  8  8| 9  9  9|10 10 10  10

Teste de ordem

Nós acompanhamos os sinais de diferenças entre números consecutivos na máscara de bits v , inicialmente definida como 3 (0b11):

• bit # 0: limpo quando new_value> previous_value
• bit # 1: limpo quando new_value <previous_value

O valor anterior é armazenado na mesma variável x que a entrada. Isso garante que a primeira iteração - na qual não existe realmente nenhum valor anterior - não apague nenhum bit, porque uma sequência contendo apenas letras não é maior nem menor que qualquer número:

('CAT' > 5) === false
('CAT' < 5) === false

Uma palavra é ordenada, a menos que ambos os sinais sejam encontrados, o que leva a v = 0 e causa every()falha.

Jelly , 28, 27, 25, 23, 22, 21, 19, 18 bytes

_>
O‘ç82ç88:3IṠḟ0E

Experimente online!

Foi muito divertido escrever!

Explicação:

                # Define a helper link, decrement a if a > b
_               # Subtract
 >              # Boolean greater than
                # Main link:
O               # The ordinals (ASCII points) of the input
 ‘              # Minus one
  ç82           # Decrement if greater than 82
     ç88        # Decrement if greater than 88
        :3      # Divide each number by 3
          I     # Consecutive differences
           Ṡ    # Sign (-1 if < 0, 0 if == 0, and 1 if > 0)
            ḟ0  # Remove all 0's
              E # All elements are equal?

Obrigado a @ErikTheOutgolfer, @leakynun e @BusinessCat por todos os bytes salvos. :)

05AB1E , 36 bytes

v.•1нJ©½è`ÇHø¹á₂N¸°…ÈáÀ•#Dʒyå}k}¥0‹Ë

Experimente online!

MATL , 26 25 bytes

1Y21K250B-Y{c&m8\dZSu|s2<

A entrada está em maiúsculas. A saída é 1ou 0.

Experimente online!

Explicação

1Y2      % Push 'ABC...XYZ'
1        % Push 1
K        % Push 4
250B     % Push 250 in binary, that is, [1 1 1 1 1 0 1 0]
-        % Subtract (from 4, element-wise): gives [3 3 3 3 3 4 1 4]
Y{       % Convert to cell array, splitting into chunks of those lengths
c        % Convert to char matrix. Gives a 4-column matrix. Chunks of length 3
         % are right-padded with a space
&m       % Implicit input. Push (linear) index of membership in char matrix
8\       % Modulo 8. Converts linear index into 0-based row index
d        % Consecutive differences
ZS       % Sign
u        % Unique
|        % Absolute value
s        % Sum
2<       % Less than 2? Implicit display

Casco , 22 21 19 18 bytes

±S€Ẋ▲`Ṫo±≤"DGJMPTW

Retorna 1para entradas 0verdadeiras , para falsas. As entradas devem estar em maiúsculas. Passa em todos os casos de teste. Experimente online!

Explicação

±S€Ẋ▲`Ṫo±≤"DGJMPTW  Implicit input x, e.g. "CAT"
     `Ṫo±≤"DGJMPTW  This part transforms x into a "canonical form" corresponding to the numpad digits
     `Ṫ             Table with flipped arguments
       o±≤          on sign of less-than-or-equal
                    (In Husk, ≤ returns extra information we don't want, so we take sign of the result to get 0 or 1.)
          "DGJMPTW  of this string and x.
                    This gives, for each char in x, a bit array of comparisons with the chars in the string:
                    y = [[0,0,0,0,0,0,0],[0,0,0,0,0,0,0],[1,1,1,1,1,1,0]]
   Ẋ▲               Maxima of adjacent pairs: [[0,0,0,0,0,0,0],[1,1,1,1,1,1,0]]
 S€                 1-based index in y as sublist: 2
±                   Sign: 1

Python 2 , 60 bytes

a=[3681/ord(c)for c in input()]
print sorted(a)in[a,a[::-1]]

Experimente online!

Aceita entrada em minúsculas.

Como funciona

813681 / x ⌋ diminui de

• 38 a 37 em x ~ 96,8684210526, antes a;
• 37 a 36 em x 99,4864864865, entre ce d;
• 36 a 35 em x ≈ 102,25, entre fe g;
• 35 a 34 em x .1 105,171428571, entre ie j;
• 34 a 33 em x 108,264705882, entre le m;
• 33 a 32 em x 111,545454545, entre oe p;
• 32 a 31 em x .0 115,03125, entre se t;
• 31 a 30 em x 118,741935484, entre ve w;
• 30 a 29 em x ± 122,7, depois z.

C ++, 375 199 195 194 bytes

Graças à resposta de Shaggy JavaScript:
-5 bytes graças a Zacharý

#include<string>
int o(std::string a){std::string m="22233344455566677778889999";for(auto&b:a)b=m[b-65];int j=1,i=0,d=0;for(;j<a.size();++j){if(a[j]>a[j-1])++i;if(a[j]<a[j-1])++d;}return!(i*d);}

05AB1E , 30 bytes

A3 8×Ƶ0+S£¹δåā>‚øε`*}.«+¥0K0‹Ë

Experimente online!

-1 graças a Magic Octopus Urn .

Retina , 65 bytes

T`_ADGJMPTW`d
}T`L`_L
(.)\1*
$1$*1<
(1+)<(?!\1)
$1>
1

^(<*|>*)>$

Experimente online! O link inclui casos de teste. Explicação:

T`_ADGJMPTW`d

Mude a primeira letra de cada tecla para um dígito. (Isso é desativado por 1, mas isso não importa para uma verificação ascendente / descendente. Por outro lado, zeros tornariam minha vida mais difícil, então deixei um caractere de preenchimento.)

}T`L`_L

Embaralhe todas as letras restantes até 1 e repita até que todas tenham sido convertidas em dígitos.

(.)\1*
$1$*1<

Converta os dígitos em unários, mas apenas uma vez por execução de dígitos idênticos. Os valores unários são separados com um <...

(1+)<(?!\1)
$1>

... mas se o LHS for maior que o RHS, corrija o <para >.

1

Exclua os 1que não são mais necessários.

^(<*|>*)>$

Verifique se a palavra está ordenada. (O final >é proveniente do último dígito, que sempre compara maior que o espaço vazio a seguir.)

Pitão , 23 bytes

Uma das minha primeira resposta Pyth não trivial! Guardado 6 bytes graças a @LeakyNun. A solução inicial está abaixo.

/{_BKmhS,9/a58Cd3.13zSK

Suíte de teste.

Pitão , 29 bytes

KmhS+9]/-Cd58 3.13w|qKSKqK_SK

Suíte de teste.

Explicação

/{_BKmhS,9/a58Cd3.13zSKQ - O Q significa entrada avaliada e está implícito no final

 {- Desduplicar
  _ - Marcha ré
   B - Bifurcar, criar uma lista de dois elementos, [B, A (B)]
    K - Variável com atribuição automática para:
     mz - Mapa sobre a entrada:
      hS - Mínimo (primeiro elemento da lista classificada)
        , - Crie uma lista de dois elementos, [A, B] com estes elementos:
         9 - O literal numérico 9
          / - A divisão inteira de:
           a58Cd - A diferença absoluta entre 58 e ord (elemento_ atual)   
                3.13 - O literal numérico 3.13
                    SK - K classificado
/ Q - conte as ocorrências da entrada em [K, K [:: - 1]]                

05AB1E , 21 17 bytes

Código

A•22ā₂•Sās×J‡Ô¥dË

Usa a codificação 05AB1E .

Experimente online! ou Verifique todos os casos de teste!

Explicação

A                   # Push the lowercase alphabet
 •22ā₂•             # Push the number 33333434
       S            # Split into an array
        ā           # Get the range of indices [1 .. length]
         s×         # Swap and string multiply
           J        # Join that array
            ‡       # Transliterate

Agora, agora essencialmente mapeia as seguintes letras para os seguintes números:

abcdefghijklmnopqrstuvwxyz
↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
11122233344455566667778888

             Ô      # Remove consecutive duplicates
              ¥     # Compute the delta's of the list
               d    # Check if the number is greater or equal to 0
                Ë   # Check if all elements are the same

JavaScript (ES6), 107 97 95 92 88 85 bytes

Funciona com seqüências de caracteres mistos. Retorna 1para verdade ou 0para falsey.

s=>(s=(a=[...s].map(c=>(parseInt(c,36)-3)/3.13%10|0||9))+"")==a.sort()|s==a.reverse()

• 10 bytes salvos graças ao Rod .

Tente

o.innerText=(f=
s=>(s=(a=[...s].map(c=>(parseInt(c,36)-3)/3.13%10|0||9))+"")==a.sort()|s==a.reverse()
)(i.value="Cat")
oninput=_=>o.innerText=f(i.value)

<input id=i><pre id=o>

Gaia , 29 27 25 17 bytes

ċ⟨):“QX’>¦Σ⁻3/⟩¦o

Experimente online!

Explicação

ċ                  Turn the input into a list of code points
 ⟨            ⟩¦   Map this block to each code point:
  )                 Increment it
   :                Copy it
    “QX’            Push [81 88]
        >¦          Check if the code point is greater than each of [81 88]
          Σ         Sum the results
           ⁻        Subtract from the code point
            3/      Integer divide the result by 3
                o  Check if the resulting list is in sorted order (increasing or decreasing)

05AB1E , 13 bytes

ÇÍžq÷8
7:Ô¥dË

Sempre que vejo uma pergunta numpad, tenho que fazer uma resposta baseada em pi.

Experimente online ou verifique todos os casos de teste

Ç                    # ASCII code of each letter in the input
 Í                   # add 2
  žq÷                # divide by pi
     8 7:            # replace 8 with 7
         Ô           # remove duplicates
          ¥          # deltas
           d         # each >= 0 ?
            Ë        # are all elements equal?

Geléia , 32 bytes

“¢Ç⁺H’D0ẋj1œṗØA⁸=€×"€9Ḋ¤Fḟ0Iḟ0ṠE

Experimente online!

C # (.NET Core) , 133 bytes

using System.Linq;q=>{var u=q.Select(c=>(int)((c-58)/3.13));var z=u.Zip(u.Skip(1),(a,b)=>a-b);return!(z.Any(d=>d<0)&z.Any(d=>d>0));};

Experimente online!

Eu sinto que há algum espaço para economizar, mas o C # não é um idioma conciso, então talvez não. Ungolfed:

bool Ordered(string word){

    IEnumerable<int> keys = word.Select(character => (int)((character - 58)/3.13)); 
    // convert characters to keypad number

    IEnumerable<int> differences = keys.Zip(keys.Skip(1), (a, b)=> a-b); 
    // difference between consecutive elements

    return !(differences.Any(diff => diff<0) & differences.Any(diff => diff>0)); 
    // false if both positive and negative differences exist
}

Em particular, acho que há uma maneira mais curta de expressar a verificação final de validade, possivelmente uma maneira de alinhar com a Zip. Encontrar uma maneira de expressar isso Zipsem precisar de armazenamento temporário Skiptambém pouparia algo, mas duvido que exista algo mais conciso para isso.

Python 3 , 143 147 148 149 149 130 bytes

def g(s,f=lambda c:min(int((ord(c)-58)/3.13),9)):x=[f(a)-f(b)for a,b in zip(s,s[1:])];return any(t<0for t in x)*any(t>0for t in x)

O melhor que posso fazer por enquanto. A função bruta transforma a letra no número com base no código ascii. Definitivamente, existem algumas melhorias a serem feitas. 0 é verdade, 1 é falsey (desculpe). Economizou 10 bytes graças ao Rod, outros 3 graças ao Sr. Xcoder.

Experimente online!

Python 2 , 111 103 bytes

-8 bytes graças a @Arnold Palmer: não é lower()necessário

• Leva letras maiúsculas como entrada.

lambda x:sorted(f(x))in[f(x),f(x)[::-1]]
f=lambda x:['22233344455566677778889999'[ord(i)-65]for i in x]

Experimente online!

PHP 7, 98 + 1 95 + 1 84 + 1 bytes

um porto de golfe da resposta de Arnauld .

for(;$c=ord($argn[$i]);$v|=$i++?$p>$k?2:$p<$k:0,$p=$k)$k=($c-58)*.32%10?:9;echo$v<3;

aceita maiúsculas; saída vazia por falsidade, 1por verdade.

Execute como pipe -nRou experimente online .

postagem original:

for(;$c=$argn[$i++];$p?$a[]=$p<=>$k:0,$p=$k)$k=(ord($c)-58)/3.13-($c>Y)|0;echo min($a)*max($a)>=0;

CJam, 37 31 30 27 bytes

q{_"SVZY"#g-i3/}%_$_W%](e=g

Experimente Online

Claro que a versão feia acaba sendo mais curta ...

q{        e# For each character in string...
_"SVZY"#g e# Get index of that character in "SVZY". Signum that. (returns 1 or 0 if inside string, -1 if not.)
-i3/      e# Subtract value from character (i.e 'Z' becomes 'Y', 'F' becomes 'G'). Convert to int. Integer divide by 3. (this is just how the math works out for proper mapping of characters to phone digits.)
}%
_$_W%]    e# Put mapped string, sorted version, and reverse sorted version in array.
(         e# Pop mapped string from array onto stack.
e=        e# Count occurences of mapped string in array.
g         e# Signum.

C (gcc) , 183 169 153 117 117 bytes

#define a(b)(int)fmin(*(b c)/3.2,27)
d(char*c){int r=1,p=1;for(;1<strlen(c);)r&=a()<=a(1+),p&=a()>=a(++);return r|p;}

Experimente online!

Solução antiga:

#define a(b)(int)((int)(b*.32-17.6)*.9)
d(char*c){int l=~-strlen(c),i=0,r=1,p=1;for(;i<l;++i)r&=a(c[i])<=a(c[i+1]),p&=a(c[l-i])<=a(c[l-i-1]);return r+p;}

Economizou 8 bytes graças ao ThePirateBay.

Solução antiga antiga:

d(char*c){char*a="22233344455566677778889999";int l=strlen(c)-1,i=0,r=1,p=1;for(;i<l;++i){if(a[c[i]-65]>a[c[i+1]-65])r=0;if(a[c[l-i]-65]>a[c[l-i-1]-65])p=0;}return r+p;}

Solução antiga antiga:

d(char*c){char*a="22233344455566677778889999";int l=strlen(c);int i,r=1,p=1;for(;i<l-1;++i)if(a[c[i]-65]>a[c[i+1]-65])r=0;for(i=l-1;i>0;--i)if(a[c[i]-65]>a[c[i-1]-65])p=0;return r+p;}

TI-Basic, 92 66 bytes

ΔList(int(seq(inString("BC DEF GHI JKL MNO PQRSTUV WXYZ",sub(Ans,I,1))/4,I,1,length(Ans
0≤min(Ansmax(Ans

Converte cada caractere na seqüência de caracteres em um número inteiro de 0 a 7 e leva a diferença entre cada elemento consecutivo; depois verifica se as diferenças mínimas e máximas têm o mesmo sinal (ou é 0).

Zsh , 73 69 57 bytes

-12 bytes usando a 3681/codeconversão de @ anders-kaseorg .

for c (${(s::)1})((y=3681/#c,A|=y<p,D|=p&&p<y,p=y,!D|!A))

Experimente online! Experimente online! Experimente online!

Algumas coisas que abusamos:

• ((statement,statement,...))é uma sequência de expressões aritméticas que retorna verdade se a última instrução for diferente de zero.
• O valor de retorno de um loop é o valor de retorno da última instrução em um loop.
• As precedências do operador aritmético foram bastante agradáveis ​​para nós, pois apenas um par de parênteses não foi usado. Um byte pode ser salvo se !vinculado menos firmemente que &.
• Os parâmetros não configurados se expandem para 0em expansões aritméticas.
• A função que usamos para mapear para o número do teclado é CODE / 3.2 - 18(com um caso especial para Z), mas como precisamos apenas da alteração entre códigos, não fazemos o ajuste linear.

for c (${(s::)1})           # split into characters
    (( y = #c-90 ? 0^(#c/3.2) : 27,   # this sets y to the keypad number + 18
       A |= y < p,          # set the A flag if we detect it is not ascending
       D |= p && p < y,     # ditto descending, don't compare on first iteration
       p = y,               # save the current character
       !D | !A              # return false if D and A are both set
    ))

Podem ser salvos 2 bytes se os valores de verdade / falsey puderem ser trocados.