(inspirado en esta publicación sobre Puzzling. PRECAUCIÓN: LOS SPOILERS PARA ESE PUZZLE ESTÁN A CONTINUACIÓN).

El teclado del teléfono estándar correlaciona letras con números de la siguiente manera:

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

Una palabra de entrada dada se define como una palabra ordenada si, cuando se traduce a las pulsaciones del teclado usando lo anterior, el número resultante no disminuye o no aumenta. En otras palabras, el número resultante no puede aumentar y disminuir.

Por ejemplo, la palabra se CATtraduce como 228no decreciente y, por lo tanto, como una palabra ordenada. Sin embargo, la palabra DOGes 364, que aumenta y disminuye, y por lo tanto no es una palabra ordenada.

El reto

Dada una palabra, salida ya sea ordenada o no.

Entrada

• Una palabra (no necesariamente una palabra del diccionario) que consta de letras del alfabeto ASCII ( [A-Z]o [a-z]) únicamente, en cualquier formato adecuado .
• Usted elige si la entrada es todo en mayúsculas o minúsculas, pero debe ser consistente.
• La palabra tendrá al menos 3 caracteres de longitud.

Salida

Un valor de verdad / falsey consistente para saber si la palabra de entrada es Ordenada (verdad) o no Ordenada (falsey).

Reglas

• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Si es posible, incluya un enlace a un entorno de prueba en línea para que otras personas puedan probar su código.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Ejemplos

Aquí hay algunas palabras ordenadas (es decir, verdad), y hay más sobre el rompecabezas vinculado.

CAT
TAC
AAA
DEMONS
SKID
LKJONMSRQP
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Aquí hay algunas palabras no ordenadas (es decir, falsey)

DOG
GOD
ROSE
COFFEE
JKLMNOGHI

Python 2 , 164 148 132 77 bytes

-16 bytes gracias a la sugerencia de Rod en otro lugar . Un maldito -55 bytes gracias a Arnold Palmer.

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

Pruébalo en línea!

La entrada debe ser mayúscula. Salidas Trueo en Falsefunción de su orden.

Explicación

La primera línea asigna cada letra a un 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

Esto funciona basado en:

          | 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

_{* Los valores son redondeados. :PAGS}

La segunda línea sale si la lista de números está en orden ascendente o descendente.

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

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

Devuelve un booleano.

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

Casos de prueba

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

¿Cómo?

Conversión de letras

Usamos parseInt(c, 35)para convertir cada letra de la cadena de entrada a algún número en [ 10 .. 34 ]. Como es base 35, "Z" se convierte en su NaNlugar.

La expresión * .32 | 0asigna este número en el intervalo [ 3 .. 10 ], lo que lleva a 8 grupos correctos de letras para "A" a "Y" . Necesitamos || 10obtener el valor correcto 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

Prueba de orden

Llevamos un registro de los signos de diferencias entre números consecutivos en la máscara de bits v , inicialmente establecida en 3 (0b11):

• bit # 0: borrado cuando new_value> previous_value
• bit # 1: borrado cuando new_value <previous_value

El valor anterior se almacena en la misma variable x que la entrada. Esto garantiza que la primera iteración, donde no existe un valor anterior , no borrará ningún bit, porque una cadena que contiene solo letras no es mayor ni menor que cualquier número:

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

Se ordena una palabra a menos que se encuentren ambos signos, lo que conduce a v = 0 y hace que every()falle.

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

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

Pruébalo en línea!

¡Fue muy divertido escribirlo!

Explicación:

                # 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?

Gracias a @ErikTheOutgolfer, @leakynun y @BusinessCat por todos los bytes guardados. :)

05AB1E , 36 bytes

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

Pruébalo en línea!

MATL , 26 25 bytes

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

La entrada está en letras mayúsculas. La salida es 1o 0.

Pruébalo en línea!

Explicación

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

Devoluciones 1para entradas verdaderas, 0para entradas falsas. Las entradas deben estar en mayúsculas. Pasa todos los casos de prueba. Pruébalo en línea!

Explicación

±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]]

Pruébalo en línea!

Acepta entradas en minúsculas.

Cómo funciona

⌊3681 / x ⌋ disminuye desde

• 38 a 37 en x ≈ 96.8684210526, antes a;
• 37 a 36 en x ≈ 99.4864864865, entre cy d;
• 36 a 35 en x ≈ 102.25, entre fy g;
• 35 a 34 en x ≈ 105.171428571, entre iy j;
• 34 a 33 en x ≈ 108.264705882, entre ly m;
• 33 a 32 en x ≈ 111.545454545, entre oy p;
• 32 a 31 en x ≈ 115.03125, entre sy t;
• 31 a 30 en x ≈ 118.741935484, entre vy w;
• 30 a 29 en x ≈ 122.7, después z.

C ++, 375 199 195 194 bytes

Gracias a la respuesta JavaScript de Shaggy:
-5 bytes gracias 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‹Ë

Pruébalo en línea!

-1 gracias a Magic Octopus Urn .

Retina , 65 bytes

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

^(<*|>*)>$

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

T`_ADGJMPTW`d

Cambia la primera letra de cada tecla a un dígito. (Esto está desactivado en 1, pero eso no importa para una verificación ascendente / descendente. Por otro lado, los ceros harían mi vida más difícil, así que dejé un personaje de relleno).

}T`L`_L

Mezcle todas las letras restantes hasta 1 y repita hasta que se hayan convertido a dígitos.

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

Convierta los dígitos en unarios, pero solo una vez por ejecución de dígitos idénticos. Los valores unarios se separan con un <...

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

... pero si el LHS resulta ser mayor que el RHS, corrija el <a >.

1

Elimine los 1mensajes que ya no son necesarios.

^(<*|>*)>$

Verifique que la palabra esté ordenada. (El final >viene del último dígito que siempre se compara mayor que el espacio vacío que lo sigue).

Pyth , 23 bytes

¡Una de mis primeras respuestas Pyth no triviales! Guardado 6 bytes gracias a @LeakyNun. La solución inicial está abajo.

/{_BKmhS,9/a58Cd3.13zSK

Banco de pruebas.

Pyth , 29 bytes

KmhS+9]/-Cd58 3.13w|qKSKqK_SK

Banco de pruebas.

Explicación

/{_BKmhS,9/a58Cd3.13zSKQ: la Q significa entrada evaluada y está implícita al final

 {- Deduplicar
  _ - Marcha atrás
   B - Bifurcar, crear una lista de dos elementos, [B, A (B)]
    K - Variable con autoasignación para:
     mz - Mapa sobre la entrada:
      hS - Mínimo (primer elemento de la lista ordenada)
        , - Cree una lista de dos elementos, [A, B] con estos elementos:
         9 - El literal numérico 9
          / - La división entera de:
           a58Cd: la diferencia absoluta entre 58 y ord (current_element)   
                3.13 - El literal numérico 3.13
                    SK - K ordenados
/ Q - Cuenta las ocurrencias de la entrada en [K, K [:: - 1]]                

05AB1E , 21 17 bytes

Código

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

Utiliza la codificación 05AB1E .

Pruébalo en línea! o Verifique todos los casos de prueba!

Explicación

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

Esto ahora esencialmente asigna las siguientes letras a los siguientes 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 con cuerdas mixtas. Vuelve 1por veracidad o 0por falsey.

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

• 10 bytes guardados gracias a Rod .

Intentalo

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

Pruébalo en línea!

Explicación

ċ                  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Ë

Cada vez que veo una pregunta de teclado numérico, tengo que hacer una respuesta basada en pi.

Pruébelo en línea o verifique todos los casos de prueba

Ç                    # 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?

Jalea , 32 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

Siento que hay espacio para ahorrar, pero C # no es un lenguaje conciso, por lo que tal vez no. Sin golf:

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
}

En particular, creo que hay una forma más corta de expresar la verificación final de validez, posiblemente una forma de alinearla con el Zip. Encontrar una manera de expresarlo Zipsin necesidad de almacenamiento temporal para el Skiptambién ahorraría algo, pero dudo que haya algo más conciso para eso.

Python 3 , 143 147 148 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)

Lo mejor que puedo hacer por ahora. La función cruda convierte la letra en el número basado en el código ASCII. Definitivamente hay algunas mejoras por hacer. 0 es verdadero, 1 es falsey (lo siento). Ahorré 10 bytes gracias a Rod, otros 3 gracias al Sr. Xcoder.

Pruébalo en línea!

Python 2 , 111103 bytes

-8 bytes gracias a @Arnold Palmer: no es lower()necesario

• Toma letras mayú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]

Pruébalo en línea!

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

Un puerto de golf de la respuesta 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;

acepta mayúsculas; salida vacía para falsedad, 1para verdad.

Ejecutar como tubería con -nRo probarlo en línea .

publicación 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

Pruébalo en línea

Por supuesto, la versión fea termina siendo más corta ...

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

Pruébalo en línea!

Vieja solución:

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

Guardado 8 bytes gracias a ThePirateBay.

Vieja y vieja solución:

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

Vieja vieja vieja solución:

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

Convierte cada carácter de la cadena en un entero de 0 a 7, y toma la diferencia entre cada elemento consecutivo; luego verifica si las diferencias mínimas y máximas tienen el mismo signo (o si es 0).

Zsh , 73 69 57 bytes

-12 bytes usando la 3681/codeconversión de @ anders-kaseorg .

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

Pruébalo en línea! Pruébalo en línea! Pruébalo en línea!

Algunas cosas que abusamos:

• ((statement,statement,...))es una secuencia de expresiones aritméticas que devuelve verdad si la última declaración es distinta de cero.
• El valor de retorno de un bucle es el valor de retorno de la última instrucción en un bucle.
• Precedencias de operadores aritméticos eran bastante agradable para nosotros, ya que sólo un par de no se utiliza paréntesis. Se podría guardar un byte si se !enlaza con menos fuerza que &.
• Los parámetros desarmados se expanden 0en expansiones aritméticas.
• La función que utilizamos para asignar al número del teclado es CODE / 3.2 - 18(con un caso especial para Z), pero como solo necesitamos el cambio entre códigos, no hacemos el ajuste lineal.

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

Se pueden guardar 2 bytes si se pueden intercambiar los valores de verdadero / falso.