Est-ce un mot ordonné?


26

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

Related and Related Je ne suis pas sûr que ce ne soit pas dupe, le seul changement entre abc->t9et ce défi est de vérifier la monotonie?
nmjcman101

1
@ nmjcman101 Oui, ceux-ci sont liés, mais il pourrait y avoir d'autres moyens (meilleurs?) que strictement abc->t9.
AdmBorkBork

Cela a du sens, j'espère voir quelque chose battre cette méthode
nmjcman101


Demande de scénario de test:AAA
Business Cat

Réponses:


13

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


1
Sainte vache, c'est génial. Merci!
2017 totalement humain

J'allais le poster comme réponse parce que je l'ai écrit avant que tout le monde ne déborde de réponses, mais tu m'as snipé :)
Arnold Palmer

8

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


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.


Oh, belle astuce pour obtenir le numéro de chaque lettre :) Je suis déchiré quant à savoir si je devrais l'emprunter ou non, car cela signifierait que je serais à égalité avec vous, ce qui ne semble pas correct.
Shaggy

6

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



3

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

Score approprié pour un défi alphabétique: P
DJMcMayhem

@DJMcMayhem Plus maintenant :-D
Luis Mendo

3

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

3

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.

2

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

Pouvez-vous déplacer la int j=1,i=0,d=0boucle for?
Zacharý

@ Zacharý Depuis iet dsont utilisés en dehors du bloc de boucle, je ne peux pas
HatsuPointerKun

i==0||d==0==> i*d==0.
Zacharý

Ça !(i*d)marcherait? (en supprimant l'espace après return)
Zacharý

@ Zacharý Oui, cela fonctionne
HatsuPointerKun

1

05AB1E , 30 octets

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

Essayez-le en ligne!

-1 grâce à Magic Octopus Urn .


L'avez-vous utilisé ¥0K0.SËparce que ce ¥0‹Ën'est pas correct? Je ne peux pas dire si 0.Sc'est nécessaire.
Magic Octopus Urn

@MagicOctopusUrn En fait, cela ¥0K0‹Ësemble fonctionner.
Erik the Outgolfer

Oui, si vous supprimez les 0, cela devrait; dans ma réponse, je ne suis pas sûr que cela fonctionne.
Magic Octopus Urn

@MagicOctopusUrn Je supprime les 0 car sinon il y aura de faux négatifs. Votre réponse pourrait cependant se comporter différemment.
Erik the Outgolfer

1

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


C'est plutôt cool. Merci pour l'explication approfondie.
AdmBorkBork

1

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


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

1

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>


1
Math.min((parseInt(c,36)-3)/3.13|0,9)à la place "2..9"[parseInt(c,36)-10]pour économiser quelques octets
Rod

Merci, @Rod; très agréable. Je vais devoir le ranger pour une utilisation future.
Shaggy


Merci, @ThePirateBay, mais, malheureusement, cela échoue pour la saisie AAA.
Shaggy

1

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)

1

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?


0

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.


0

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!


vous pouvez utiliser x=[f(a)-f(b)for a,b in zip(s,s[1:])]pour enregistrer quelques octets
Rod

aussi, min(int((ord(c)-58)/3.13),9)est un moyen plus court de convertir l'omble chevalier
Rod


@Rod Merci! Très utile.
C McAvoy

Vous devrez permuter vos sorties pour que cela soit valide.
Shaggy

0

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!


1
Vous pouvez supprimer le .lower()puisque l'entrée peut être dans tous les cas que vous spécifiez.
Arnold Palmer

0

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;

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.

0

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

0

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


Je pense que ΔList(int(4^-1seq(inString("DEF GHI JKL MNO PQRSTUV WXYZ",sub(Ans,I,1))+3,I,1,length(Anssauve un octet.
lirtosiast

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.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.