¿Es una palabra ordenada?

26

(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 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
AdmBorkBork
fuente
Relacionado y relacionado No estoy seguro de que esto no sea un engaño, ¿el único cambio entre abc->t9este desafío es controlar la monotonía?
nmjcman101
1
@ nmjcman101 Sí, están relacionados, pero podría haber otras formas (¿mejores?) que estrictamente abc->t9.
AdmBorkBork
Eso tiene sentido, espero ver que algo
supere
1
También un poco relacionado.
totalmente humano
Solicitud de caso de prueba:AAA
Business Cat

Respuestas:

13

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
totalmente humano
fuente
44
84 bytes
Arnold Palmer
1
Santa vaca, eso es asombroso. ¡Gracias!
totalmente humano
Iba a publicarlo como respuesta porque lo escribí antes de que todos se inundaran de respuestas, pero me abofeteaste :)
Arnold Palmer
8

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


¿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.

Arnauld
fuente
Oh, buen truco para obtener el número de cada letra :) No estoy seguro de si debería pedirlo prestado o no, ya que significaría que lo vincularía contigo, lo que no parece correcto.
Shaggy
6

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

DJMcMayhem
fuente
3

05AB1E , 36 bytes

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

Pruébalo en línea!

Urna de pulpo mágico
fuente
44
Puedes reemplazar .•1нJ©½è`ÇHø¹á₂N¸°…ÈáÀ•#por A•22ā₂•S£.
Adnan
3
@Adnan rip formatting
Leaky Nun
3
@LeakyNun <s> rip efectivamente </s> solucionado
Adnan
44
@Adnan rip formatting
Leaky Nun
44
@LeakyNun rip hecho
Adnan
3

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
Luis Mendo
fuente
Puntaje apropiado para un desafío alfabético: P
DJMcMayhem
@DJMcMayhem Ya no :-D
Luis Mendo
3

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
Zgarb
fuente
3

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.
Anders Kaseorg
fuente
2

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);}
HatsuPointerKun
fuente
¿Puedes mover el int j=1,i=0,d=0al bucle for?
Zacharý
@ Zacharý Desde iy dse utilizan fuera del bloque de bucle, no puedo
HatsuPointerKun
i==0||d==0==> i*d==0.
Zacharý
Funcionaria !(i*d)? (quitando el espacio después return)
Zacharý
@ Zacharý Sí, funciona
HatsuPointerKun
1

05AB1E , 30 bytes

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

Pruébalo en línea!

-1 gracias a Magic Octopus Urn .

Erik el Outgolfer
fuente
¿Usaste ¥0K0.SËporque ¥0‹Ëno es correcto? No puedo decir si 0.Ses necesario.
Magic Octopus Urn
@MagicOctopusUrn De hecho, ¥0K0‹Ëparece funcionar.
Erik the Outgolfer
Sí, si estás eliminando los 0, debería; en mi respuesta no estoy seguro de que funcione.
Urna mágica del pulpo
@MagicOctopusUrn Estoy eliminando los ceros ya que de lo contrario habrá falsos negativos. Sin embargo, su respuesta podría comportarse de manera diferente.
Erik the Outgolfer
1

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

Neil
fuente
Eso es muy bonito. Gracias por la explicación detallada.
AdmBorkBork
1

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]]                
Sr. Xcoder
fuente
1
23 bytes
Leaky Nun
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
Adnan
fuente
1

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>

Lanudo
fuente
1
Math.min((parseInt(c,36)-3)/3.13|0,9)en lugar "2..9"[parseInt(c,36)-10]de guardar algunos bytes
Rod
Gracias @ Rod; muy agradable. Tendré que archivar eso para uso futuro.
Shaggy
Gracias, @ThePirateBay, pero, lamentablemente, eso falla para la entrada AAA.
Shaggy
1

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)
Gato de negocios
fuente
1

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?
Mugriento
fuente
0

Jalea , 32 bytes

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

Pruébalo en línea!

Erik el Outgolfer
fuente
Compresión RIP
Leaky Nun
@LeakyNun El número comprimido es en realidad 32222323así que ahorra solo 2 bytes.
Erik the Outgolfer
0

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.

Kamil Drakari
fuente
0

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!

C McAvoy
fuente
puede usar x=[f(a)-f(b)for a,b in zip(s,s[1:])]para guardar algunos bytes
Rod
también, min(int((ord(c)-58)/3.13),9)es una forma más corta de convertir el carbón
Rod
140 bytes
Sr. Xcoder
@ Rod ¡Gracias! Muy útil.
C McAvoy
Tendrá que cambiar sus salidas para que esto sea válido.
Shaggy
0

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!

officialaimm
fuente
1
Puede eliminar el .lower()ya que la entrada puede ser en cualquier caso que especifique.
Arnold Palmer
0

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;
Titus
fuente
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.
geokavel
fuente
0

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;}
Matej Mulej
fuente
0

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

Timtech
fuente
Creo que ΔList(int(4^-1seq(inString("DEF GHI JKL MNO PQRSTUV WXYZ",sub(Ans,I,1))+3,I,1,length(Ansahorra un byte.
lirtosiast
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.

Función Gamma
fuente