(inspiré par ce post sur Puzzling. ATTENTION: SPOILERS POUR CE PUZZLE SONT CI-DESSOUS.)

Le clavier téléphonique standard met en corrélation les lettres et les chiffres comme suit:

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

Un mot d'entrée donné est défini comme un mot ordonné si, lorsqu'il est traduit sur des touches du clavier à l'aide de ce qui précède, le nombre résultant est soit non décroissant soit non croissant. En d'autres termes, le nombre résultant ne peut ni augmenter ni diminuer.

Par exemple, le mot se CATtraduit par 228, qui n'est pas décroissant, et donc un mot ordonné. Cependant, le mot DOGest 364, qui augmente et diminue à la fois, et n'est donc pas un mot ordonné.

Le défi

Étant donné un mot, affichez s'il est ordonné ou non.

Contribution

• Un mot (pas nécessairement un mot du dictionnaire) composé uniquement de lettres ( [A-Z]ou [a-z]) alphabétiques ASCII , dans n'importe quel format approprié .
• Votre choix si l'entrée est entièrement en majuscules ou en minuscules, mais elle doit être cohérente.
• Le mot comptera au moins 3 caractères.

Sortie

Une valeur véridique / falsey cohérente indiquant si le mot saisi est ordonné (véridique) ou non ordonné (falsey).

Règles

• Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
• Si possible, veuillez inclure un lien vers un environnement de test en ligne afin que d'autres personnes puissent essayer votre code!
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Exemples

Voici quelques mots ordonnés (c'est-à-dire véridiques), et il y en a plus sur le puzzle Puzzling lié.

CAT
TAC
AAA
DEMONS
SKID
LKJONMSRQP
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Voici quelques mots non ordonnés (c.-à-d. Falsey)

DOG
GOD
ROSE
COFFEE
JKLMNOGHI

Python 2 , 164 148 132 132 77 octets

-16 octets grâce à la suggestion de Rod ailleurs . Un frickin '-55 octets grâce à Arnold Palmer.

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

Essayez-le en ligne!

L'entrée doit être en majuscules. Sorties Trueou en Falsefonction de son ordre.

Explication

La première ligne associe chaque lettre à un nombre.

                               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

Cela fonctionne basé sur:

          | 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

_{* Les valeurs sont arrondies. : P}

La deuxième ligne sort si la liste des nombres est dans l'ordre croissant ou décroissant.

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

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

Renvoie un booléen.

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

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

Comment?

Conversion de lettres

Nous utilisons parseInt(c, 35)pour convertir chaque lettre de la chaîne d'entrée en un certain nombre dans [ 10 .. 34 ]. Parce qu'il s'agit de la base-35, "Z" est converti à la NaNplace.

L'expression * .32 | 0mappe ce nombre dans l'intervalle [ 3 .. 10 ], conduisant à 8 groupes de lettres corrects pour "A" à "Y" . Nous devons || 10obtenir la valeur correcte pour "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 de commande

Nous gardons une trace des signes de différences entre les nombres consécutifs dans le masque de bits v , initialement défini sur 3 (0b11):

• bit # 0: effacé lorsque new_value> previous_value
• bit # 1: effacé lorsque new_value <previous_value

La valeur précédente est stockée dans la même variable x que l'entrée. Cela garantit que la première itération - où aucune valeur précédente n'existe réellement - n'effacera aucun bit, car une chaîne contenant uniquement des lettres n'est ni supérieure ni inférieure à n'importe quel nombre:

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

Un mot est ordonné sauf si les deux signes sont rencontrés, ce qui conduit à v = 0 et fait every()échouer.

Gelée , 28, 27, 25, 23, 22, 21, 19, 18 octets

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

Essayez-le en ligne!

C'était très amusant à écrire!

Explication:

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

Merci à @ErikTheOutgolfer, @leakynun et @BusinessCat pour tous les octets de sauvegarde. :)

05AB1E , 36 octets

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

Essayez-le en ligne!

MATL , 26 25 octets

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

L'entrée est en majuscules. La sortie est 1ou 0.

Essayez-le en ligne!

Explication

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

Husk , 22 21 19 18 octets

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

Retourne 1pour les entrées véridiques, 0pour les fausses. Les entrées doivent être en majuscules. Réussit tous les cas de test. Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

Accepte les entrées en minuscules.

Comment ça marche

⌊3681 / x ⌋ diminue de

• 38 à 37 à x ≈ 96,8684210526, avant a;
• 37 à 36 à x ≈ 99,4864864865, entre cet d;
• 36 à 35 à x ≈ 102,25, entre fet g;
• 35 à 34 à x ≈ 105,171428571, entre iet j;
• 34 à 33 à x ≈ 108.264705882, entre let m;
• 33 à 32 à x ≈ 111,545454545, entre oet p;
• 32 à 31 à x ≈ 115.03125, entre set t;
• 31 à 30 à x ≈ 118,741935484, entre vet w;
• 30 à 29 à x ≈ 122,7, après z.

C ++, 375 199 195 194 octets

Merci à la réponse JavaScript de Shaggy:
-5 octets grâce à 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 octets

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

Essayez-le en ligne!

-1 grâce à Magic Octopus Urn .

Rétine , 65 octets

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

^(<*|>*)>$

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

T`_ADGJMPTW`d

Remplacez la première lettre de chaque touche par un chiffre. (Ceci est désactivé par 1 mais cela n'a pas d'importance pour un contrôle ascendant / descendant. D'un autre côté, les zéros rendraient ma vie plus difficile, alors j'ai laissé un caractère de remplissage.)

}T`L`_L

Mélangez toutes les lettres restantes de 1 et répétez jusqu'à ce qu'elles soient toutes converties en chiffres.

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

Convertissez les chiffres en unaire, mais une seule fois par série de chiffres identiques. Les valeurs unaires sont séparées par un <...

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

... mais si le LHS se révèle être supérieure à l'ERS, corriger l' <à >.

1

Supprimez les 1s qui ne sont plus nécessaires.

^(<*|>*)>$

Vérifiez que le mot est ordonné. (Le >dernier vient du dernier chiffre qui se compare toujours plus grand que l'espace vide qui le suit.)

Pyth , 23 octets

Une de mes premières réponses Pyth non triviales! 6 octets enregistrés grâce à @LeakyNun. La solution initiale est ci-dessous.

/{_BKmhS,9/a58Cd3.13zSK

Suite de tests.

Pyth , 29 octets

KmhS+9]/-Cd58 3.13w|qKSKqK_SK

Suite de tests.

Explication

/{_BKmhS,9/a58Cd3.13zSKQ - Le Q signifie l'entrée évaluée et est implicite à la fin

 {- Dédupliquer
  _ - Sens inverse
   B - Bifurquer, Créer une liste à deux éléments, [B, A (B)]
    K - Variable avec affectation automatique à:
     mz - Carte sur l'entrée:
      hS - Minimum (premier élément de la liste triée)
        , - Créez une liste à deux éléments, [A, B] avec ces éléments:
         9 - Le littéral numérique 9
          / - La division entière de:
           a58Cd - La différence absolue entre 58 et ord (current_element)   
                3.13 - Le littéral numérique 3.13
                    SK - K triés
/ Q - Compter les occurrences de l'entrée dans [K, K [:: - 1]]                

05AB1E , 21 17 octets

Code

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

Utilise l' encodage 05AB1E .

Essayez-le en ligne! ou Vérifiez tous les cas de test!

Explication

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

Cela mappe désormais essentiellement les lettres suivantes aux nombres suivants:

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 octets

Fonctionne avec des chaînes à casse mixte. Retourne 1pour véridique ou 0pour falsey.

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

• 10 octets économisés grâce à Rod .

Essayez-le

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 octets

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

Essayez-le en ligne!

Explication

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

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

Chaque fois que je vois une question de pavé numérique, je dois faire une réponse basée sur pi.

Essayez-le en ligne ou vérifiez tous les cas de 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?

Gelée , 32 octets

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

Essayez-le en ligne!

C # (.NET Core) , 133 octets

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

Essayez-le en ligne!

J'ai l'impression qu'il y a de la place pour économiser, mais C # n'est pas un langage concis donc peut-être pas. Non 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 particulier, je pense qu'il existe un moyen plus court d'exprimer la vérification finale de la validité, peut-être un moyen de l'intégrer au Zip. Trouver un moyen d'exprimer le Zipsans avoir besoin de stockage temporaire pour le Skipsauverait également quelque chose, mais je doute qu'il y ait quelque chose de plus concis pour cela.

Python 3 , 143 147 147 148 149 130 octets

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)

Le mieux que je puisse faire pour l'instant. La fonction brute transforme la lettre en nombre basé sur le code ascii. Il y a certainement des améliorations à apporter. 0 est véridique, 1 est falsey (désolé). Enregistré 10 octets grâce à Rod, 3 autres grâce à M. Xcoder.

Essayez-le en ligne!

Python 2 , 111 103 octets

-8 octets grâce à @Arnold Palmer: pas lower()besoin

• Prend les lettres majuscules en entrée.

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

Essayez-le en ligne!

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

un port golfé de la réponse d'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;

accepte les majuscules; sortie vide pour faux, 1pour vrai.

Exécuter en tant que pipe avec -nRou l' essayer en ligne .

poste d'origine:

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 octets

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

Essayez-le en ligne

Bien sûr, la version laide finit par être plus courte ...

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 153 117 octets

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

Essayez-le en ligne!

Ancienne solution:

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

8 octets enregistrés grâce à ThePirateBay.

Vieille vieille solution:

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

Vieille vieille vieille solution:

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 octets

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

Convertit chaque caractère de la chaîne en un entier de 0 à 7 et prend la différence entre chaque élément consécutif; vérifie ensuite si les différences minimum et maximum ont le même signe (ou bien 0).

Zsh , 73 69 57 octets

-12 octets en utilisant la 3681/codeconversion de @ anders-kaseorg .

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

Essayez-le en ligne! Essayez-le en ligne! Essayez-le en ligne!

Quelques choses que nous abusons:

• ((statement,statement,...))est une séquence d' expressions arithmétiques qui renvoie la vérité si la dernière instruction est non nulle.
• La valeur de retour d'une boucle est la valeur de retour de la dernière instruction d'une boucle.
• Les priorités des opérateurs arithmétiques ont été assez agréables pour nous, car une seule paire de parenthèses sans a été utilisée. Un octet pourrait être enregistré s'il est !lié moins étroitement que &.
• Les paramètres non définis se développent 0dans les extensions arithmétiques.
• La fonction que nous utilisons pour mapper au numéro du clavier est CODE / 3.2 - 18(avec un cas spécial pour Z), mais comme nous n'avons besoin que du changement entre les codes, nous ne faisons pas l'ajustement linéaire.

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 octets peuvent être sauvegardés si les valeurs vérité / falsey peuvent être échangées.