26

( इस पोस्ट से प्रेरित होकर 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 अक्षरों का होगा।

उत्पादन

इनपुट शब्द आर्डर (सत्य) है या नहीं आर्डर किया गया है, इसके लिए एक सुसंगत सत्य / गलत मूल्य।

नियम

या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
यदि संभव हो, तो कृपया ऑनलाइन परीक्षण वातावरण का लिंक शामिल करें ताकि अन्य लोग आपके कोड को आज़मा सकें!
मानक खामियों को मना किया जाता है।
यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

उदाहरण

यहां कुछ ऑर्डर किए गए शब्द (जैसे, सत्य) हैं, और लिंक किए गए पज़लिंग पहेली पर अधिक हैं।

CAT
TAC
AAA
DEMONS
SKID
LKJONMSRQP
ABCDEFGHIJKLMNOPQRSTUVWXYZ

यहाँ कुछ गैर-आदेशित शब्द हैं (यानी, फाल्सी)

DOG
GOD
ROSE
COFFEE
JKLMNOGHI

code-golf string keyboard

— AdmBorkBork
स्रोत

संबंधित और संबंधित मुझे यकीन नहीं है कि यह एक ठग नहीं है, केवल बीच में बदलाव है abc->t9और यह चुनौती एकरसता की जाँच कर रही है?

— nmjcman101

1

@ nmjcman101 हां, वे संबंधित हैं, लेकिन कड़ाई से अन्य (बेहतर?) तरीके हो सकते हैं abc->t9।

— AdmBorkBork

यह समझ में आता है, मुझे उम्मीद है कि कुछ ऐसा तरीका देखने को

— मिलेगा

1

थोड़ा संबंधित भी।

— जुबान

टेस्ट केस अनुरोध:AAA

— बिजनेस कैट

13

पायथन 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

— totallyhuman
स्रोत

4

84 बाइट्स

— अर्नोल्ड पामर

1

पवित्र गाय, वह बहुत बढ़िया है। धन्यवाद!

— पूरी तरह से

मैं इसे एक उत्तर के रूप में पोस्ट करने जा रहा था क्योंकि मैंने इसे सभी के जवाबों के साथ बाढ़ आने से पहले लिखा था, लेकिन आपने मुझे छीन लिया :)

— अर्नोल्ड पामर

8

जावास्क्रिप्ट (ईएस 6), 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 सही समूह बन जाते हैं । हमें "Z" के|| 10 लिए सही मान प्राप्त करने की आवश्यकता है ।

           | 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> पिछले_वायु को मंजूरी दे दी
बिट # 1: जब new_value <पिछले_वल्यू

पिछला मान इनपुट के समान चर x में संग्रहीत है । यह सुनिश्चित करता है कि पहला पुनरावृत्ति - जहां कोई पिछला मूल्य वास्तव में मौजूद नहीं है - किसी भी बिट को स्पष्ट नहीं करेगा, क्योंकि केवल अक्षर युक्त एक स्ट्रिंग न तो अधिक है और न ही किसी संख्या से कम है:

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

एक शब्द तब तक आदेश दिया जाता है जब तक कि दोनों संकेत सामने न हों, जो v = 0 की ओर जाता है और every()विफल हो जाता है।

— Arnauld
स्रोत

ओह, प्रत्येक अक्षर की संख्या प्राप्त करने के लिए अच्छी चाल :) मैं इस बात से आंसू बहा रहा हूं कि मुझे इसे उधार लेना चाहिए या नहीं, क्योंकि इसका मतलब होगा कि मैं आपके साथ बाँधूँगा, जो सही नहीं लगता।

— शैगी

6

जेली , 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 को धन्यवाद। :)

— DJMcMayhem
स्रोत

3

05AB1E , 36 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— जादू ऑक्टोपस Urn
स्रोत

4

आप .•1нJ©½è`ÇHø¹á₂N¸°…ÈáÀ•#द्वारा प्रतिस्थापित कर सकते हैं A•22ā₂•S£।

— अदनान

3

@ अदनान रिप प्रारूपण

— लीक नून

3

@LeakyNun <s> वास्तव में </ s> नियत

— अदनान

4

@ अदनान रिप प्रारूपण

— लीक नून

4

@LeakyNun वास्तव में चीर

— अदनान

3

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

— लुइस मेंडो
स्रोत

पी: एक अक्षरात्मक चुनौती के लिए उपयुक्त स्कोर

— DJMcMayhem

@DJMcMayhem अब और नहीं :-D

— लुइस

3

हस्क , 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

— Zgarb
स्रोत

3

पायथन 2 , 60 बाइट्स

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

इसे ऑनलाइन आज़माएं!

लोअरकेस में इनपुट स्वीकार करता है।

यह काम किस प्रकार करता है

⌊3681 / x ⌊ से घट जाती है

एक्स से पहले a, 96.8684210526 पर 38 से 37 ;
37 से 36 x 8 99.4864864865, के बीच cऔर d;
36 at से 35 x x ≈ 102.25 के बीच fऔर g;
35 से 34 में एक्स ≈ १०५.१७,१४,२८,५७१, के बीच iऔर j;
34 से 33 में एक्स ≈ १०८.२६,४७,०५,८८२, के बीच lऔर m;
33 से 32 x at 111.545454545, के बीच oऔर p;
32 से 31 में एक्स ≈ ११५.०३,१२५, के बीच sऔर t;
31 से 30 x पर 4 118.741935484, के बीच vऔर w;
30 से 29 x ≈ 122.7, के बाद z।

— एंडर्स कसीगोर
स्रोत

2

सी ++, 375 199 195 194 बाइट्स

शागी के जावास्क्रिप्ट जवाब के लिए धन्यवाद : -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);}

— HatsuPointerKun
स्रोत

क्या आप int j=1,i=0,d=0लूप के लिए आगे बढ़ सकते हैं ?

— ज़ाचरी

@ Zacharý के बाद से iऔर dलूप ब्लॉक के बाहर उपयोग किया जाता है, मैं नहीं कर सकता

— HatsuPointerKun

i==0||d==0==> i*d==0।

— ज़ाचरी

चाहेंगे !(i*d)काम करते हैं? (के बाद अंतरिक्ष को हटाने return)

— Zacharý

@ Zacharý हाँ, यह काम करता है

— HatsuPointerKun

1

05AB1E , 30 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-1 मैजिक ऑक्टोपस Urn को धन्यवाद ।

— आउटग्रॉफर को एरिक करें
स्रोत

क्या आपने उपयोग किया ¥0K0.SËक्योंकि ¥0‹Ëसही नहीं है? अगर 0.Sजरूरत है तो मैं नहीं बता सकता ।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn वास्तव ¥0K0‹Ëमें काम करने लगता है।

— 15

यदि आप 0 को हटा रहे हैं, तो हाँ; मेरे जवाब में मुझे यकीन नहीं है कि यह काम करता है।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn मैं 0s हटा रहा हूं, अन्यथा झूठे नकारात्मक होंगे। आपका उत्तर भले ही अलग तरह से व्यवहार करे।

— निकोल निकोल

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>

... लेकिन अगर एलएचएस पता चला है आरएचएस से अधिक होना, सही करने <के लिए >।

उन 1एस को हटा दें जो अब आवश्यक नहीं हैं।

^(<*|>*)>$

जाँचें कि शब्द का आदेश दिया गया है। (अनुगामी >अंतिम अंक से आती है जो हमेशा खाली स्थान की तुलना में अधिक से अधिक होती है।)

— नील
स्रोत

यह बहुत मजेदार है। पूरी तरह से स्पष्टीकरण के लिए धन्यवाद।

— AdmBorkBork

1

पायथ , 23 बाइट्स

मेरे पहले गैर-तुच्छ पाइथ उत्तर में से एक! सहेजे गए 6 बाइट्स @LeakyNun की बदौलत। प्रारंभिक समाधान नीचे है।

/{_BKmhS,9/a58Cd3.13zSK

परीक्षण सूट।

पायथ , 29 बाइट्स

KmhS+9]/-Cd58 3.13w|qKSKqK_SK

परीक्षण सूट।

व्याख्या

/ जटिलताओं_BKmh,9/a58Cd3.13zSKQ - Q का अर्थ है कि इनपुट का मूल्यांकन किया गया है और अंत में निहित है

 {- डेडुप्लिकेट
  _ - उल्टा
   बी - द्विभाजित, एक दो-तत्व सूची बनाएँ, [बी, ए (बी)]
    K - ऑटो-असाइनमेंट के साथ चर:
     mz - इनपुट पर नक्शा:
      hS - न्यूनतम (सॉर्ट की गई सूची का पहला तत्व)
        , - इन तत्वों के साथ एक दो-तत्व सूची बनाएँ, [A, B]:
         9 - संख्यात्मक शाब्दिक 9
          / - पूर्णांक विभाजन:
           a58Cd - 58 और ord (current_element) के बीच का पूर्ण अंतर   
                3.13 - संख्यात्मक शाब्दिक 3.13
                    एसके - के छांटे गए
/ Q - इनपुट की घटनाओं की गणना [के, के [:: - 1]] में करें

— श्री एक्सकोडर
स्रोत

1

23 बाइट्स

— लीक नन

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

— अदनान
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 107 97 95 92 88 85 बाइट्स

मिश्रित-केस स्ट्रिंग्स के साथ काम करता है। रिटर्न 1truthy के लिए या 0falsey के लिए।

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>

स्निपेट का विस्तार करें

— झबरा
स्रोत

1

Math.min((parseInt(c,36)-3)/3.13|0,9)इसके बजाय "2..9"[parseInt(c,36)-10]कुछ बाइट्स बचाने के लिए

— रॉड

धन्यवाद, @Rod; बहुत अच्छा। मुझे भविष्य के उपयोग के लिए फाइल करनी होगी।

— शैगी

86 बाइट्स ।

धन्यवाद, @ThePirateBay, लेकिन, दुख की बात है, कि इनपुट के लिए विफल रहता है AAA।

— झबरा

1

गैया , 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)

— बिजनेस कैट
स्रोत

1

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?

— ग्रिमी
स्रोत

0

जेली , 32 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— आउटग्रॉफर को एरिक करें
स्रोत

आरआईपी संपीड़न

— लीक नून

@LeakyNun संपीड़ित संख्या वास्तव में है 32222323इसलिए यह सिर्फ 2 बाइट्स बचाता है।

— आउटगॉल्फ जूल

0

सी # (.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 # एक संक्षिप्त भाषा नहीं है इसलिए शायद नहीं। 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भी कुछ बचत होगी, लेकिन मुझे संदेह है कि इसके लिए कुछ अधिक संक्षिप्त है।

— कामिल दकरी
स्रोत

0

पायथन 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 धन्यवाद।

इसे ऑनलाइन आज़माएं!

— C मैकआवॉय
स्रोत

आप x=[f(a)-f(b)for a,b in zip(s,s[1:])]कुछ बाइट्स बचाने के लिए उपयोग कर सकते हैं

— रॉड

इसके अलावा, min(int((ord(c)-58)/3.13),9)

— रॉड

140 बाइट्स

— श्री एक्सकोडर

@Rod धन्यवाद! बहुत उपयोगी।

— सी मैकएवॉय

इसे मान्य करने के लिए आपको अपने आउटपुट को चारों ओर स्वैप करना होगा।

— झबरा

0

पायथन 2 , 111 103 बाइट्स

-8 बाइट्स @Arnold पामर को धन्यवाद: कोई lower()ज़रूरत नहीं

इनपुट के रूप में बड़े अक्षरों को लेता है।

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

इसे ऑनलाइन आज़माएं!

— officialaimm
स्रोत

1

आप हटा सकते हैं .lower()क्योंकि इनपुट आपके द्वारा निर्दिष्ट किसी भी मामले में हो सकता है।

— अर्नोल्ड पामर

0

PHP 7, 98 + 1 95 + 1 84 + 1 बाइट्स

Arnauld´s जवाब का एक गोल्फ पोर्ट ।

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;

— टाइटस
स्रोत

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.

— geokavel
स्रोत

0

सी (जीसीसी) , 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 बाइट्स

पुराना पुराना हल:

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

— मतेज मुलज
स्रोत

0

टीआई-बेसिक, 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 है)।

— Timtech
स्रोत

मुझे लगता ΔList(int(4^-1seq(inString("DEF GHI JKL MNO PQRSTUV WXYZ",sub(Ans,I,1))+3,I,1,length(Ansहै कि एक बाइट बचाता है।

— lirtosiast

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अंकगणितीय विस्तार में।
कीपैड नंबर के लिए मैप करने के लिए हम जिस फ़ंक्शन का उपयोग करते हैं, वह 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 बाइट बचाई जा सकती हैं।

— GammaFunction
स्रोत

यह एक आदेश दिया शब्द है?

चुनौती

इनपुट

उत्पादन

नियम

उदाहरण

पायथन 2 , 164 148 132 77 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 83 ... 71 70 बाइट्स

परीक्षण के मामलों

कैसे?

जेली , 28, 27, 25, 23, 22, 21, 19, 18 बाइट्स

05AB1E , 36 बाइट्स

MATL , 26 25 बाइट्स

व्याख्या

हस्क , 22 21 19 18 बाइट्स

व्याख्या

पायथन 2 , 60 बाइट्स

यह काम किस प्रकार करता है

सी ++, 375 199 195 194 बाइट्स

05AB1E , 30 बाइट्स

रेटिना , 65 बाइट्स

पायथ , 23 बाइट्स

पायथ , 29 बाइट्स

व्याख्या

05AB1E , 21 17 बाइट्स

कोड

व्याख्या

जावास्क्रिप्ट (ईएस 6), 107 97 95 92 88 85 बाइट्स

कोशिश करो

गैया , 29 27 25 17 बाइट्स

व्याख्या

05AB1E , 13 बाइट्स

जेली , 32 बाइट्स

सी # (.NET कोर) , 133 बाइट्स

पायथन 3 , 143 147 148 149 130 बाइट्स

पायथन 2 , 111 103 बाइट्स

PHP 7, 98 + 1 95 + 1 84 + 1 बाइट्स

CJam, 37 31 30 27 बाइट्स

सी (जीसीसी) , 183 169 153 117 बाइट्स

टीआई-बेसिक, 92 66 बाइट्स

Zsh , 73 69 57 बाइट्स