（Puzzlingに関するこの投稿に触発されました。注意：そのパズルのネタバレは下にあります。）

標準の電話キーパッドは、次のように文字と数字を関連付けます。

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

上記を使用してキーパッドプレスに変換したときに、結果の数値が非減少または非増加である場合、特定の入力単語は順序付き単語として定義されます。言い換えれば、結果の数は増加も減少もできません。

たとえば、単語はにCAT変換され228ます。これは減少しないため、順序付けされた単語です。ただし、単語DOGは364であり、これは増加と減少の両方であるため、順序付けされた単語ではありません。

チャレンジ

単語が与えられたら、それが順序付けられているかどうかを出力します。

入力

• ASCIIアルファベット（[A-Z]または[a-z]）文字のみで構成される適切な形式の単語（必ずしも辞書の単語である必要はありません）。
• 入力がすべて大文字またはすべて小文字の場合の選択ですが、一貫性が必要です。
• 単語の長さは少なくとも3文字になります。

出力

入力語が順序付けられている（真実）か、順序付けされていない（偽）かについての一貫した真実/偽の値。

ルール

• 完全なプログラムまたは機能のいずれかが受け入れられます。関数の場合、出力する代わりに出力を返すことができます。
• 可能であれば、他の人があなたのコードを試すことができるように、オンラインテスト環境へのリンクを含めてください！
• 標準的な抜け穴は禁止されています。
• これはコードゴルフなので、通常のゴルフルールがすべて適用され、最短のコード（バイト単位）が勝ちます。

例

ここにいくつかの順序付けされた単語（つまり、真実）があり、リンクされたパズルパズルにはもっとあります。

CAT
TAC
AAA
DEMONS
SKID
LKJONMSRQP
ABCDEFGHIJKLMNOPQRSTUVWXYZ

ここにいくつかの非順序語（すなわち、偽）があります

DOG
GOD
ROSE
COFFEE
JKLMNOGHI

パイソン2、164の 148 132 77バイト

他の場所でRodが提案した-16バイトのおかげ。アーノルドパーマー氏のおかげで、-55バイトの途方もない結果が得られました。

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

オンラインでお試しください！

入力は大文字でなければなりません。出力TrueまたはFalseその順序に基づいています。

説明

最初の行は、各文字を数字にマップします。

                               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

これは以下に基づいて機能します。

          | 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

_{*値は四捨五入されます。：P}

2番目の行は、数値のリストが昇順または降順の場合に出力されます。

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

JavaScript（ES6）、 83 ... 71  70バイト

ブール値を返します。

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

テストケース

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

どうやって？

文字変換

parseInt(c, 35)入力文字列の各文字を[ 10 .. 34 ]の数値に変換するために使用します。base-35であるため、「Z」はNaN代わりに変換されます。

式* .32 | 0はこの数値を間隔[ 3 .. 10 ]にマッピングし、「A」から「Y」までの8つの正しい文字グループを導きます。"Z"の|| 10正しい値を取得する必要があります。

           | 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

注文テスト

最初に3（0b11）に設定されたビットマスクvへの連続した数値の差の兆候を追跡します。

• ビット＃0：new_value> previous_valueのときにクリア
• ビット＃1：new_value <previous_valueの場合にクリア

前の値は、入力と同じ変数xに格納されます。これにより、文字のみを含む文字列は数字より大きくも小さくもないため、最初の反復（実際には以前の値が存在しない）はビットをクリアしません。

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

両方の記号が検出されない限り、単語は順序付けられ、v = 0になり、every()失敗します。

ゼリー、28、27、25、23、22、21、19、 18のバイト

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

オンラインでお試しください！

これは書くのがとても楽しかったです！

説明：

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

すべてのバイトを節約してくれた@ ErikTheOutgolfer、@ leakynun、@ BusinessCatに感謝します。:)

05AB1E、36バイト

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

オンラインでお試しください！

MATL、26 25バイト

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

入力は大文字です。出力は1または0です。

オンラインでお試しください！

説明

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

ハスク、22 21 19 18バイト

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

1虚偽の入力に対して、真実の入力に対して返します0。入力は大文字でなければなりません。すべてのテストケースに合格します。 オンラインでお試しください！

説明

±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バイト

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

オンラインでお試しください！

小文字の入力を受け入れます。

使い方

⌊3681/ X ⌋減少から

• 38〜37でX ≈96.8684210526、前a。
• 37〜36でX ≈99.4864864865、の間cとd、
• 36〜35でX ≈102.25、の間fとg、
• 35〜34でX ≈105.171428571、間iとj;
• 34〜33でX ≈108.264705882、間lとm;
• 33〜32において、X ≈111.545454545、間oとp;
• 32〜31において、X ≈115.03125、間sとt;
• 31〜30におけるX ≈118.741935484、間vとw;
• 30の29へのXの後、≈122.7 z。

C ++、375 199 195 194バイト

ShaggyのJavaScriptの回答に
感謝します：Zacharýのおかげで-5バイト

#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バイト

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

オンラインでお試しください！

-1 Magic Octopus Urnに感謝します。

網膜、65バイト

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

^(<*|>*)>$

オンラインでお試しください！リンクにはテストケースが含まれます。説明：

T`_ADGJMPTW`d

各キーの最初の文字を数字に変更します。（これは1ずつずれていますが、昇順/降順のチェックには関係ありません。一方、ゼロは私の人生をより難しくするので、フィラー文字を1つ残しました。）

}T`L`_L

残りのすべての文字を1つずつシャッフルし、すべて数字に変換されるまで繰り返します。

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

数字を単項に変換しますが、同一の数字の実行ごとに1回だけにします。単項値は<...で区切られています

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

...しかし、LHSがRHSよりも大きい場合、<toを修正し>ます。

1

1不要になったsを削除します。

^(<*|>*)>$

単語が順序付けられていることを確認します。（末尾>は最後の桁に由来し、常に後続の空のスペースよりも大きく比較されます。）

Pyth、23バイト

私の最初の重要なPyth回答の1つです！@LeakyNunのおかげで6バイト節約されました。最初の解決策は次のとおりです。

/{_BKmhS,9/a58Cd3.13zSK

テストスイート。

Pyth、29バイト

KmhS+9]/-Cd58 3.13w|qKSKqK_SK

テストスイート。

説明

/{_BKmhS,9/a58Cd3.13zSKQ-Qは評価された入力を意味し、最後に暗黙的です

 {-重複排除
  _-リバース
   B-分岐、2要素リストの作成、[B、A（B）]
    K-次への自動割り当てがある変数：
     mz-入力上のマップ：
      hS-最小（ソート済みリストの最初の要素）
        、-これらの要素を含む2要素リスト[A、B]を作成します。
         9-数値リテラル9
          /-整数の除算：
           a58Cd-58とord（current_element）の絶対差   
                3.13-数値リテラル3.13
                    SK-Kソート済み
/ Q-[K、K [::-1]]の入力の出現回数をカウントします                

05AB1E、21 17バイト

コード

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

05AB1Eエンコードを使用します。

オンラインでお試しください！またはすべてのテストケースを検証してください！

説明

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

これにより、基本的に次の文字が次の数字にマッピングされます。

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バイト

大/小文字混合ストリングで機能します。1真実か偽か0を返します。

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

• Rodのおかげで10バイト節約されました。

それを試してみてください

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>

ガイア、29 27 25 17 バイト

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

オンラインでお試しください！

説明

ċ                  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バイト

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

テンキーの質問が表示されるたびに、piベースの回答を作成する必要があります。

オンラインそれを試してみたり、すべてのテストケースを検証します

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

ゼリー、32バイト

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

オンラインでお試しください！

C＃（.NET Core）、133バイト

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

オンラインでお試しください！

保存する余地があるように感じますが、C＃は簡潔な言語ではないので、多分そうではありません。ゴルフをしていない：

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
}

特に、妥当性の最終チェックを表現するより短い方法、おそらくそれをでインライン化する方法があると思いますZip。のZip一時的なストレージを必要とせずに表現する方法を見つけることはSkip何かを節約することにもなりますが、もっと簡潔な何かがあるとは思いません。

Pythonの3、143の 147 148 149 130バイト

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)

今のところできること。粗関数は、文字をASCIIコードに基づいた数字に変換します。間違いなくいくつかの改善点があります。0は真実、1は偽です（ごめん）。Rodのおかげで10バイト、Mr。Xcoderのおかげで3バイト節約できました。

オンラインでお試しください！

パイソン2、111の 103バイト

@Arnold Palmerのおかげで-8バイト：lower()不要

• 入力として大文字を使用します。

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

オンラインでお試しください！

PHP 7、98 + 1 95 + 1 84 + 1バイト

アーナウドのゴルフ場の答え。

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

大文字を受け入れます。虚偽、1真実のための空の出力。

でパイプとして実行する-nRか、オンラインで試してください。

元の投稿：

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バイト

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

オンラインで試す

もちろん、いバージョンは短くなります...

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）、183169153117バイト

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

オンラインでお試しください！

古いソリューション：

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

ThePirateBayのおかげで8バイト節約されました。

古い古いソリューション：

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

古い古い古いソリューション：

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バイト

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

文字列の各文字を0〜7の整数に変換し、連続する各要素間の差を取得します。次に、最小と最大の差が同じ符号を持っている（またはどちらかが0である）かどうかをチェックします。

Zsh、73 69 57バイト

@ anders-kaseorgの3681/code変換を使用して-12バイト。

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

オンラインでお試しください！ オンラインでお試しください！ オンラインでお試しください！

悪用するいくつかのこと：

• ((statement,statement,...))最後のステートメントがゼロ以外の場合に真理を返す一連の算術式です。
• ループの戻り値は、ループの最後のステートメントの戻り値です。
• 算術演算子の優先順位は、かっこなしの1つのペアのみ が使用されたため、非常に便利でした。バインドが1バイトより少ない場合は、1バイトを節約できます。!&
• 未設定パラメーターは0、算術展開で展開されます。
• キーパッド番号へのマッピングに使用する関数はCODE / 3.2 - 18（の特別な場合Z）ですが、コード間の変更のみが必要なため、線形調整は行いません。

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バイトを節約できます。