(натхненний цією публікацією на головоломки. ПОПЕРЕДЖЕННЯ: СПОЙЛЕРИ ДЛЯ ТАКОГО ПУЗЗЛЯ НИЖЕ)

Стандартна клавіатура телефону співвідносить літери до цифр наступним чином:

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 символи.

Вихідні дані

Послідовне значення truthy / falsey для того, чи введене слово впорядковане (truthy) чи не Orders (falsey).

Правила

• Прийнятна або повна програма, або функція. Якщо функція, ви можете повернути вихід, а не надрукувати його.
• Якщо можливо, додайте посилання на онлайн-тестувальне середовище, щоб інші люди могли спробувати ваш код!
• Стандартні лазівки заборонені.
• Це код-гольф, тому діють усі звичайні правила гольфу, і найкоротший код (у байтах) виграє.

Приклади

Ось декілька впорядкованих слів (тобто, truthy), а ще є їх у пов'язаній загадці.

CAT
TAC
AAA
DEMONS
SKID
LKJONMSRQP
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Ось кілька не упорядкованих слів (тобто фальси)

DOG
GOD
ROSE
COFFEE
JKLMNOGHI

Пітон 2 , 164 148 132 77 байт

-16 байт завдяки пропозиції Рода в інших місцях . Frickin -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}

Другий рядок виводиться, якщо список номерів знаходиться у порядку зростання чи спадання.

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 ]. Тому що це база-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

Замовити тест

Ми відслідковуємо ознаки різниці між послідовними числами в бітовій масці v , спочатку встановленій 3 (0b11):

• біт № 0: очищається, коли new_value> previous_value
• біт №1: очищається, коли new_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 при х ≈ 96,8684210526, раніше a;
• 37 до 36 при х ≈ 99,4864864865, між cі d;
• 36 до 35 при х ≈ 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 при х ≈ 115.03125, між sіt ;
• 31 до 30 при х ≈ 118,741935484, між vіw ;
• Від 30 до 29 при х ≈ 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<

Перетворіть цифри в одинакові, але лише один раз за цикл однакових цифр. Одинарні значення вирізняються <...

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

... але якщо LHS виявляється більше , ніж ГРЗ, виправити <в >.

1

Видаліть 1s, які більше не потрібні.

^(<*|>*)>$

Перевірте, чи слово впорядковане. (Послідовність закінчення >походить від останньої цифри, яка завжди порівнює більше, ніж порожній простір, що слідує за ним.)

Піт , 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>

Гая , 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Ë

Щоразу, коли я бачу запитання про число, я мушу відповідати на основі пі.

Спробуйте в Інтернеті або перевірте всі тестові випадки

Ç                    # 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також дозволить щось заощадити, але я сумніваюся, що для цього є щось більш стисле.

Пітон 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 байт завдяки Роду, ще 3 подяки містеру 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 байт

відповідь порту для гольфу Арнаульда .

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 для фальшивих для truthy.

Запустіть як трубу -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) , 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,...))являє собою послідовність арифметичних виразів, яка повертає truthy, якщо останнє твердження не дорівнює нулю.
• Повернене значення циклу - це повернене значення останнього твердження в циклі.
• Арифметичний оператор старшинства були досить добре для нас, так як тільки одна пара НЕ були використані дужки. Один байт можна зберегти, якщо !зв’язати менш щільно, ніж& .
• Невизначені параметри розширюються на 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 байти можна зберегти, якщо можна змінити значення truthy / falsey.