(ispirato a questo post su Sconcertante. ATTENZIONE: GLI SPOILER PER QUELLO PUZZLE SONO QUI SOTTO.)

La tastiera del telefono standard correla le lettere ai numeri come segue:

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

Una determinata parola di input è definita come una Parola ordinata se, quando tradotta in tastiere da tastiera utilizzando quanto sopra, il numero risultante è non decrescente o non crescente. In altre parole, il numero risultante non può aumentare o diminuire.

Ad esempio, la parola si CATtraduce in 228, che non è in diminuzione, e quindi una Parola ordinata. Tuttavia, la parola DOGè 364, che aumenta e diminuisce sia, e quindi non è una Parola ordinata.

La sfida

Data una parola, indica se è ordinato o meno.

Ingresso

• Una parola (non necessariamente una parola del dizionario) costituita solo da lettere ASCII ( [A-Z]o [a-z]) alfabetiche , in qualsiasi formato adatto .
• La tua scelta se l'input è tutto maiuscolo o tutto minuscolo, ma deve essere coerente.
• La parola avrà una lunghezza di almeno 3 caratteri.

Produzione

Un valore di verità / falsità coerente per stabilire se la parola di input è Ordinata (verità) o non Ordinata (falsità).

Regole

• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Se possibile, includi un collegamento a un ambiente di test online in modo che altre persone possano provare il tuo codice!
• Sono vietate le scappatoie standard .
• Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Esempi

Ecco alcune parole ordinate (vale a dire la verità) e ce ne sono altre nel puzzle enigmatico collegato.

CAT
TAC
AAA
DEMONS
SKID
LKJONMSRQP
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Ecco alcune parole non ordinate (es. Falsa)

DOG
GOD
ROSE
COFFEE
JKLMNOGHI

Python 2 , 164 148 132 77 byte

-16 byte grazie al suggerimento di Rod altrove . Un fottuto -55 byte grazie ad Arnold Palmer.

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

Provalo online!

L'input deve essere in maiuscolo. Output Trueo in Falsebase alla sua ordinanza.

Spiegazione

La prima riga associa ogni lettera a un numero.

                               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

Funziona in base a:

          | 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

_{* I valori sono arrotondati. : P}

La seconda riga viene visualizzata se l'elenco di numeri è in ordine crescente o decrescente.

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

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

Restituisce un valore booleano.

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

Casi test

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

Come?

Conversione di lettere

Usiamo parseInt(c, 35)per convertire ogni lettera della stringa di input in un numero in [ 10 .. 34 ]. Poiché è base-35, "Z" viene NaNinvece convertita in .

L'espressione * .32 | 0mappa questo numero nell'intervallo [ 3 .. 10 ], portando a 8 gruppi corretti di lettere da "A" a "Y" . Dobbiamo || 10ottenere il valore corretto per "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

Test d'ordine

Teniamo traccia dei segni di differenze tra numeri consecutivi nella maschera di bit v , inizialmente impostata su 3 (0b11):

• bit # 0: cancellato quando new_value> previous_value
• bit n. 1: cancellato quando new_value <valore_ precedente

Il valore precedente è memorizzato nella stessa variabile x dell'input. Questo assicura che la prima iterazione - dove in realtà non esiste alcun valore precedente - non cancellerà alcun bit, poiché una stringa contenente solo lettere non è né maggiore né minore di qualsiasi numero:

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

Viene ordinata una parola a meno che non vengano rilevati entrambi i segni, il che porta a v = 0 e non every()riesce.

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

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

Provalo online!

È stato molto divertente scrivere!

Spiegazione:

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

Grazie a @ErikTheOutgolfer, @leakynun e @BusinessCat per tutti i byte di salvataggio. :)

05AB1E , 36 byte

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

Provalo online!

MATL , 26 25 byte

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

L'input è in lettere maiuscole. L'output è 1o 0.

Provalo online!

Spiegazione

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

Buccia , 22 21 19 18 byte

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

Restituisce 1per input veritieri, 0per input falsi. Gli input devono essere in maiuscolo. Supera tutti i casi di test. Provalo online!

Spiegazione

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

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

Provalo online!

Accetta input in minuscolo.

Come funziona

⌊3681 / x ⌋ diminuisce da

• Da 38 a 37 a x .8 96.8684210526, prima a;
• 37 a 36 a x .4 99.4864864865, tra ce d;
• 36 a 35 a x ≈ 102,25, tra fe g;
• Da 35 a 34 a x ≈ 105.171428571, tra ie j;
• Da 34 a 33 a x ≈ 108.264705882, tra le m;
• Da 33 a 32 a x ≈ 111.545454545, tra oe p;
• Da 32 a 31 a x ≈ 115.03125, tra se t;
• 31 a 30 a x .7 118.741935484, tra ve w;
• 30 a 29 a x ≈ 122,7, dopo z.

C ++, 375 199 195 194 byte

Grazie alla risposta JavaScript di Shaggy:
-5 byte grazie 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 byte

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

Provalo online!

-1 grazie a Magic Octopus Urn .

Retina , 65 byte

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

^(<*|>*)>$

Provalo online! Il link include casi di test. Spiegazione:

T`_ADGJMPTW`d

Cambia la prima lettera di ogni tasto in una cifra. (Questo è disattivato di 1 ma non importa per un controllo crescente / decrescente. D'altra parte, gli zeri renderebbero la mia vita più difficile, quindi ho lasciato un carattere di riempimento.)

}T`L`_L

Mescola tutte le lettere rimanenti su 1 e ripeti fino a quando non sono state tutte convertite in cifre.

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

Converti le cifre in unarie, ma solo una volta per serie di cifre identiche. I valori unari sono separati da un <...

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

... ma se il LHS risulta essere maggiore della RHS, correggere la <a >.

1

Elimina le 1s che non sono più necessarie.

^(<*|>*)>$

Verifica che la parola sia ordinata. (Il trailing >proviene dall'ultima cifra che confronta sempre più dello spazio vuoto che lo segue.)

Pyth , 23 byte

Una delle mie prime risposte non banali su Pyth! 6 byte salvati grazie a @LeakyNun. La soluzione iniziale è di seguito.

/{_BKmhS,9/a58Cd3.13zSK

Test Suite.

Pyth , 29 byte

KmhS+9]/-Cd58 3.13w|qKSKqK_SK

Test Suite.

Spiegazione

/{_BKmhS,9/a58Cd3.13zSKQ - La Q indica input valutato ed è implicita alla fine

 {- Deduplicato
  _ - Inverti
   B - Biforcato, Crea un elenco di due elementi, [B, A (B)]
    K - Variabile con assegnazione automatica a:
     mz - Mappa sopra l'ingresso:
      hS - Minimo (primo elemento dell'elenco ordinato)
        , - Crea un elenco di due elementi, [A, B] con questi elementi:
         9 - Il letterale numerico 9
          / - La divisione intera di:
           a58Cd - La differenza assoluta tra 58 e ord (current_element)   
                3.13 - Il letterale numerico 3.13
                    SK - K ordinati
/ Q - Conta le occorrenze dell'input in [K, K [:: - 1]]                

05AB1E , 21 17 byte

Codice

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

Utilizza la codifica 05AB1E .

Provalo online! oppure Verifica tutti i casi di test!

Spiegazione

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

Questo ora mappa essenzialmente le seguenti lettere ai seguenti numeri:

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 byte

Funziona con stringhe di maiuscole e minuscole. Restituisce 1per verità o 0per falsità.

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

• 10 byte salvati grazie a Rod .

Provalo

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 byte

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

Provalo online!

Spiegazione

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

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

Ogni volta che vedo una domanda sul tastierino numerico, devo fare una risposta basata su pi.

Provalo online o verifica tutti i casi di test

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

Gelatina , 32 byte

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

Provalo online!

C # (.NET Core) , 133 byte

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

Provalo online!

Sento che c'è spazio per salvare, ma C # non è un linguaggio conciso, quindi forse no. 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
}

In particolare, penso che ci sia un modo più breve per esprimere il controllo finale per la validità, possibilmente un modo per integrarlo con il Zip. Trovare un modo per esprimere il fatto Zipsenza aver bisogno di una memoria temporanea per Skipsalvare anche qualcosa, ma dubito che ci sia qualcosa di più conciso per quello.

Python 3 , 143 147 148 149 130 byte

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)

Il meglio che posso fare per ora. La funzione grezza trasforma la lettera nel numero in base al codice ASCII. Ci sono sicuramente alcuni miglioramenti da apportare. 0 è verità, 1 è falsità (scusa). Risparmiato 10 byte grazie a Rod, altri 3 grazie a Mr. Xcoder.

Provalo online!

Python 2 , 111 103 byte

-8 byte grazie a @Arnold Palmer: non lower()necessario

• Accetta le lettere maiuscole come input.

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

Provalo online!

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

un porto da golf della risposta di 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;

accetta lettere maiuscole; output vuoto per falsy, 1per verità.

Esegui come pipe -nRo provalo online .

post originale:

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 byte

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

Provalo online

Naturalmente la brutta versione finisce per essere più 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 byte

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

Provalo online!

Vecchia soluzione:

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

Risparmiato 8 byte grazie a ThePirateBay.

Vecchia vecchia soluzione:

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

Vecchia vecchia vecchia soluzione:

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 byte

Δ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 ogni carattere nella stringa in un numero intero compreso tra 0 e 7 e prende la differenza tra ciascun elemento consecutivo; quindi controlla se le differenze minima e massima hanno lo stesso segno (o entrambi sono 0).

Zsh , 73 69 57 byte

-12 byte usando la 3681/codeconversione di @ anders-kaseorg .

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

Provalo online! Provalo online! Provalo online!

Alcune cose che abusiamo:

• ((statement,statement,...))è una sequenza di espressioni aritmetiche che restituisce la verità se l'ultima affermazione è diversa da zero.
• Il valore restituito di un ciclo è il valore restituito dell'ultima istruzione in un ciclo.
• Precedenze operatore aritmetico erano abbastanza bello per noi, come solo un paio di non sono stati utilizzati parentesi. È possibile salvare un byte se !associato meno strettamente di &.
• I parametri non impostati si espandono in 0in espansioni aritmetiche.
• La funzione che utilizziamo per mappare al numero di tastiera è CODE / 3.2 - 18(con un caso speciale per Z), ma poiché abbiamo solo bisogno di cambiare tra i codici, non facciamo la regolazione lineare.

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

2 byte possono essere salvati se i valori di verità / falsità possono essere scambiati.