(Inspiriert von diesem Beitrag über Rätsel. ACHTUNG: SPOILER FÜR DIESE PUZZLE SIND UNTEN.)

Die Standard-Telefontastatur korreliert Buchstaben und Zahlen wie folgt:

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

Ein gegebenes Eingabewort wird als ein geordnetes Wort definiert, wenn beim Umsetzen auf die Tastatur unter Verwendung der obigen Angaben die resultierende Zahl entweder nicht abnimmt oder nicht zunimmt. Mit anderen Worten, die resultierende Anzahl kann nicht sowohl steigen als auch fallen abnehmen.

Zum Beispiel CATübersetzt das Wort in 228, was nicht abnehmend ist und somit ein geordnetes Wort. Das Wort DOGist jedoch364 , was sowohl zunimmt als auch abnimmt und somit kein geordnetes Wort ist.

Die Herausforderung

Geben Sie bei gegebenem Wort aus, ob es bestellt ist oder nicht.

Eingang

• Ein Wort (nicht unbedingt ein Wörterbuchwort), das nur aus ASCII-Buchstaben ( [A-Z]oder [a-z]Buchstaben) in einem geeigneten Format besteht .
• Sie können wählen, ob die Eingabe nur in Groß- oder Kleinbuchstaben erfolgen soll, sie muss jedoch konsistent sein.
• Das Wort wird mindestens 3 Zeichen lang sein.

Ausgabe

Ein konsistenter Wert für Wahrhaftigkeit / Falschheit, der angibt , ob das Eingabewort geordnet ist (Wahrhaftigkeit) oder nicht (Falschheit).

Regeln

• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Fügen Sie nach Möglichkeit einen Link zu einer Online-Testumgebung hinzu, damit andere Benutzer Ihren Code ausprobieren können!
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Beispiele

Hier sind einige geordnete Wörter (dh wahrheitsgemäß) und es gibt mehr über das verknüpfte Rätsel.

CAT
TAC
AAA
DEMONS
SKID
LKJONMSRQP
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Hier sind einige nicht geordnete Wörter (zB Falsey)

DOG
GOD
ROSE
COFFEE
JKLMNOGHI

Python 2 , 164 148 132 77 Bytes

-16 Bytes dank Rods Vorschlag an anderer Stelle . Ein verdammt -55 Bytes dank Arnold Palmer.

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

Probieren Sie es online!

Die Eingabe muss in Großbuchstaben erfolgen. Outputs Trueoder Falsebasierend auf seiner Ordnungsmäßigkeit.

Erläuterung

Die erste Zeile ordnet jeden Buchstaben einer Zahl zu.

                               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

Dies funktioniert basierend auf:

          | 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

_{* Werte sind gerundet. : P}

Die zweite Zeile gibt aus, ob die Liste der Nummern aufsteigend oder absteigend sortiert ist.

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

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

Gibt einen Booleschen Wert zurück.

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

Testfälle

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

Wie?

Briefkonvertierung

Wir verwenden parseInt(c, 35), um jeden Buchstaben der Eingabezeichenfolge in eine Zahl in [ 10 .. 34 ] umzuwandeln . Da es sich um die Basis 35 handelt, wird stattdessen "Z" in konvertiert NaN.

Der Ausdruck * .32 | 0ordnet diese Zahl dem Intervall [ 3 .. 10 ] zu, was zu 8 korrekten Buchstabengruppen für "A" bis "Y" führt . Wir müssen || 10den richtigen Wert für "Z" erhalten .

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

Wir verfolgen die Anzeichen von Unterschieden zwischen aufeinanderfolgenden Zahlen in der Bitmaske v , die anfänglich auf 3 gesetzt war (0b11):

• Bit # 0: gelöscht, wenn new_value> previous_value
• Bit 1: gelöscht, wenn new_value <previous_value

Der vorherige Wert wird in derselben Variablen x wie der Eingang gespeichert . Dies stellt sicher, dass die erste Iteration, bei der kein vorheriger Wert vorhanden ist, kein Bit löscht, da eine Zeichenfolge, die nur Buchstaben enthält, weder größer noch kleiner als eine Zahl ist:

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

Ein Wort wird geordnet, wenn nicht beide Zeichen angetroffen werden, was zu v = 0 führt und zum every()Scheitern führt.

Jelly , 28, 27, 25, 23, 22, 21, 19, 18 Bytes

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

Probieren Sie es online!

Es hat viel Spaß gemacht, dies zu schreiben!

Erläuterung:

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

Vielen Dank an @ErikTheOutgolfer, @leakynun und @BusinessCat für alle sparenden Bytes. :)

05AB1E , 36 Bytes

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

Probieren Sie es online!

MATL , 26 25 Bytes

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

Die Eingabe erfolgt in Großbuchstaben. Ausgang ist 1oder 0.

Probieren Sie es online!

Erläuterung

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

Schale , 22, 21, 19 18 Bytes

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

Returns 1für truthy Eingänge,0 für falsche. Eingaben müssen in Großbuchstaben erfolgen. Besteht alle Testfälle. Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Akzeptiert Eingaben in Kleinbuchstaben.

Wie es funktioniert

⌊3681 / x ⌋ verringert sich von

• 38 bis 37 bei x 96,8684210526 vora ;
• 37 bis 36 bei x 99,4864864865 zwischen cundd ;
• 36 bis 35 bei x ≤ 102,25 zwischen fundg ;
• 35 bis 34 bei x 105,171428571 zwischen iundj ;
• 34 bis 33 bei x 108,264705882 zwischen lundm ;
• 33 bis 32 bei x 111,545454545, zwischen oundp ;
• 32 bis 31 bei x ≈ 115.03125, zwischen sundt ;
• 31 bis 30 bei x 118,741935484 zwischen vundw ;
• 30 bis 29 bei x 122,7, danach z.

C ++, 375 199 195 194 Bytes

Dank Shaggys JavaScript-Antwort:
-5 Bytes dank 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‹Ë

Probieren Sie es online!

-1 dank Magic Octopus Urn .

Netzhaut , 65 Bytes

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

^(<*|>*)>$

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

T`_ADGJMPTW`d

Ändern Sie den ersten Buchstaben jeder Taste in eine Ziffer. (Dies ist um 1 verschoben, aber das spielt für eine Überprüfung aufsteigend / absteigend keine Rolle. Auf der anderen Seite würden Nullen mein Leben erschweren, sodass ich ein Füllzeichen belassen habe.)

}T`L`_L

Mische alle verbleibenden Buchstaben um 1 und wiederhole, bis sie alle in Ziffern umgewandelt wurden.

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

Konvertieren Sie die Ziffern in unäre, jedoch nur einmal pro Lauf identischer Ziffern. Die unären Werte werden mit einem <...

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

... aber wenn sich herausstellt, dass der LHS-Wert größer ist als der RHS-Wert, korrigieren Sie den <to- Wert >.

1

Löschen Sie die 1nicht mehr benötigten s.

^(<*|>*)>$

Überprüfen Sie, ob das Wort geordnet ist. (Das Ende >stammt von der letzten Ziffer, die immer größer ist als das Leerzeichen, das darauf folgt.)

Pyth , 23 Bytes

Eine meiner ersten nicht trivialen Pyth-Antworten! 6 Bytes dank @LeakyNun gespart. Die anfängliche Lösung ist unten.

/{_BKmhS,9/a58Cd3.13zSK

Test Suite.

Pyth , 29 Bytes

KmhS+9]/-Cd58 3.13w|qKSKqK_SK

Test Suite.

Erläuterung

/{_BKmhS,9/a58Cd3.13zSKQ - Das Q bedeutet ausgewertete Eingabe und ist am Ende implizit

 {- Deduplizieren
  _ - Rückwärts
   B - Gabelung, Erstellen einer Liste mit zwei Elementen, [B, A (B)]
    K - Variable mit automatischer Zuordnung zu:
     mz - Karte über die Eingabe:
      hS - Minimum (erstes Element der sortierten Liste)
        , - Erstellen Sie eine Liste mit zwei Elementen, [A, B], mit diesen Elementen:
         9 - Das numerische Literal 9
          / - Die ganzzahlige Division von:
           a58Cd - Der absolute Unterschied zwischen 58 und ord (current_element)   
                3.13 - Das numerische Literal 3.13
                    SK - K sortiert
/ Q - Zähle die Vorkommen der Eingabe in [K, K [:: - 1]]                

05AB1E , 21 17 Bytes

Code

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

Verwendet die 05AB1E- Codierung.

Probieren Sie es online! oder Überprüfen Sie alle Testfälle!

Erläuterung

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

Dies ordnet nun im Wesentlichen die folgenden Buchstaben den folgenden Zahlen zu:

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

Funktioniert mit Strings in Groß- und Kleinschreibung. Returns 1für truthy oder 0für Falsey.

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

• 10 Bytes gespart dank Rod .

Versuch es

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

Probieren Sie es online!

Erläuterung

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

Immer wenn ich eine Frage auf dem Nummernblock sehe, muss ich eine pi-basierte Antwort geben.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle

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

Gelee , 32 Bytes

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

Probieren Sie es 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));};

Probieren Sie es online!

Ich glaube, es gibt etwas Platz zum Speichern, aber C # ist keine prägnante Sprache, also vielleicht auch nicht. 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
}

Insbesondere denke ich, dass es eine kürzere Möglichkeit gibt, die endgültige Gültigkeitsprüfung auszudrücken, möglicherweise eine Möglichkeit, sie mit der zu verknüpfen Zip. Einen Weg zu finden, um das auszudrücken, Zipohne dass ein temporärer Speicher für die Daten erforderlich ist, Skipwürde ebenfalls etwas sparen, aber ich bezweifle, dass es etwas prägnanteres dafür gibt.

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)

Das Beste, was ich jetzt tun kann. Die Crude-Funktion wandelt den Buchstaben in eine Zahl um, die auf dem ASCII-Code basiert. Es müssen definitiv einige Verbesserungen vorgenommen werden. 0 ist wahr, 1 ist falsch (sorry). Dank Rod 10 Bytes gespart, dank Mr. Xcoder weitere 3 Bytes.

Probieren Sie es online!

Python 2 , 111 103 Bytes

-8 Bytes dank @Arnold Palmer: nicht lower()erforderlich

• Nimmt Großbuchstaben als Eingabe.

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

Probieren Sie es online!

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

ein Golfhafen von Arnauld´s Antwort .

for(;$c=ord($argn[$i]);$v|=$i++?$p>$k?2:$p<$k:0,$p=$k)$k=($c-58)*.32%10?:9;echo$v<3;

akzeptiert Großbuchstaben; leere Ausgabe für falsch,1 für wahr.

Laufen Sie als Pipe mit -nRoder versuchen Sie es online .

ursprünglicher Beitrag:

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

Probieren Sie es online

Natürlich wird die hässliche Version kürzer ...

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

Probieren Sie es online!

Alte Lösung:

#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 Bytes dank ThePirateBay gespart.

Alte alte Lösung:

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

Alt alt alt Lösung:

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

Konvertiert jedes Zeichen in der Zeichenfolge in eine Ganzzahl von 0 bis 7 und berechnet die Differenz zwischen den einzelnen aufeinanderfolgenden Elementen. prüft dann, ob die minimale und die maximale Differenz das gleiche Vorzeichen haben (oder 0 ist).

Zsh , 73 69 57 Bytes

-12 Bytes mit der 3681/codeKonvertierung von @ anders-kaseorg .

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

Probieren Sie es online! Probieren Sie es online! Probieren Sie es online!

Ein paar Dinge, die wir missbrauchen:

• ((statement,statement,...))ist eine Folge von arithmetischen Ausdrücken, die die Wahrheit zurückgibt, wenn die letzte Anweisung nicht Null ist.
• Der Rückgabewert einer Schleife ist der Rückgabewert der letzten Anweisung in einer Schleife.
• Arithmetische Operator-Prioritäten waren für uns sehr nett, da nur ein Paar ohne Klammern verwendet wurde. Ein Byte könnte gespeichert werden, wenn !es weniger eng gebunden ist als& .
• Nicht gesetzte Parameter werden 0in arithmetischen Erweiterungen auf erweitert.
• Die Funktion, mit der wir der Tastaturnummer zuordnen, ist CODE / 3.2 - 18(mit einem Sonderfall für Z), aber da wir nur den Wechsel zwischen Codes benötigen , nehmen wir keine lineare Anpassung vor.

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 Bytes können gespeichert werden, wenn die Wahrheits- / Falschheitswerte ausgetauscht werden können.