(แรงบันดาลใจจากโพสต์นี้ใน Puzzling ข้อควรระวัง: สปอยเลอร์สำหรับปริศนาที่มีอยู่ด้านล่าง)

ปุ่มกดโทรศัพท์มาตรฐานมีความสัมพันธ์กับตัวอักษรกับตัวเลขดังนี้:

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

คำที่ป้อนที่กำหนดจะถูกกำหนดให้เป็นคำสั่งถ้าหากแปลไปยังแป้นกดโดยใช้ด้านบนหมายเลขที่เป็นผลลัพธ์จะไม่ลดลงหรือไม่เพิ่มขึ้น กล่าวอีกนัยหนึ่งจำนวนผลลัพธ์ไม่สามารถเพิ่มและลดลงได้

ตัวอย่างเช่นคำCATแปล228ซึ่งไม่ลดลงและทำให้เป็นคำสั่ง อย่างไรก็ตามคำว่าDOGเป็น364ซึ่งทั้งเพิ่มขึ้นและลดลงและทำให้ไม่ได้รับคำสั่งของ Word

ความท้าทาย

ได้รับคำเอาท์พุทไม่ว่าจะสั่งหรือไม่

อินพุต

• คำ (ไม่จำเป็นต้องเป็นคำพจนานุกรม) ประกอบด้วยอักษร ASCII ( [A-Z]หรือ[a-z]) ตัวอักษรในรูปแบบที่เหมาะสมใด ๆ
• ตัวเลือกของคุณหากอินพุตเป็นตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็กทั้งหมด แต่ต้องสอดคล้องกัน
• คำจะมีความยาวอย่างน้อย 3 ตัวอักษร

เอาท์พุต

ค่าความจริง / เท็จที่สอดคล้องกันไม่ว่าจะเป็นคำอินพุต (จริง) หรือไม่ก็ได้สั่งซื้อ (เท็จ)

กฎระเบียบ

• ยอมรับได้ทั้งโปรแกรมหรือฟังก์ชั่น หากฟังก์ชั่นคุณสามารถส่งคืนผลลัพธ์มากกว่าการพิมพ์
• หากเป็นไปได้โปรดใส่ลิงค์ไปยังสภาพแวดล้อมการทดสอบออนไลน์เพื่อให้ผู้อื่นสามารถลองใช้รหัสของคุณได้!
• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• นี่คือรหัส - กอล์ฟเพื่อให้ใช้กฎการเล่นกอล์ฟตามปกติทั้งหมดและรหัสที่สั้นที่สุด (เป็นไบต์) ชนะ

ตัวอย่าง

ต่อไปนี้เป็นคำที่มีการเรียงลำดับ (เช่นความจริง) และมีเพิ่มเติมเกี่ยวกับปริศนา Puzzling ที่เชื่อมโยง

CAT
TAC
AAA
DEMONS
SKID
LKJONMSRQP
ABCDEFGHIJKLMNOPQRSTUVWXYZ

ต่อไปนี้เป็นคำบางคำที่ไม่มีคำสั่ง

DOG
GOD
ROSE
COFFEE
JKLMNOGHI

Python 2 , 164 148 132 77 ไบต์

-16 ไบต์ขอบคุณที่ให้ข้อเสนอแนะอื่น ๆ ของร็อด Frickin '-55 bytes ขอบคุณ Arnold Palmer

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}

บรรทัดที่สองแสดงผลลัพธ์หากรายการตัวเลขอยู่ในลำดับจากน้อยไปมากหรือมากไปหาน้อย

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 ] ที่นำไปสู่ 8 กลุ่มที่ถูกต้องของตัวอักษร"A"เพื่อ"Y" เราต้องการ|| 10ที่จะได้รับค่าที่ถูกต้องสำหรับ"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

ทดสอบคำสั่ง

เราติดตามสัญญาณของความแตกต่างระหว่างตัวเลขติดต่อกันเป็น bitmask vซึ่งเริ่มแรกเป็น 3 (0b11):

• บิต # 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<

อินพุตเป็นตัวอักษรตัวพิมพ์ใหญ่ เอาท์พุทเป็นหรือ10

ลองออนไลน์!

คำอธิบาย

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 ไบต์

±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 ไบต์

ขอบคุณคำตอบ JavaScript ของ Shaggy:
-5 ไบต์ขอบคุณ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 ไบต์

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

ลองออนไลน์!

-1 ขอบคุณที่เมจิกปลาหมึกโกศ

เรติน่า 65 ไบต์

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

^(<*|>*)>$

ลองออนไลน์! ลิงค์มีกรณีทดสอบ คำอธิบาย:

T`_ADGJMPTW`d

เปลี่ยนอักษรตัวแรกของแต่ละคีย์เป็นตัวเลข (นี่คือปิดโดย 1 แต่ที่ไม่สำคัญสำหรับการตรวจสอบขึ้น / ลงในทางกลับกันศูนย์จะทำให้ชีวิตของฉันยากขึ้นดังนั้นฉันทิ้งตัวละครตัวหนึ่งบรรจุ)

}T`L`_L

สุ่มตัวอักษรที่เหลือทั้งหมดขึ้น 1 และทำซ้ำจนกว่าพวกเขาจะถูกแปลงเป็นตัวเลข

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

แปลงตัวเลขเป็น unary แต่เพียงครั้งเดียวต่อการทำงานของตัวเลขที่เหมือนกัน ค่า unary ถูกคั่นด้วย<...

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

... แต่ถ้า LHS จะเปิดออกจะมากกว่า RHS, แก้ไขไป<>

1

ลบ1s ที่ไม่จำเป็นอีกต่อไป

^(<*|>*)>$

ตรวจสอบว่าคำสั่งนั้น (การติดตาม>มาจากตัวเลขสุดท้ายซึ่งจะเปรียบเทียบมากกว่าพื้นที่ว่างที่ตามมาเสมอ)

Pyth , 23 ไบต์

หนึ่งในคำตอบ Pyth ที่ไม่ใช่เรื่องแปลกแรกของฉัน! บันทึกแล้ว 6 ไบต์ขอบคุณ @LeakyNun วิธีแก้ปัญหาเบื้องต้นคือด้านล่าง

/{_BKmhS,9/a58Cd3.13zSK

ชุดทดสอบ

Pyth , 29 ไบต์

KmhS+9]/-Cd58 3.13w|qKSKqK_SK

ชุดทดสอบ

คำอธิบาย

/{_BKmhS,9/a58Cd3.13zSKQ - Q หมายถึงอินพุตที่ประเมินและมีความหมายโดยนัยในตอนท้าย

 {- ซ้ำซ้อน
  _ - ย้อนกลับ
   B - สองแยกสร้างรายการสององค์ประกอบ [B, A (B)]
    K - ตัวแปรที่มีการกำหนดอัตโนมัติไปที่:
     mz - แผนที่เหนืออินพุต:
      hS - ขั้นต่ำ (องค์ประกอบแรกของรายการที่เรียงลำดับ)
        , - สร้างรายการสององค์ประกอบ, [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()

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

Gaia , 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Ë

เมื่อใดก็ตามที่ฉันเห็นคำถาม numpad ฉันต้องตอบตาม 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 # ไม่ใช่ภาษาที่กระชับดังนั้นอาจไม่ใช่ 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
}

โดยเฉพาะอย่างยิ่งผมคิดว่ามีวิธีที่สั้นกว่าที่จะแสดงการตรวจสอบขั้นสุดท้ายสำหรับความถูกต้องอาจจะเป็นวิธีการที่จะ inline 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 คือความเท็จ (ขออภัย) บันทึก 10 ไบต์ขอบคุณ Rod และอีก 3 ขอบคุณ Mr. Xcoder

ลองออนไลน์!

Python 2 , 111 103 ไบต์

-8 ไบต์ขอบคุณ @Arnold Palmer: ไม่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 ไบต์

พอร์ตแข็งแรงเล่นกอล์ฟของคำตอบ Arnauld's

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 bytes

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) , 183 169 153 117 ไบต์

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

บันทึก 8 ไบต์ขอบคุณ ThePirateBay

วิธีแก้ปัญหาเก่า:

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 ไบต์

-12 ไบต์โดยใช้3681/codeการแปลงของ @ anders-kaseorg

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

ลองออนไลน์! ลองออนไลน์! ลองออนไลน์!

บางสิ่งที่เราละเมิด:

• ((statement,statement,...))เป็นลำดับของเลขคณิตนิพจน์ที่ส่งกลับค่าความจริงหากข้อความล่าสุดไม่ใช่ศูนย์
• ค่าส่งคืนของลูปคือค่าส่งคืนของคำสั่งสุดท้ายในลูป
• precedences ประกอบการทางคณิตศาสตร์ได้สวยดีที่เราเป็นเพียงหนึ่งคู่ของ ไม่มีวงเล็บถูกนำมาใช้ หนึ่งไบต์จะถูกบันทึกไว้ถ้าผูกไว้แน่นน้อยกว่า!&
• พารามิเตอร์ที่ไม่ได้ตั้งค่าจะ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 ไบต์หากสามารถสลับค่าความจริง / เท็จได้