(lấy cảm hứng từ bài đăng này trên Puzzling. THẬN TRỌNG: SPOILERS CHO R PUNG BÉ DƯỚI ĐÂY.)

Bàn phím điện thoại tiêu chuẩn tương quan các chữ cái với các số như sau:

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

Một từ đầu vào đã cho được xác định là một từ được sắp xếp nếu, khi được dịch sang các lần nhấn bàn phím bằng cách sử dụng ở trên, số kết quả là không giảm hoặc không tăng. Nói cách khác, số kết quả không thể tăng và giảm.

Ví dụ: từ này CATdịch ra 228, không giảm, và do đó, một từ có thứ tự. Tuy nhiên, từ DOGnày 364, cả tăng và giảm, và do đó không phải là một từ có thứ tự.

Các thách thức

Đưa ra một từ, đầu ra cho dù nó được đặt hàng hay không.

Đầu vào

• Một từ (không nhất thiết phải là một từ trong từ điển) chỉ bao gồm các chữ cái trong bảng chữ cái ASCII ( [A-Z]hoặc [a-z]), ở bất kỳ định dạng phù hợp nào .
• Sự lựa chọn của bạn nếu đầu vào là tất cả chữ hoa hoặc tất cả chữ thường, nhưng nó phải nhất quán.
• Từ này sẽ có ít nhất 3 ký tự.

Đầu ra

Giá trị trung thực / falsey nhất quán cho việc từ đầu vào được sắp xếp theo thứ tự (trung thực) hay không được đặt hàng (falsey).

Quy tắc

• Một chương trình đầy đủ hoặc một chức năng được chấp nhận. Nếu một chức năng, bạn có thể trả lại đầu ra thay vì in nó.
• Nếu có thể, vui lòng bao gồm một liên kết đến một môi trường thử nghiệm trực tuyến để người khác có thể thử mã của bạn!
• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn, vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất (tính bằng byte) sẽ thắng.

Ví dụ

Dưới đây là một số từ có thứ tự (nghĩa là trung thực), và có nhiều hơn về câu đố khó hiểu được liên kết.

CAT
TAC
AAA
DEMONS
SKID
LKJONMSRQP
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Dưới đây là một số từ không theo thứ tự (ví dụ: falsey)

DOG
GOD
ROSE
COFFEE
JKLMNOGHI

Python 2 , 164 148 132 77 byte

-16 byte nhờ đề xuất của Rod ở nơi khác . Một frickin '-55 byte nhờ Arnold Palmer.

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

Hãy thử trực tuyến!

Đầu vào phải là chữ hoa. Đầu ra Truehoặc Falsedựa trên thứ tự của nó.

Giải trình

Dòng đầu tiên ánh xạ mỗi chữ cái thành một số.

                               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

Điều này hoạt động dựa trê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

_{* Giá trị được làm tròn. : P}

Dòng thứ hai xuất ra nếu danh sách các số theo thứ tự tăng dần hoặc giảm dần.

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

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

Trả về một boolean.

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

Các trường hợp thử nghiệm

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

Làm sao?

Chuyển đổi thư

Chúng tôi sử dụng parseInt(c, 35)để chuyển đổi từng chữ cái của chuỗi đầu vào thành một số trong [ 10 .. 34 ]. Vì là cơ sở 35, "Z" được chuyển đổi thành NaNthay thế.

Biểu thức * .32 | 0ánh xạ số này vào khoảng [ 3 .. 10 ], dẫn đến 8 nhóm chữ cái chính xác cho "A" thành "Y" . Chúng ta cần || 10lấy giá trị chính xác cho "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

Kiểm tra đơn hàng

Chúng tôi theo dõi các dấu hiệu khác biệt giữa các số liên tiếp vào bitmask v , ban đầu được đặt thành 3 (0b11):

• bit # 0: bị xóa khi new_value> trước_value
• bit # 1: bị xóa khi new_value <trước_value

Giá trị trước được lưu trong cùng một biến x với đầu vào. Điều này đảm bảo rằng lần lặp đầu tiên - nơi không có giá trị trước đó thực sự tồn tại - sẽ không xóa bất kỳ bit nào, bởi vì một chuỗi chỉ chứa các chữ cái không lớn hơn hoặc ít hơn bất kỳ số nào:

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

Một từ được sắp xếp trừ khi cả hai dấu hiệu đều gặp phải, dẫn đến v = 0 và every()không thành công.

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

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

Hãy thử trực tuyến!

Đây là rất nhiều niềm vui để viết!

Giải trình:

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

Cảm ơn @ErikTheOutgolfer, @leakynun và @BusinessCat cho tất cả các byte lưu. :)

05AB1E , 36 byte

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

Hãy thử trực tuyến!

MATL , 26 25 byte

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

Đầu vào là chữ in hoa Đầu ra là 1hoặc 0.

Hãy thử trực tuyến!

Giải trình

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

Chồng , 22 21 19 18 byte

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

Trả về 1cho đầu vào trung thực,0 cho những người . Đầu vào phải được viết hoa. Vượt qua tất cả các trường hợp thử nghiệm. Hãy thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến!

Chấp nhận đầu vào bằng chữ thường.

Làm thế nào nó hoạt động

3681 / x ⌋ giảm từ

• 38 đến 37 tại x ≈ 96.8684210526, trước đó a;
• 37 đến 36 tại x ≈ 99.4864864865, giữa cvà d;
• 36 đến 35 tại x ≈ 102,25, giữa fvà g;
• 35 đến 34 tại x ≈ 105.171428571, giữa ivà j;
• 34 đến 33 tại x ≈ 108.264705882, giữa lvà m;
• 33 đến 32 tại x ≈ 111.545454545, giữa ovà p;
• 32 đến 31 tại x ≈ 115.03125, giữa svà t;
• 31 đến 30 tại x ≈ 118,741935484, giữa vvà w;
• 30 đến 29 tại x ≈ 122,7, sau z.

C ++, 375 199 195 194 byte

Nhờ câu trả lời JavaScript của Shaggy:
-5 byte nhờ 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 byte

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

Hãy thử trực tuyến!

-1 cảm ơn Magic Octopus Urn .

Võng mạc , 65 byte

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

^(<*|>*)>$

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

T`_ADGJMPTW`d

Thay đổi chữ cái đầu tiên trên mỗi phím thành một chữ số. (Điều này giảm đi 1 nhưng điều đó không quan trọng đối với việc kiểm tra tăng / giảm dần. Mặt khác, số không sẽ khiến cuộc sống của tôi trở nên khó khăn hơn, vì vậy tôi đã để lại một nhân vật phụ.)

}T`L`_L

Xáo trộn tất cả các chữ cái còn lại lên 1 và lặp lại cho đến khi tất cả chúng được chuyển đổi thành chữ số.

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

Chuyển đổi các chữ số thành unary, nhưng chỉ một lần cho mỗi lần chạy các chữ số giống hệt nhau. Các giá trị đơn nguyên được phân tách bằng một <...

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

... nhưng nếu LHS hóa ra lớn hơn RHS, hãy sửa < thành >.

1

Xóa 1 s không còn cần thiết.

^(<*|>*)>$

Kiểm tra xem từ được đặt hàng. (Dấu> xuất phát từ chữ số cuối luôn so sánh lớn hơn khoảng trống theo sau nó.)

Bình , 23 byte

Một trong những câu trả lời Pyth không tầm thường đầu tiên của tôi! Đã lưu 6 byte nhờ @LeakyNun. Các giải pháp ban đầu là dưới đây.

/{_BKmhS,9/a58Cd3.13zSK

Phòng thử nghiệm.

Bình , 29 byte

KmhS+9]/-Cd58 3.13w|qKSKqK_SK

Phòng thử nghiệm.

Giải trình

/ Đũa_BKmhS,9/a58Cd3.13zSKQ - Q có nghĩa là đầu vào được đánh giá và ẩn ở cuối

 {- Khử trùng lặp
  _ - Đảo ngược
   B - Bifurcate, Tạo danh sách hai yếu tố, [B, A (B)]
    K - Biến với tự động gán cho:
     mz - Bản đồ qua đầu vào:
      hS - Tối thiểu (yếu tố đầu tiên của danh sách được sắp xếp)
        , - Tạo danh sách hai thành phần, [A, B] với các thành phần sau:
         9 - Chữ số 9
          / - Phân chia số nguyên của:
           a58Cd - Sự khác biệt tuyệt đối giữa 58 và ord (current_element)   
                3.13 - Chữ số 3.13
                    SK - K đã sắp xếp
/ Q - Đếm số lần xuất hiện của đầu vào trong [K, K [:: - 1]]                

05AB1E , 21 17 byte

Mã

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

Sử dụng mã hóa 05AB1E .

Hãy thử trực tuyến! hoặc Xác minh tất cả các trường hợp thử nghiệm!

Giải trình

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

Điều này về cơ bản ánh xạ các chữ cái sau đây đến các số sau:

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

Hoạt động với các chuỗi trường hợp hỗn hợp. Trả về 1cho sự thật hoặc 0cho falsey.

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

• 10 byte được lưu nhờ Rod .

Thử nó

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 byte

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

Hãy thử trực tuyến!

Giải trình

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

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

Bất cứ khi nào tôi thấy một câu hỏi numpad, tôi phải đưa ra một câu trả lời dựa trên pi.

Dùng thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm

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

Thạch , 32 byte

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Tôi cảm thấy có một số chỗ để tiết kiệm, nhưng C # không phải là một ngôn ngữ súc tích nên có thể không. Ung dung:

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
}

Cụ thể, tôi nghĩ rằng có một cách ngắn hơn để thể hiện kiểm tra cuối cùng về tính hợp lệ, có thể là một cách để nội tuyến nó với Zip. Tìm cách thể hiện Zipmà không cần lưu trữ tạm thời cho Skipcũng sẽ tiết kiệm được một cái gì đó, nhưng tôi nghi ngờ có một cái gì đó ngắn gọn hơn cho điều đó.

Python 3 , 143 147 148 149 130 byte

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)

Tốt nhất tôi có thể làm bây giờ. Hàm thô biến chữ cái thành số dựa trên mã ascii. Chắc chắn có một số cải tiến được thực hiện. 0 là sự thật, 1 là falsey (xin lỗi). Đã lưu 10 byte nhờ Rod, 3 người khác nhờ ông Xcoder.

Hãy thử trực tuyến!

Python 2, 111 103 bytes

-8 bytes thanks to @Arnold Palmer:no lower() needed

• Takes uppercase letters as input.

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

Try it online!

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

a golfed port of Arnauld´s answer.

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

accepts uppercase; empty output for falsy, 1 for truthy.

Run as pipe with -nR or try it online.

original post:

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

Try it Online

Of course the ugly version ends up being shorter...

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

Try it online!

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

Saved 8 bytes thanks to ThePirateBay.

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

Old old old 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 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

Converts each character in the string to an integer from 0 to 7, and takes the difference between each consecutive element; then checks whether the minimum and maximum differences have the same sign (or either is 0).

Zsh, 73 69 57 bytes

-12 bytes by using @anders-kaseorg's 3681/code conversion.

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

Try it online! Try it online! Try it online!

A few things we abuse:

• ((statement,statement,...)) is a sequence of arithmetic expressions which returns truthy if the last statement is non-zero.
• The return value of a loop is the return value of the last statement in a loop.
• Arithmetic operator precedences were pretty nice to us, as only one pair of no parentheses were used. One byte could be saved if ! bound less tightly than &.
• Unset parameters expand to 0 in arithmetic expansions.
• The function we use to map to the keypad number is CODE / 3.2 - 18 (with a special case for Z), but since we only need the change between codes, we don't do the linear adjustment.

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 can be saved if the truthy/falsey values can be swapped.