35

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सकारात्मक पूर्णांक में लेता है। आप मान सकते हैं कि इनपुट वैध है और इसे एक स्ट्रिंग के रूप में ले सकते हैं। यदि संख्या किसी की है

फिर एक सत्य मूल्य का उत्पादन । अन्यथा, एक मिथ्या मूल्य का उत्पादन । उदाहरण के लिए, इनपुट

सभी गलत परिणाम में परिणाम चाहिए। (इनपुट में अग्रणी शून्य नहीं होगा, इसलिए आपको चीजों की चिंता नहीं करनी चाहिए 012।)

बाइट्स में सबसे छोटा कोड जीतता है।

— केल्विन के शौक
स्रोत

ओह, स्ट्रिंग्स की अनुमति है? अंक सरणियों के बारे में क्या?

— डेनिस

@ डेनिस नंबर चलो इसे सादे तार या सादे स्याही में रखें।

— केल्विन के शौक

6

यदि मैं स्ट्रिंग इनपुट लेता हूं, तो क्या मुझे संभालना चाहिए 012?

— लिन

1

@ लियन नंबर गलत 012होगा लेकिन आप मान सकते हैं कि यह इनपुट नहीं है।

— केल्विन के शौक

1

@ ब्रैडगिल्बर्ब २ गल्स नं। यह सिर्फ सत्य

— केल्विन के शौक

46

पायथन, 24 बाइट्स

range(123,790,111).count

एक अनाम फ़ंक्शन जो 0 या 1 आउटपुट करता है। यह सूची बनाता है [123, 234, 345, 456, 567, 678, 789]और गिनता है कि इनपुट कितनी बार दिखाई देता है।

f=range(123,790,111).count

f(123)
=> 1
f(258)
=> 0

— XNOR
स्रोत

क्या आप 123 के बजाय 12 पर शुरुआत करके बाइट नहीं निकाल सकते?

— var पहला नाम

1

इसमें

— xnor

लेकिन हम यह मान सकते हैं कि यह इनपुट नहीं होगा? मैं भ्रमित हूं

— var firstName

1

यदि आप टिप्पणियों के बारे में बात कर रहे हैं, तो वे कह रहे हैं कि यदि आप एक स्ट्रिंग के रूप में इनपुट लेते हैं (जो यह नहीं है), तो आप संख्याओं की अपेक्षा कर सकते हैं कि अग्रणी शून्य नहीं होंगे, इसलिए 12 को "12" के रूप में दिया जाएगा और "नहीं" 012 "।

— xnor

34

पायथन, 24 बाइट्स

lambda n:n%111==12<n<900

बस बहुत सी स्थिति जंजीर है।

— Sp3000
स्रोत

एक सीमा की तुलना करने में सक्षम होना जो आसानी से किसी भी भाषा को धड़कता है जो मैं पहले से जानता हूं। मुझे यह देखना था कि यह कैसे काम करता है।

— गिटारपिकर

वाह, अगर यह शब्द के लिए नहीं था तो lambdaमुझे अनुमान भी नहीं था कि पायथन था। वह भयावह है।

— स्टीव बेनेट

25

हास्केल, 22 बाइट्स

(`elem`[123,234..789])

एक अनाम फ़ंक्शन। समान स्थान वाली सूची बनाता है [123, 234, 345, 456, 567, 678, 789]और जाँचता है कि इनपुट एक तत्व है या नहीं।

— XNOR
स्रोत

1

बिल्कुल नहीं! वह जादू है!

— YSC

12

ब्रेकीलॉग , 9 बाइट्स

h:2j:12+?

इसे ऑनलाइन आज़माएं! या सभी परीक्षण-मामलों को सत्यापित करें।

एल्गोरिथ्म के लिए डेनिस को श्रेय ।

अंग्रेजी में, "(यह साबित करें) कि इनपुट का पहला अंक, दो बार खुद से जुड़ा हुआ है, 12 जोड़ें, अभी भी इनपुट है।"

— लीक नन
स्रोत

1

ये जबरदस्त है!

— डेटागोड 16

11

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

lambda n:`n-12`==`n`[0]*3

Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत

8

ब्रेन-फ्लैक 76 + 3 = 79 बाइट्स

इस उत्तर के एक गोल्फ है इस सवाल का जवाब। मुझे वास्तव में यह पता नहीं है कि मेरा उत्तर कैसे काम करता है, लेकिन DJMcMayhem अपने मूल उत्तर में एक अच्छी व्याख्या देता है और मेरा उत्तर उसका एक संशोधन है।

([]<>)<>({}[({})]<>)<>(({}[({})()()()()()]<>{}{}<(())>)){{}{}(((<{}>)))}{}{}

इसे 3 बाइट्स जोड़कर -a ascii ध्वज के साथ चलाया जाता है।

स्पष्टीकरण (प्रकार के)

मूल कार्य समाधान के साथ शुरू:

([]<>)<>({}[({})]<>)<>({}[({})]<>)({}{}[()()])({}<({}[()()()])>)(({}{}<(())>)){{}{}(((<{}>)))}{}{}

मैंने इसे एक साधारण गोल्फिंग एल्गोरिथ्म के माध्यम से चलाया जो मैंने लिखा और प्राप्त किया:

([]<>)<>({}[({})]<>)<>(({}[({})]<>{}[()()]<({}[()()()])>{}<(())>)){{}{}(((<{}>)))}{}{}

यहाँ से मैं अनुभाग को <({}[()()()])>{}अनिवार्य रूप से एक से गुणा करता हूँ जो इसे {}[()()()]पूरे कोड को कम करने के बराबर बनाता है:

([]<>)<>({}[({})]<>)<>(({}[({})]<>{}[()()]{}[()()()]<(())>)){{}{}(((<{}>)))}{}{}

अंत में नकारात्मक को जोड़ा जा सकता है:

([]<>)<>({}[({})]<>)<>(({}[({})()()()()()]<>{}{}<(())>)){{}{}(((<{}>)))}{}{}

— गेहूं का जादूगर
स्रोत

14

"मुझे वास्तव में यह पता नहीं है कि मेरा जवाब कैसे काम करता है" आप इंटरनेट पर जीतते हैं

— लीक नून

नहीं ।

— लीके नन

@LeakyNun मुझे विश्वास नहीं है कि Ascii मोड इसे ऑनलाइन करने की कोशिश करता है। आपको github संस्करण प्राप्त करना होगा।

— गेहूं जादूगर

1

@HeatWizard ASCII मोड निश्चित रूप से TIO पर काम करता है। आप स्टैक के शीर्ष पर 48 ('0') जोड़कर इसे सत्यापित कर सकते हैं । लीक नन सही है, एल्गोरिथ्म ( मेरा एल्गोरिथ्म) गलत है, क्योंकि यह सिर्फ जांचता है कि अंतर का योग 2 है (जो काम करता है यदि अंतर +3 और -1 है)। दुर्भाग्य से, हमारे दोनों उत्तर गलत हैं।

— DJMcMayhem

1

@HeatWizard यह उत्तर मान्य प्रतीत नहीं होता है। इसे ऑनलाइन आज़माएं! (मेरी मूल जवाब नहीं या तो था)

— DJMcMayhem

8

ब्रेनफक, 32 बाइट्स

+>,+>,>,-[-<-<->>],[<]<[<]<[<]<.

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

एल्गोरिथ्म के मूल के लिए लिन को श्रेय।

— लीक नन
स्रोत

7

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

DI⁼1,1

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

DI⁼1,1  Main link. Argument: n (integer)

D       Decimal; convert n to base 10.
 I      Increments; compute the differences of all pairs of adjacent digits.
   1,1  Yield [1, 1].
  ⁼     Test the results to both sides for equality.

— डेनिस
स्रोत

012 गलत नहीं है, हालांकि यह वास्तव में कुछ भी वापस नहीं करता है ...

— जेमी बार्कर

इनपुट को पूर्णांक होना चाहिए। जहाँ तक ast.literal_evalबात है, 012पूर्णांक का प्रतिनिधित्व नहीं करता है ।

— डेनिस

7

05AB1E , 5 बाइट्स

¥XX‚Q

व्याख्या

¥      # deltas
    Q  # are equal to
 XX‚   # [1,1]

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

— Emigna
स्रोत

मैं के 2Å1बजाय इस्तेमाल कियाXX, कम कमांड (4 के बजाय 4) का उपयोग किया।

— एरिक आउटोलॉफ़र

@ErikGolfer エリ fer fer fer fer fer ー and: और Åमेरे कीबोर्ड पर लिखने योग्य है (जैसा कि विरोध किया गया है‚ ) जो एक लाभ है :)

— Emigna

‚ (नहीं है , , मैं प्रयोग किया जाता है) एक लिखें कुंजी अनुक्रम भी नहीं है, जबकि Åहै oAएक संलग्न अमेरिका कीबोर्ड पर।

— आउटगॉल्फ

6

MATL , 8 बाइट्स

d1=tn2=*

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

यह 1 1एक सत्य इनपुट के लिए प्रिंट करेगा , और एक 0मिथ्या मान के लिए इसमें एक सरणी , क्योंकि MATL में गलत है।

स्पष्टीकरण:

d           % Calculate the difference between consecutive digits
 1=         % Push an array of which elements equal one
   t        % Duplicate this array
    n       % Push the length of this array
     2=     % Push a one if the length is 2, and a zero otherwise
            % Now, if we have a truthy input, the stack looks like:
            %   [1 1]
            %   1
            % And if we have a falsy input, the stack looks something like this:
            %   [1 0]
            %   1
            % Or this:
            %   [1 1]
            %   0
       *    % Multiply the top two elements

— DJMcMayhem
स्रोत

शायद d1=Ep4=(मैंने अच्छी तरह से परीक्षण नहीं किया है)

— लुइस मेंडो

1

या dTTX=5 बाइट्स के लिए

— लुइस मेंडो

@luismendo whaaa? इससे काम होता ही कैसे है? मैं पर प्रलेखन नहीं मिल सकता हैT

— DJMcMayhem

Tशाब्दिक है true, और Fहै false। पड़ोसी Tऔर Fएक साथ चिपके रहते हैं, इसलिए TTहै [true true]जो इन उद्देश्यों के लिए करने के लिए बराबर है, [1 1]। युक्ति

— लुइस मेंडो

6

जावा 7, 46 बाइट्स

boolean f(int a){return a>12&a<790&a%111==12;}

चैट में लीकी नून के साथ कई चीजों की कोशिश करने के बाद, यह सबसे छोटा लगता है। कभी-कभी आपको बस चीजों को सीधा करना होगा: /

स्पष्टीकरण:

boolean f(int a){
    return a>12         Is it more than 12? (stupid edge case)
           &
           a<790        Is it in range the other way? 
           &
           a%111==12;   Is it 12 more than a multiple of 111? 
}

— Geobits
स्रोत

6

पर्ल 6 , 35 29 24 21 19 बाइट्स

{.chars==3&&'0123456789'.index: $_}
{$_ (elem) (123,*+111...789)}
{$_∈(123,*+111...789)}
*∈(123,*+111...789)
*∈(123,234...789)

स्पष्टीकरण:

# Whatever lambda ( the parameter is ｢*｣ )
*

∈ # is it an element of:

# this sequence
(
  123,
  234,

  # deduce rest of sequence
  ...

  # stop when you generate this value
  789
)

उपयोग:

my &code = *∈(123,234...789);

say code 123; # True
say code 472; # False

say (  *∈(123,234...789)  )( 789 ); # True

— ब्रैड गिल्बर्ट b2gills
स्रोत

6

रेटिना , २६

.
$*: 
^(:+ ):\1::\1$

सत्य के लिए आउटपुट 1 और झूठी के लिए 0।

इसे ऑनलाइन आज़माएँ (पहली पंक्ति को कई टेस्टकेस चलाने की अनुमति देने के लिए जोड़ा गया है)।

— डिजिटल आघात
स्रोत

5

रूबी, 32 30 25 + 2 = 27 बाइट्स

-nlझंडे के लिए +2 बाइट्स ।

STDIN और प्रिंट पर इनपुट लेता है trueया false।

p"123456789"[$_]&.size==3

इसे repl.it पर देखें: https://repl.it/DBn2/2 ( repl ️ पर क्लिक करें और फिर नीचे कंसोल में इनपुट टाइप करें।)

— जॉर्डन
स्रोत

आपके परीक्षण 12 सच होने को दर्शाते हैं।

— xnor

@ एक्सनोर ऊप्स। वह मुझे सोने के बाद गोल्फ सिखाना होगा। फिक्स्ड!

— जॉर्डन

मैंने सोचा था कि -aनहीं split, एक chop? इसके अलावा, क्या करता &है? मैं एक पुरानी रूबी का उपयोग कर रहा हूं जो एक त्रुटि फेंकता है। वैसे भी, यह इसके बिना 26 बाइट्स पर पूरी तरह से काम करता है।

— xsot

उफ़, मेरा मतलब था -l, नहीं -a। &.रूबी 2.3 में जोड़ा गया "सुरक्षित नेविगेशन" ऑपरेटर है। इसके बिना इनपुट की तरह 19, जो सबस्ट्रिंग नहीं हैं अगर "123456789", कोई NoMethodError बढ़ाएगा।

— जॉर्डन

@ जोर्डन मुझे २.२ में त्रुटि नहीं मिल रही है। शायद 2.3 में भी नया है?

— xsot

5

ब्रेन-फ्लैक , 99 बाइट्स

([{}]({})<>)<>([{}]{}<>)(({})<([{}]{})((){[()](<{}>)}{})>)([{}]{})((){[()](<{}>)}{})<>{{{}}<>{}}<>

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

इस के +1लिए कोड के 98 बाइट्स है-a ध्वज ।

यह 1सत्य के लिए प्रिंट करता है, और या तो 0कुछ भी नहीं (जो 0 के बराबर है) मिथ्या के लिए

— DJMcMayhem
स्रोत

पुश पॉप अक्षमताओं से छुटकारा पाने की कोशिश करें। मैं आपके कोड में एक गुच्छा देख सकता हूं। वे दिखते हैं ...)({}लेकिन अलग-अलग होते हैं। यदि आप मूल्य का उपयोग किए बिना धक्का देते हैं और पॉप करते हैं तो आप इसे एक चीज में शामिल कर सकते हैं। यदि आप चाहें तो मैं आपको इन सभी के साथ अपने कोड के एक संस्करण से जोड़ सकता हूं।

— गेहूं जादूगर

यहाँ अपने कार्यक्रम के 76 बाइट गोल्फ है। मैं बहुत कुछ कस्टम सेटिंग्स के साथ अपने कोड पर अपने मस्तिष्क-फ्लैक अनुकूलक चला।

— गेहूं जादूगर

नहीं ।

— लीक

4

ब्रेन-फ्लैक , 114 बाइट्स

([((()()()){}){}]{})(((()()()){}())<>)<>{({}<(({}[(((((()()()){}()){}){}){}){}]())){(<{}>)<>({}[()])<>}{}>[()])}<>

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

सही संस्करण (प्रश्न की भावना में): पूर्णांक को इनपुट के रूप में लेता है, आउटपुट 0 को फाल्सी के लिए और सत्य के लिए 1।

यह स्टैक साफ नहीं है ।

कलन विधि

इनपुट होने दें n।

आउटपुट सत्यपूर्ण iff है (n-123)(n-234)(n-345)(n-456)(n-567)(n-678)(n-789)=0।

मैंने उन सात संख्याओं को पहले घटाकर १२ घटाया और फिर १११ 111 बार घटाया, और फिर उन सात संख्याओं की तार्किक दोहरे संख्या की गणना की और उन्हें जोड़ा।

सत्य परिणामों के लिए, योग 6 है; झूठी परिणाम के लिए, योग 7 है।

फिर, मैं योग को 7 से घटाता हूं और उत्तर को आउटपुट करता हूं।

— लीक नन
स्रोत

मुझे कोड समझ में नहीं आ रहा है, लेकिन एल्गोरिथ्म चतुर है इसलिए +1 है।

— साइओस 4'16

4

आर, 30 22 बाइट्स

scan()%in%(12+1:7*111)

विशेष रूप से रोमांचक नहीं; जाँच करें कि इनपुट 12 + 111k द्वारा दिए गए अनुक्रम में है, जहाँ k प्रत्येक 1 से 7 तक है। ध्यान दें कि :पूर्ववर्ती *गुणन इतना है कि अनुक्रम उत्पन्न होने के बाद गुणन होता है।

— JDL
स्रोत

4

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 41 30 23 बाइट्स

पहला कोड-गोल्फ प्रस्तुत करना, कोमल होना :)

a=>{return a>12&&a<790?a%111==12:false;};
a=>a>12&&a<790?a%111==12:false
a=>a>12&a<790&a%111==12

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

-11 बाइट्स किरिल एल को धन्यवाद।
केवल ASCII के लिए एक और -7 बाइट्स धन्यवाद।

— Loxx
स्रोत

1

PPCG में आपका स्वागत है! आप कर्ली ब्रेसिज़ और returnकीवर्ड को हटाकर कुछ बाइट्स बचा सकते हैं : 30 बाइट्स

— किरिल एल।

1

23 , 23 भी

— ASCII- केवल

1

अच्छा प्रथम प्रस्तुत!

— अज्ञानता

3

ब्रेनफक, 43 बाइट्स

,>,>,>,[>>]<[[-<-<->>]<+[>>]<++[>>->]<+<]>.

बाह, मैं इस पर अच्छा नहीं हूँ। आउटपुट \x01यदि उत्पादन तार में से एक है 123, 234, ..., 789, आउटपुट \x00अन्यथा।

(मैंने जावा 7 को हराया, हालांकि…)

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

— लिन
स्रोत

किस बात का [>>]<? क्या ऐसा नहीं हो सकता >?

— DJMcMayhem

मैं प्रोग्राम को विफल करना चाहता हूं (यदि इसे ऑफ-ट्रैक फेंककर) अगर पॉइंटर के तहत सेल उस बिंदु पर शून्य नहीं है।

— लिन

42 बाइट्स

— लीकी नून

@LeakyNun जो पूरी तरह से अलग दिखता है; एक अलग जवाब के रूप में इसे पोस्ट करने के लिए स्वतंत्र महसूस करें

— लिन

@ लियन ने किया।

— लीक नन

3

जावास्क्रिप्ट ईएस 6, 26 बाइट्स

n=>1>(n-12)%111&n>99&n<790

यह इस तथ्य का लाभ उठाता है कि मैं बिट-वार लॉजिक ऑपरेटरों का उपयोग कर रहा हूं जो अनिवार्य रूप से बूलियन हैं (जो बिट-आधारित हैं!)

2 को बचाने के लिए टाइटस को धन्यवाद।

— WallyWest
स्रोत

1

दो बाइट्स: (n-12)औरn>99

— टाइटस

@Titus ओह, आप के लिए बहुत अच्छा, +1!

— वैलीवेस्ट

1

=> ES6 है, ES5 नहीं है।

— नील

1

मेरा मानना है कि यह मेटा में तय किया गया था कि आपको इस 26 बाइट्स बनाने के लिए "f =" को गिनना नहीं था

— चार्ली व्यान

1

@WallyWest मुझे लगता है कि हर मामले में फ़ंक्शन का उपयोग करने के लिए "f =" होना आवश्यक नहीं है, इसलिए इस मामले के लिए आपको इसकी आवश्यकता क्यों है? मुझसे ज्यादा स्मार्ट लोगों ने फैसला किया कि यह ठीक है इसलिए मैं बस इसके साथ जाता हूं;)

— चार्ली व्यान

3

एक्सेल - 62 57 35 31 बाइट्स

अनास्तासिया-रोमानोवा के जवाब के आधार पर, लेकिन एक्सेल के TRUE/FALSEमूल्यों को वापस करना।

=AND(LEN(N)=3,MID(N,2,1)-MID(N,1,1)=1,MID(N,3,1)-MID(N,2,1)=1)

इसके अलावा, हम प्राप्त कर सकते हैं

=AND(LEN(N)=3,MID(N,2,1)-LEFT(N)=1,RIGHT(N)-MID(N,2,1)=1)

दोनों के बाद से RIGHTऔर LEFTडिफ़ॉल्ट रूप से एक ही चरित्र लौटाते हैं।

और, पायथन के कुछ समाधानों से प्रेरित:

=AND(LEN(N)=3,MOD(N,111)=12,N<>900)

4 और बाइट्स के लिए नील को धन्यवाद ...

=AND(N>99,MOD(N,111)=12,N<900)

— dulrich
स्रोत

N<900आपको एक बाइट नहीं बचाता है, जिस स्थिति में आप N>99इसके बजाय उपयोग कर सकते हैं LEN(N)=3।

— नील

1

21 बाइट्स: संदर्भ सेल का नाम =REPT(LEFT(N),3)+12=Nकहां Nहै।

— इंजीनियर टोस्ट

3

Brachylog (2), 7 बाइट्स

ẹ~⟦₂-_2

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

व्याख्या

ẹ~⟦₂-_2
ẹ        Split into digits
 ~⟦₂     Assert that this is an increasing range; take its endpoints
    -_2  Assert that the starting minus ending endpoint is -2

एक पूर्ण कार्यक्रम के रूप में, हम एक सच्चा रिटर्न प्राप्त करते हैं यदि सभी जोर पकड़ते हैं, तो कोई भी असफल होने पर एक झूठी वापसी होती है।

3

सीजाम, 13 9 बाइट्स

A,s3ewqe=

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

व्याख्या

A,s        e# Push "0123456789".
   3ew     e# Split it into contiguous length-3 chunks: ["012" "123" "234" ... "789"].
      q    e# Push the input.
       e=  e# Count the number of times the input appears in the array.

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

5

यदि संख्या समान है तो काम नहीं करता है2345

— माल्टीसेन

@ मैलेटेन फिक्स्ड

— बिजनेस कैट

2

एक्सेल - 104 बाइट्स

=IF(LEN(N)<3,"Falsy",IF(AND(LEN(N)=3,MID(N,2,1)-MID(N,1,1)=1,MID(N,3,1)-MID(N,2,1)=1),"Truthy","Falsy"))

स्पष्टीकरण:

Excel में IF सूत्र के लिए सिंटैक्स है:

IF( condition, [value_if_true], [value_if_false] )

यदि इनपुट की लंबाई N, जहां यह संदर्भ सेल का नाम है, 3 से कम है, तो यह फाल्सी वापस कर देगा । एल्स, यदि इनपुट की लंबाई N3 है और दोनों दूसरे अंक और पहले अंक के अंतर और तीसरे अंक और दूसरे अंक के अंतर 1 के बराबर हैं, तो यह ट्रू को वापस कर देगा ।

— अनास्तासिया-रोमानोवा ova
स्रोत

21 बाइट्स: संदर्भ सेल का नाम =REPT(LEFT(N),3)+12=Nकहां Nहै।

— इंजीनियर टोस्ट

2

Dyalog एपीएल , 10 बाइट्स

स्ट्रिंग तर्क देता है।

1 1≡¯2-/⍎¨

1 1≡ के समान {1, 1} है

¯2-/ का उलटा युग्म-वार अंतर

⍎¨ प्रत्येक वर्ण को एक संख्या के रूप में लिया जाता है?

TryAPL ऑनलाइन! ( सुरक्षा कारणों से ⍎इसका अनुकरण किया गया eहै।)

— एडम
स्रोत

2

पर्ल, 18 बाइट्स

के लिए +1 शामिल है -p

STDIN पर इनपुट के साथ चलाएँ

123.pl <<< 123

123.pl:

#!/usr/bin/perl -p
$_=$_=/./.2==$_-$&x3

— टन हास्पेल
स्रोत

2

PHP, 31 बाइट्स

<?=($n=$_GET[n])-12==$n[0]*111;

जांचें कि क्या (संख्या माइनस 12) का पहला अंक 111 से अधिक है

— फ्लोरिन चिस
स्रोत

2

PowerShell v3 +, 24 बाइट्स

($args[0]-12)/111-in1..7

कुछ अन्य उत्तरों के समान "111 से अधिक 12" की चाल का उपयोग करता है, लेकिन दूसरी दिशा में जाता है। इनपुट लेता है $args[0], घटाता है 12, द्वारा विभाजित करता है 111, और जाँचता है कि क्या यह -inसीमा है 1..7। एक बूलियन सच / गलत मूल्य आउटपुट करता है। के लिए v3 + की आवश्यकता है-inऑपरेटर के ।

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

PS C:\Tools\Scripts\golfing> 123,234,345,456,567,678,789|%{.\easy-as-one-two-three.ps1 $_}
True
True
True
True
True
True
True

PS C:\Tools\Scripts\golfing> 1,2,3,12,122,124,132,321,457,777,890,900,1011,1230,1234|%{.\easy-as-one-two-three.ps1 $_}
False
False
False
False
False
False
False
False
False
False
False
False
False
False
False

— AdmBorkBork
स्रोत

2

एआरएम मशीन कोड, 18 बाइट्स

हेक्स डंप (थोड़ा एंडियन):

3803 d105 6808 ebc0 2010 b280 f2a0 1001 4770

यह एक फ़ंक्शन है जो स्ट्रिंग के लिए एक लंबाई, सूचक जोड़ी में लेता है। आउटपुट बैश-शैली है, यह 0 के लिए आउटपुट सत्य है और असत्य के लिए एक शून्य-शून्य मान है। C में फ़ंक्शन को int oneTwoThree (size_t length, char * string) घोषित किया जाएगा। निर्देश एन्कोडिंग थंब -2 है, जिसमें 2 और 4 बाइट निर्देश हैं। एक रास्पबेरी पाई 3 पर परीक्षण किया गया।

असंगठित सभा:

.syntax unified
.text
.global oneTwoThree
.thumb_func
oneTwoThree:
    @Input: r0 - the number of characters in the string
    @r1 - A pointer to the (not necessarily NUL-terminated)
    @string representation of the number (char*)
    @Output: r1 - 0 if the number is in 123,234,...,789, else non-zero (bash-style)
    subs r0,r0,#3
    bne end @Return non-zero if r0!=3
    ldr r0,[r1] @Remember that this is little endian
    @So the first digit is the most siginificant byte
    @I.e. if the input was 123 then r0 contains 0xXY010203 where XY is garbage

    rsb r0,r0,r0,lsr #8 @r0=(r0>>8)-r0 (rsb is reverse subtract)
    uxth r0,r0 @r0&=((1<<16)-1) (mask off top half)
    @Now r0 is 0x0101 iff we have a matching number
    sub r0,r0,#0x101
    @Now r0 is 0 iff the string fit the specification

    end:
    bx lr @return

परीक्षण स्क्रिप्ट (विधानसभा भी):

.syntax unified
.text
.global main
.thumb_func
main:
    push {r4,lr}
    ldr r4,[r1,#4] @r0=argv[1]
    mov r0,r4
    bl strlen
    @Now r0 is the length of the string argv[1]
    mov r1,r4
    bl oneTwoThree @oneTwoThree(strlen(argv[1]),argv[1])
    cmp r0,#0
    it ne
    movne r0,#1 @Output through return code, 1 if false
    pop {r4,pc}

— इयान चबाना
स्रोत

2

जावास्क्रिप्ट (ईएस 6), 34 बाइट्स

और जेएस में एक और विकल्प। एक स्ट्रिंग के रूप में इनपुट लेता है और इसके लिए आउटपुट 0देता है ।false1true

n=>++n[0]==n[1]&++n[1]==n[2]&!n[3]

मेरे अन्य समाधान यहाँ और यहाँ देखें

कोशिश करो

f=
n=>++n[0]==n[1]&++n[1]==n[2]&!n[3]
i.addEventListener("input",_=>o.innerText=f(i.value))

<input id=i type=number><pre id=o>

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

— झबरा
स्रोत

एक-दो-तीन जितना आसान

पायथन, 24 बाइट्स

पायथन, 24 बाइट्स

हास्केल, 22 बाइट्स

ब्रेकीलॉग , 9 बाइट्स

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

ब्रेन-फ्लैक 76 + 3 = 79 बाइट्स

स्पष्टीकरण (प्रकार के)

ब्रेनफक, 32 बाइट्स

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

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

05AB1E , 5 बाइट्स

MATL , 8 बाइट्स

जावा 7, 46 बाइट्स

पर्ल 6 , 35 29 24 21 19 बाइट्स

स्पष्टीकरण:

उपयोग:

रेटिना , २६

रूबी, 32 30 25 + 2 = 27 बाइट्स

ब्रेन-फ्लैक , 99 बाइट्स

ब्रेन-फ्लैक , 114 बाइट्स

कलन विधि

आर, 30 22 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 41 30 23 बाइट्स

ब्रेनफक, 43 बाइट्स

जावास्क्रिप्ट ईएस 6, 26 बाइट्स

एक्सेल - 62 57 35 31 बाइट्स

Brachylog (2), 7 बाइट्स

व्याख्या

सीजाम, 13 9 बाइट्स

एक्सेल - 104 बाइट्स

Dyalog एपीएल , 10 बाइट्स

पर्ल, 18 बाइट्स

PHP, 31 बाइट्स

PowerShell v3 +, 24 बाइट्स

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

एआरएम मशीन कोड, 18 बाइट्स

जावास्क्रिप्ट (ईएस 6), 34 बाइट्स

कोशिश करो