( 퍼즐 링에 대한 이 게시물 에서 영감을 얻었습니다 .주의 : 퍼즐이 아래에있는 스포일러.)

표준 전화 키패드는 문자를 다음과 같이 숫자와 연관시킵니다.

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 자 이상입니다.

산출

입력 단어가 Ordered (truthy)인지 Ordered (falsey)인지에 대한 일관된 진실 / 거짓 값입니다.

규칙

• 전체 프로그램 또는 기능이 허용됩니다. 함수 인 경우 출력하지 않고 출력을 반환 할 수 있습니다.
• 가능하면 다른 사람들이 귀하의 코드를 시험해 볼 수 있도록 온라인 테스트 환경에 대한 링크를 포함하십시오!
• 표준 허점 은 금지되어 있습니다.
• 이것은 코드 골프 이므로 모든 일반적인 골프 규칙이 적용되며 가장 짧은 코드 (바이트)가 이깁니다.

예

다음은 몇 가지 질서있는 단어들 (즉, 진실됨)이며, 연결된 퍼즐 퍼즐에 대한 자세한 내용이 있습니다.

CAT
TAC
AAA
DEMONS
SKID
LKJONMSRQP
ABCDEFGHIJKLMNOPQRSTUVWXYZ

다음은 주문되지 않은 단어입니다 (예 : 거짓)

DOG
GOD
ROSE
COFFEE
JKLMNOGHI

파이썬 (2) , 164 (148) 132 77 바이트

다른 곳의 Rod 제안 덕분에 -16 바이트 . Arnold Palmer 덕분에 -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

자바 스크립트 (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

반환 1truthy 입력을위한 0falsy 사람을위한. 입력은 대문자 여야합니다. 모든 테스트 사례를 통과합니다. 온라인으로 사용해보십시오!

설명

±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

파이썬 2 , 60 바이트

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

온라인으로 사용해보십시오!

소문자로 입력을 받아들입니다.

작동 원리

⌊3681 / x ⌋ 감소

• x ≈ 96.8684210526 에서 38 내지 37 , 전에 a;
• x ≈ 99.4864864865 에서 37 내지 36 , c및 사이 d;
• x ≈ 102.25 에서 36 내지 35 , f및 사이 g;
• x ≈ 105.171428571 에서 35 내지 34 , i및 사이 j;
• x ≈ 108.264705882 에서 34 내지 33 , l및 사이 m;
• x ≈ 111.545454545 에서 33 내지 32 , o및 사이 p;
• x ≈ 115.03125 에서 32 내지 31 , s및 사이 t;
• x 118.741935484 에서 31 내지 30 , v및 사이 w;
• x ≈ 122.7 에서 30 ~ 29 , 이후 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‹Ë

온라인으로 사용해보십시오!

Magic Octopus Urn 에게 -1 감사합니다 .

레티 나 , 65 바이트

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

^(<*|>*)>$

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 설명:

T`_ADGJMPTW`d

각 키의 첫 글자를 숫자로 변경하십시오. (이것은 1에 의해 꺼져 있지만 오름차순 / 내림차순 검사에는 중요하지 않습니다. 반면에, 0은 내 삶을 어렵게 만들므로 필러 문자 하나를 남겨 두었습니다.)

}T`L`_L

나머지 문자를 모두 섞고 1이 모두 숫자로 변환 될 때까지 반복하십시오.

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

숫자를 단항으로 변환하지만 동일한 숫자를 실행할 때마다 한 번만 변환하십시오. 단항 값은 <... 로 분리됩니다 .

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

좌변은 RHS보다 더 큰 것으로 밝혀지면 ... 단,이 수정 <에 >.

1

1더 이상 필요없는을 삭제하십시오 .

^(<*|>*)>$

단어가 주문되어 있는지 확인하십시오. ( >마지막 숫자는 뒤에 오는 빈 공간보다 항상 더 큰 마지막 숫자에서 나옵니다.)

Pyth , 23 바이트

내 첫 번째 사소한 Pyth 답변 중 하나! @LeakyNun 덕분에 6 바이트를 절약했습니다. 초기 솔루션은 다음과 같습니다.

/{_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

자바 스크립트 (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 코어) 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 바이트를 절약했으며 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 바이트

Arnauld의 답변 의 골프 포트 .

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 기본, 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,...))마지막 명령문이 0이 아닌 경우 진리를 리턴 하는 일련의 산술 표현식입니다.
• 루프의 리턴 값은 루프에서 마지막 명령문의 리턴 값입니다.
• 괄호가 없는 한 쌍만 사용 되었으므로 산술 연산자 우선 순위는 우리에게 꽤 좋았습니다 . 보다 단단히 바인딩 된 경우 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 바이트를 저장할 수 있습니다.