(Вдохновленный этим постом над 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 символов.

Выход

Последовательное truthy / falsey значение входного слова Упорядоченный ли (truthy) или нет Упорядоченный (falsey).

правила

• Допустимы либо полная программа, либо функция. Если функция, вы можете вернуть вывод, а не распечатать его.
• Если возможно, укажите ссылку на среду онлайн-тестирования, чтобы другие люди могли опробовать ваш код!
• Стандартные лазейки запрещены.
• Это код-гольф, поэтому применяются все обычные правила игры в гольф, и выигрывает самый короткий код (в байтах).

Примеры

Вот несколько Упорядоченных Слов (т. Е. Правдивых), и есть еще несколько связанных головоломок.

CAT
TAC
AAA
DEMONS
SKID
LKJONMSRQP
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Вот некоторые неупорядоченные слова (например, фальси)

DOG
GOD
ROSE
COFFEE
JKLMNOGHI

Python 2 , 164 148 132 77 байт

-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

_{* Значения округлены. :П}

Вторая строка выводит, если список чисел находится в порядке возрастания или убывания.

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

Попробуйте онлайн!

Принимает ввод в нижнем регистре.

Как это работает

813681 / 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.

С ++, 375 199 195 194 байта

Благодаря ответу Shaggy на JavaScript:
-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 окажется больше, чем RHS, исправьте <значение >.

1

Удалить те, 1которые больше не нужны.

^(<*|>*)>$

Проверьте, что слово упорядочено. (Трейлинг >идет от последней цифры, которая всегда сравнивается больше, чем пустой пробел после нее.)

Pyth , 23 байта

Один из моих первых нетривиальных ответов Pyth! Сохранено 6 байт благодаря @LeakyNun. Начальное решение ниже.

/{_BKmhS,9/a58Cd3.13zSK

Тестирование.

Pyth , 29 байт

KmhS+9]/-Cd58 3.13w|qKSKqK_SK

Тестирование.

объяснение

/Ndom_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Ë

Всякий раз, когда я вижу вопрос с цифровой клавиатурой, я должен ответить на основе числа пи.

Попробуйте онлайн или проверьте все тесты

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

В частности, я думаю, что есть более короткий способ выразить окончательную проверку на достоверность, возможно, способ встроить его в 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 байт благодаря @ Арнольду Палмеру: не 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) , 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).

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