( Puzzling'deki bu yazıdan esinlenmiştir . DİKKAT: AŞAĞIDAKİ KEÇE İÇİN SPOILER.)

Standart telefon tuş takımı, harfleri aşağıdaki sayılarla ilişkilendirir:

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

Belirli bir giriş kelimesi, yukarıdakileri kullanarak tuş takımına basıldığında, sonuçtaki sayının azalmaması veya artmaması durumunda, Sıralı Kelime olarak tanımlanır. Diğer bir deyişle, elde edilen sayı olamaz artış, hem ve azalma.

Örneğin, kelime CATçevirir 228azalan olmayan, ve bu yüzden, bir Sipariş kelime olan. Bununla birlikte, kelime DOGolduğu 364ve böylece artış ve düşüş, ve her ikisi de bir Sıralı kelime olmadığı.

Meydan okuma

Bir kelime verildiğinde, Sıralı olup olmadığını çıktı.

Giriş

• Yalnızca ASCII alfabesi ( [A-Z]veya [a-z]) harflerinden oluşan, herhangi bir uygun biçimde bir kelime (zorunlu olarak bir sözlük kelimesi değildir) .
• Seçiminiz, girişin tümü büyük harf veya tümü küçük harf ise, ancak tutarlı olmalıdır.
• Sözcük uzunluğu en az 3 karakter olacak.

Çıktı

Girilen sözcüğün Sıralı (truthy) veya Sıralı (falsey) olup olmadığı için tutarlı bir truthy / falsey değeri.

kurallar

• Tam bir program veya bir işlev kabul edilebilir. Bir işlev varsa, çıktıyı yazdırmak yerine geri gönderebilirsiniz.
• Mümkünse, lütfen başkalarının kodunuzu deneyebilmesi için çevrimiçi bir test ortamına bir bağlantı ekleyin!
• Standart boşluklar yasaktır.
• Bu kod-golf olduğundan, tüm normal golf kuralları geçerlidir ve en kısa kod (bayt cinsinden) kazanır.

Örnekler

İşte bazı Sıralı Sözler (yani, truthy) ve bağlantılı Puzzling bulmacasında daha fazlası var.

CAT
TAC
AAA
DEMONS
SKID
LKJONMSRQP
ABCDEFGHIJKLMNOPQRSTUVWXYZ

İşte Sıralanmamış Bazı Kelimeler (falsey gibi)

DOG
GOD
ROSE
COFFEE
JKLMNOGHI

Python 2 , 164 148 132 77 bayt

Rod'un başka bir yerdeki önerisi sayesinde -16 bayt . Arnold Palmer sayesinde -55 bayt sürtünme.

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

Çevrimiçi deneyin!

Giriş büyük harf olmalıdır. Çıktılar Trueveya Falsesırasına göre.

açıklama

İlk satırda her harf bir sayıya eşlenir.

                               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

Bu dayanarak çalışır:

          | 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

_{* Değerler yuvarlanır. : P}

İkinci satır, eğer sayılar listesi artan veya azalan sıradaysa çıkar.

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

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

Bir boole döndürür.

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

Test durumları

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

Nasıl?

Harf dönüşümü

parseInt(c, 35)Giriş dizesinin her harfini [ 10 .. 34 ] içindeki bir sayıya dönüştürmek için kullanıyoruz . Baz-35 olduğundan, "Z"NaN yerine dönüştürülür .

İfade, * .32 | 0bu sayıyı [ 3 .. 10 ] aralığında eşleştirir ve "A" ila "Y" için 8 doğru harf grubuna yol açar . "Z"|| 10 için doğru değeri almamız gerekiyor .

           | 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

Sipariş testi

Biz bit maskesi içine ardışık sayılar arasındaki farkların belirtilerini izlemesine v başlangıçta 3 (0b11) işlemleri gerçekleştirilmektedir ayarlı,:

• bit # 0: new_value> önceki_value olduğunda temizlenir
• bit # 1: new_value <önceki_değeri olduğunda temizlenir

Önceki değer, girişle aynı x değişkeninde saklanır . Bu, ilk yinelemenin - önceki bir değerin gerçekten bulunmadığı - herhangi bir biti temizlememesini sağlar, çünkü yalnızca harfleri içeren bir dize, herhangi bir sayıdan daha büyük veya daha az değildir:

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

Her iki işarete de rastlanmadığı sürece bir kelime sıralanır; bu v = 0'a yol açar ve every()başarısız olur.

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

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

Çevrimiçi deneyin!

Bu yazmak çok eğlenceli oldu!

Açıklama:

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

Tüm tasarruf baytları için @ErikTheOutgolfer, @leakynun ve @BusinessCat'e teşekkürler. :)

05AB1E , 36 bayt

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

Çevrimiçi deneyin!

Matl , 26 25 bayt

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

Giriş büyük harflerle yazılmıştır. Çıktı 1veya 0.

Çevrimiçi deneyin!

açıklama

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

Kabuğu , 22 21 19 18 bayt

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

İade 1truthy girişler için 0falsy olanlar için. Girişler büyük harf olmalıdır. Tüm test durumlarını geçer. Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

Küçük harflerle girişi kabul eder.

Nasıl çalışır

⌊3681 / x ⌋ değerinden düşüyor

• Daha önce , x 96.8684210526'da 38 ila 37 a;
• 37 ila 36 x x 99.4864864865, cve arasında d;
• 36 ila 35 x x 102.25'te, fve arasında g;
• 35 ila 34 x x 105.171428571, ive arasında j;
• 34 ila 33 x x 108.264705882, lve arasında m;
• 33 ila 32 x x 111.545454545, ove arasında p;
• 32 ila 31 x x 115.03125'te, sve arasında t;
• 31 ila 30 x x 118.741935484'te, arasında vvew ;
• 30 ila 29 x x 122.7, sonra z.

C ++, 375 199 195 194 bayt

Shaggy'nin JavaScript cevabı
sayesinde : Zacharý sayesinde -5 bayt

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

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

Çevrimiçi deneyin!

-1, Magic Octopus Urn sayesinde .

Retina , 65 bayt

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

^(<*|>*)>$

Çevrimiçi deneyin! Link, test durumlarını içerir. Açıklama:

T`_ADGJMPTW`d

Her tuşun üzerindeki ilk harfi bir rakamla değiştirin. (Bu 1'e kadar kapalıdır, ancak artan / azalan bir kontrol için önemli değil. Öte yandan, sıfırlar hayatımı zorlaştıracak, ben de bir dolgu karakteri bıraktım.)

}T`L`_L

Kalan tüm harfleri 1 karıştırın ve hepsi rakamlara dönüştürülene kadar tekrarlayın.

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

Rakamları tekli olarak dönüştürün, ancak aynı rakamların her çalıştırmasında yalnızca bir kez Tekli değerler a ile ayrılır <...

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

LHS RHS daha büyük olduğu ortaya çıkarsa ... ama, düzeltmek <için >.

1

1Artık gerekli olmayan s'yi silin .

^(<*|>*)>$

Kelimenin sıralandığını kontrol edin. (İz >, her zaman izleyen boş alandan daha büyük olan en son rakamdan gelir.)

Pyth , 23 bayt

İlk önemsiz olmayan Pyth cevabımdan biri! @LeakyNun sayesinde 6 bayt kaydedildi. İlk çözüm aşağıdadır.

/{_BKmhS,9/a58Cd3.13zSK

Test odası.

Pyth , 29 bayt

KmhS+9]/-Cd58 3.13w|qKSKqK_SK

Test odası.

açıklama

/{_BKmhS,9/a58Cd3.13zSKQ - Q, değerlendirilen girdi anlamına gelir ve sonunda gizlidir

 {- Tekilleşmek
  _ - Ters
   B - Bifurkate, İki elemanlı bir liste oluşturun, [B, A (B)]
    K - Otomatik atamaya göre değişken:
     mz - Girdi üzerinde harita:
      hS - Minimum (sıralanmış listenin ilk elemanı)
        , - Bu elemanlarla iki elemanlı bir liste [A, B] oluşturun:
         9 - Sayısal değişmez 9
          / - Tam sayı bölümü:
           a58Cd - 58 ve ord arasındaki mutlak fark (current_element)   
                3.13 - Sayısal değişmez 3.13
                    SK - K sıralandı
/ Q - Girişin oluşumunu [K, K [:: - 1]]                

05AB1E , 21 17 bayt

kod

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

05AB1E kodlamasını kullanır .

Çevrimiçi deneyin! veya Tüm test durumlarını doğrulayın!

açıklama

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

Bu, esasen aşağıdaki harfleri aşağıdaki sayılarla eşleştirir:

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 bayt

Karışık harfli dizelerle çalışır. 1Truthy veya falsey 0için döndürür .

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

• Rod sayesinde 10 byte kurtarıldı .

Dene

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 bayt

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

Çevrimiçi deneyin!

açıklama

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

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

Ne zaman bir sayısal tuşla soru görsem pi tabanlı bir cevap vermem gerekiyor.

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın

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

Jöle , 32 bayt

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

Çevrimiçi deneyin!

C # (.NET Çekirdeği) , 133 bayt

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

Çevrimiçi deneyin!

Kurtarmak için bir yer var gibi hissediyorum, ama C # özlü bir dil değil, belki de değil. 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
}

Özellikle, geçerlilik için son kontrolün ifade edilmesinin daha kısa bir yolu olduğunu düşünüyorum, muhtemelen bununla aynı çizgide Zip. Bunun Zipiçin geçici depolamaya ihtiyaç duymadan ifade etmenin bir yolunu bulmak da bir Skipşeyleri kurtarır, ancak bunun için daha özlü bir şey olduğundan şüpheliyim.

Python 3 , 143 147 148 149 130 bayt

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)

Şimdilik yapabileceğim en iyi şey. Ham fonksiyon, mektubu, ascii kodunun dışında bir sayıya dönüştürür. Yapılması gereken bazı iyileştirmeler var. 0 truthy, 1 falsey (üzgünüm). Rod sayesinde 10 byte, Bay Xcoder'a 3 teşekkürler.

Çevrimiçi deneyin!

Python 2 , 111 103 bayt

-8 @Arnold Palmer sayesinde bayt: hayır lower()gerekli

• Büyük harfleri giriş olarak alır.

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

Çevrimiçi deneyin!

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

bir golfed liman Arnauld's cevap .

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

büyük harf kabul eder; sahte için boş çıktı,1 .

-nRVeya ile boru olarak çalıştır çevrimiçi deneyin .

orijinal gönderi:

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 bayt

q{_"SVZY"#g-i3/}%_$_W%](e=g

Çevrimiçi Deneyin

Tabii ki çirkin sürüm daha kısa sürüyor ...

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 bayt

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

Çevrimiçi deneyin!

Eski çözüm:

#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 sayesinde 8 byte kurtarıldı.

Eski eski çözüm:

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

Eski eski eski çözüm:

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 bayt

ΔList(int(seq(inString("BC DEF GHI JKL MNO PQRSTUV WXYZ",sub(Ans,I,1))/4,I,1,length(Ans
0≤min(Ansmax(Ans

Dizedeki her karakteri 0 ile 7 arasında bir tam sayıya dönüştürür ve ardışık her öğe arasındaki farkı alır; daha sonra minimum ve maksimum farkların aynı işarete sahip olup olmadığını kontrol eder (veya her ikisi de 0'dır).

Zsh , 73 69 57 bayt

-12 bayt @ anders-kaseorg 3681/codedönüşümünü kullanarak .

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

Çevrimiçi deneyin! Çevrimiçi deneyin! Çevrimiçi deneyin!

Kötüye kullandığımız birkaç şey:

• ((statement,statement,...))son ifade sıfır değilse, truthy döndüren bir aritmetik ifadeler dizisidir .
• Bir döngünün dönüş değeri, bir döngüdeki son ifadenin dönüş değeridir.
• Olarak Aritmetik operatör biçiminde tanımlanmaktadır bize oldukça güzel yalnızca bir çift hiçbir parantez kullanıldı. Bir bayt !daha az sıkı bağlanırsa kaydedilebilir& .
• Ayarlanmamış parametreler 0aritmetik genişlemelerde genişler.
• Tuş takımı numarasına eşlemek için kullandığımız işlev CODE / 3.2 - 18(özel durum içinZ ), ancak yalnızca kodlar arasındaki değişime ihtiyaç duyduğumuzdan, doğrusal ayarı yapmıyoruz.

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

Truthy / falsey değerleri değiştirilebilirse 2 bayt kaydedilebilir.