अच्छाई गिज़ा गोल्फ!

Question

एक "गिज़ा संख्या", जिसे बोलचाल की भाषा में टिम्मी नंबर के रूप में भी जाना जाता है, वह कोई भी संख्या है जहाँ अंक एक पिरामिड ( A134810 ) का प्रतिनिधित्व करते हैं । उदाहरण के लिए, "12321" एक गीज़ा संख्या है क्योंकि इसे इस तरह से देखा जा सकता है:

  3  
 2 2
1   1

हालांकि, "123321" जैसा कुछ गीज़ा नंबर नहीं है क्योंकि पिरामिड के शीर्ष पर दो अंक हैं

  33  
 2  2
1    1

दूसरे शब्दों में, एक संख्या एक गीज़ा संख्या है यदि निम्नलिखित सभी शर्तें पूरी होती हैं:

• इसमें विषम संख्या में अंक होते हैं, और केंद्र का अंक सबसे बड़ा होता है

• यह पैलिंड्रोमिक है (वही आगे या पीछे पढ़ा जाता है), और

• अंकों की पहली छमाही सख्ती से एक से बढ़ रही है। (चूँकि यह पैलिंड्रोमिक होना चाहिए, इसका मतलब है कि अंकों का दूसरा भाग एक से कम होना चाहिए)

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

कुल 45 गीज़ा संख्याएँ हैं, इसलिए इन इनपुटों में से किसी एक को सत्य मान में परिणामित करना चाहिए:

1
2
3
4
5
6
7
8
9
121
232
343
454
565
676
787
898
12321
23432
34543
45654
56765
67876
78987
1234321
2345432
3456543
4567654
5678765
6789876
123454321
234565432
345676543
456787654
567898765
12345654321
23456765432
34567876543
45678987654
1234567654321
2345678765432
3456789876543
123456787654321
234567898765432
12345678987654321

किसी भी अन्य इनपुट को मिथ्या मूल्य देना चाहिए। बेशक, आपको गैर-सकारात्मक संख्या, गैर-पूर्णांक या गैर-संख्या जैसे अमान्य इनपुट को संभालने की आवश्यकता नहीं है।

हमेशा की तरह, यह कोड-गोल्फ है , इसलिए मानक खामियों पर प्रतिबंध लगाया जाता है, और बाइट्स में सबसे कम जवाब जीतता है!

Comments

0 के बारे में क्या? क्या वह थ्रस्टी है?

— tuskiomi

@tuskiomi तकनीकी रूप से, नहीं, लेकिन यह अप्रासंगिक है क्योंकि आपको गैर-सकारात्मक संख्याओं को संभालने की आवश्यकता नहीं है।

— DJMcMayhem

क्योंकि यह करता है, तो कारण मैं पूछ है है एक गीज़ा संख्या है, तो संख्या 1210 123,210, आदि जैसे भी truthy होगा।

— tuskiomi 16:16

@tuskiomi न तो उन में से एक हैं या अंडों की एक विषम संख्या है। जब तक आप एक अग्रणी 0 की गिनती नहीं कर रहे हैं, लेकिन यह सब कुछ अधिक जटिल बना देता है।

— DJMcMayhem

@ nedla2004 मुझे लगता है कि अग्रणी 0 इनपुट स्वरूपों को अधिक जटिल बनाता है। सब कुछ अच्छा और सरल रखने के लिए, हम कहेंगे कि आप मान सकते हैं कि इनपुट में 0 की अग्रणी नहीं होगी।

— DJMcMayhem

Answer 1

पायथन 2, 48 47 46 बाइट्स

lambda s:s[~len(s)/2:]in'987654321'>s==s[::-1]

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

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

पायथन में, एक जंजीर तुलना सच है और यदि केवल सभी व्यक्तिगत तुलना समान है, तो रिटर्न । इस विशिष्ट मामले में, हमारा लैम्ब्डा सही है और यदि केवल निम्नलिखित सभी शर्तों को पूरा किया जाता है।

• s[~len(s)/2:]in'987654321'

  एक स्ट्रिंग के लिए एस लंबाई की 2n + 1 , ~len(s)/2रिटर्न ~ (2n + 1) / 2 = - (2n + 2) / 2 = - (n + 1) , तो s[~len(s)/2:]सबसे दायीं ओर पैदावार n + 1 के पात्रों रों ।

  इसी तरह, एक स्ट्रिंग के लिए रों लंबाई की 2n , ~len(s)/2रिटर्न ~ (2n) / 2 = - (2n + 1) / 2 = - (n + 1) (पूर्णांक विभाजन हमेशा की ओर दौर -∞ , तो s[~len(s)/2:]एक बार फिर सबसे दायीं ओर पैदावार n + 1 के पात्रों रों

  तुलना सही है अगर और केवल तभी सही n + 1 अक्षर एक विकल्प बनाते हैं 987654321।

  ध्यान दें कि अगर वे करते हैं और रों है 2n वर्ण, रों विलोमपद नहीं हो सकता है; n ^वें और (n + 1) ^वें सही से पात्रों अलग हो जाएगा, और बाद के है n ^वें बाएं से चरित्र।

• '987654321'>s

  यह तार की तुलनात्मक रूप से करता है। चूंकि 9 एकमात्र गीज़ा संख्या है जो 9 से शुरू होती है , सभी गिज़ा संख्या इस तुलना को संतुष्ट करती हैं।

  ध्यान दें कि इन तारों की तुलना करना हमारी निर्णय समस्या का हिस्सा नहीं है; >sकी तुलना में केवल तीन वर्ण कम है and s।

• s==s[::-1]

  यह रिटर्न यह सच है यदि और केवल यदि रों विलोमपद।

Comments

यह जवाब पागल जादूगर है। मैं समझता हूं कि इसके टुकड़े और टुकड़े कैसे काम करते हैं, लेकिन यह समझने की भी शुरुआत नहीं कर सकते कि आप इसके साथ कैसे आए। और एक पल के लिए, मैं की मेरी 64 +1 गर्व था

— DJMcMayhem

मैं उन 3 बाइट्स को बचाने के लिए गारंटीकृत तुलना से प्यार करता

— हूं

Answer 2

पर्ल, 39 37 42 39 + 1 = 40 बाइट्स

एक नई विधि का उपयोग करते हुए, मैं बाइट्स की एक बड़ी संख्या में कटौती करने में कामयाब रहा। -nझंडे के साथ भागो । रनटाइम पर इनपुट को बार-बार स्वीकार करता है, उसी के अनुसार 0 या 1 प्रिंट करता है।

मुझे 5 बाइट्स जोड़ना पड़ा क्योंकि मुझे इसके बिना पता चला, कोड ने 1234567900987654321 जैसे इनपुट्स के लिए काम किया, जो कि गीज़ा नंबर नहीं है। चूंकि गीज़ा संख्याओं में अंक 0 कभी नहीं होता है (और आवश्यकता के अनुसार सभी झूठी सकारात्मक संख्याओं में अंक 0 होता है), उसके लिए ये 5 बाइट्स खाते हैं।

say!/0/*($_- s/..?/1/gr**2)=~/^(.)\1*$/

स्पष्टीकरण:

say!/0/*($_- s/..?/1/gr**2)=~/^(.)\1*$/  #$_ contains input by default.
   !/0/                                  #Ensure that the initial text doesn't contain the number 0
       *                                 #Since both halves of this line return either 0 or 1, multiplying them together only yields 1 if both are true (which we want).
             s/   / /gr                  #Perform a substitution regex on $_ (see below)
                                         #/g means keep replacing, /r means don't modify original string; return the result instead
               ..?                       #Replace 1 or 2 characters (2, if possible)...
                   1                     #...with the number 1
                       **2               #Square this number...
        ($_-              )              #...and subtract it from the input
                           =~            #Do a regex match on the result
                             /^      $/  #Make sure the regex matches the WHOLE string
                               (.)       #Match any character...
                                  \1*    #...followed by itself 0 or more times
say                                      #Finally, output the result of the whole line of code.

प्रतिस्थापन रेगेक्स का उद्देश्य 1 एस की एक स्ट्रिंग का निर्माण करना है जिसकी लंबाई इनपुट की लंबाई की आधी है, गोल है। इस प्रकार, एक इनपुट 12321स्ट्रिंग का उत्पादन करेगा 111, जो तब चुकता हो जाता है (नीचे स्पष्टीकरण)। यहां तक ​​कि लंबाई के इनपुट भी स्ट्रिंग का उत्पादन करेंगे जो अंतिम रेगेक्स सफल होने को सुनिश्चित करने के लिए बहुत छोटे हैं।

निम्नलिखित के कारण यह कोड काम करता है:

        1         =         1**2
       121        =        11**2
      12321       =       111**2
     1234321      =      1111**2
    123454321     =     11111**2
   12345654321    =    111111**2
  1234567654321   =   1111111**2
 123456787654321  =  11111111**2
12345678987654321 = 111111111**2

हम स्पष्ट रूप से देख सकते हैं कि आरएचएस में 1 की संख्या एलएचएस के आधे से अधिक 1/2 के बराबर है। (1 और यदि हम काटते हैं)। इसके अतिरिक्त:

567898765 - 123454321 = 444444444, जो सिर्फ 4 दोहरा रहा है। इसलिए जब हम अपने वर्ग को अपने नंबर से घटाते हैं, अगर हमें एक प्रतिलेख मिलता है, तो हमारा मूल नंबर गीज़ा नंबर होता है।

पुराना कोड और पुरानी विधि (58 + 1 = 59 बाइट्स)

@ बडा के लिए 1 बाइट का धन्यवाद

-nउपयोग में ध्वज, पाइप पाठ के साथ चलाएँecho

say$_==($;=join"",/(.)/..($==y///c/2+/(.)/)-1).$=.reverse$

लंबाई और अग्रणी पूर्णांक द्वारा निर्धारित अद्वितीय गीज़ा संख्या की गणना करता है, और देखता है कि क्या यह इनपुट से मेल खाता है।

यदि यह एक गीज़ा संख्या है, तो अन्यथा echo -n "123454321" | perl -M5.010 -n giza.pl रिटर्न के रूप में चलाएं 1।

Comments

यह दूसरी विधि के लिए एक सुंदर अवलोकन है।

— ट्राइकोप्लाक्स

Answer 3

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

9ẆŒBḌċ

सभी 45 गिज़ा संख्या संख्या उत्पन्न करता है, फिर सदस्यता के लिए परीक्षण करता है।

इसे ऑनलाइन आज़माएं! या उत्पन्न संख्या देखें ।

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

9ẆŒBḌċ  Main link. Argument: n

9       Set the return value to 9.
 Ẇ      Windows; yield all "substrings" of [1, ..., 9].
  ŒB    Bounce; map each [a, ..., b] to [a, ..., b, ..., a].
    Ḍ   Undecimal; convert the digit arrays to integers.
     ċ  Count the number of occurrences of n.

Answer 4

जावास्क्रिप्ट (ईएस 6), 46 45 42 41 बाइट्स

f=([c,...s])=>s+s&&c-s.pop()|c-~-f(s)?0:c

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

मूल विचार कुछ चीजों की जांच करना है:

• यदि स्ट्रिंग एक चार लंबी है, या
• पहला चार अंतिम चार के रूप में ही है, और
• मध्य खंड भी एक गीज़ा संख्या है, और
• दूसरा चार यहाँ पहले चार की तुलना में अधिक है।

Comments

क्षमा करें, मैंने प्रश्न को गलत बताया।

— नील

Answer 5

जावा 7, 128 119 105 बाइट्स

boolean t(long n){long a=1,b=1,c=0;for(;a<n/10;b=b*b<=n/10?b*10+1:b,c^=1)a=a*10+1;return(n-b*b)%a<1&c<1;}

और कोई तार नहीं! तो, अब मैं 111...इनपुट ( a), और एक छोटे से वर्ग ( b) के रूप में एक ही लंबाई की संख्या पैदा करके शुरू करता हूं । फिर आप b*bइनपुट से घटा सकते हैं और विभाजन की जांच कर सकते हैं a। cबस वहाँ अजीब / भी जाँच करने के लिए, यह कोई मन नहीं> _> भुगतान करते हैं

Whitespaced:

boolean t(long n){
    long a=1,b=1,c=0;
    for(;a<n/10;b=b*b<=n/10?b*10+1:b,c^=1)
        a=a*10+1;
    return(n-b*b)%a<1&c<1;
}

पुरानी विधि, 119 बाइट्स

boolean g(char[]a){int i=1,l=a.length,b=1,d;for(;i<l;b*=i++>l/2?d==-1?1:0:d==1?1:0)d=a[i]-a[i-1];return b>0?l%2>0:0>1;}

सरणी के माध्यम से चलता है, प्रत्येक अंक के बीच 1 (या -1, जिसके आधार पर आधा) के अंतर की जाँच करता है। फिर लंबाई को देखने के लिए बस जांच की जाती है।

Whitespaced:

boolean g(char[]a){
    int i=1,l=a.length,b=1,d;
    for(;i<l;b*=i++>l/2?d==-1?1:0:d==1?1:0)
        d=a[i]-a[i-1];
    return b>0?l%2>0:0>1;
}

Comments

आपको यह देखने के लिए जांच करने की आवश्यकता है कि क्या पहले अंतिम के समान है?

— नाथन मेरिल

मुझे कोई मतलब नहीं है कि आपका क्या मतलब है> _>

— ज्योबिट्स

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

— हाइपिनो

@ हाइपिनो समस्या कहती है कि इनपुट को एक स्ट्रिंग या पूर्णांक के रूप में लिया जा सकता है, और यहां char[] एक स्ट्रिंग के रूप में गिना जाता है, इसलिए मैं कहूंगा कि यह मान्य है।

— जियोबिट्स

@Geobits आह मुझे वह हिस्सा याद नहीं आया जहां उसने कहा कि इसे स्ट्रिंग के रूप में लिया जा सकता है।

— हाइपिनो

Answer 6

05AB1E , 9 8 बाइट्स

सत्य 1 है , मिथ्या है 0 ।

9LŒ€ûJ¹å

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Comments

मुझे लगता है कि 2ä¬û¹Qयह भी काम करेगा और दो बाइट्स बचाता है।

— 9

@Obsable 12521 एक गीज़ा संख्या नहीं है, यह मध्य तत्व के लिए विफल है।

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

मुझे अब एहसास हुआ कि मैंने तीसरे बिंदु (लगातार अंक) को छोड़ दिया। कोई बात नहीं!

— Osable

अह्ह्ह ... मैं उपसर्गों का उपयोग कर रहा था, मैं भविष्य के प्रयासों के लिए सबस्टीट्यूशन को ध्यान में रखूंगा, थोड़ा सा हैक।

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

Answer 7

पायथन 2, 77, 76, 64 , 63 बाइट्स

f=lambda s:2>len(s)or(s[0]==s[-1]==`int(s[1])-1`and f(s[1:-1]))

एक सरल पुनरावर्ती समाधान। यह देखने के लिए कि क्या पहले और अंतिम अंक एक-दूसरे के बराबर हैं और दूसरे अंक शून्य से। फिर चेक करता है कि बीच में गीज़ा नंबर भी है या नहीं। एक बार एक अंक में नीचे जाने पर यह सही हो जाता है।

एक बाइट ने @Rod को धन्यवाद दिया, बाइट्स के एक टन ने DLosc और ETHProductions की बदौलत बचा लिया!

Comments

आप स्वैप कर सकते हैं len(s)==1के साथ 1==len(s)अंतरिक्ष पर करने के लिए सेव 1 बाइट, भी, andके साथ प्रतिस्थापित किया जा सकता *3 बाइट्स को बचाने के लिए

— रॉड

बस रॉड की टिप्पणी में जोड़ने के लिए: 1orभी काम करता है। (जब तक यह एक 0पूर्ववर्ती नहीं है - oतब पायथन को लगता है कि यह एक अष्टक संख्या है।)

— DLosc

आप आम तौर पर स्थान नहीं ले सकता andके साथ *, जब शॉर्ट सर्किट व्यवहार के लिए आवश्यक है के रूप में यह एक पुनरावर्ती समारोह में है। पहले andको बदली जाना चाहिए, लेकिन इसे दो सेट कोष्ठक की आवश्यकता होती है, जो किसी भी बचत को नकार देती है। (cc: @ रोड)

— १

मैं बहुत अजगर नहीं जानता, लेकिन क्या आप 1) के int()आसपास s[0]या 2) को हटा सकते हैं s[0]==`int(s[1])-1` ?

— ETHproductions

@ETHproductions सुझाव पर बिल्डिंग: s[-1]==s[0]==`int(s[1])-1`(विशेष रूप से पायथन 2 की आवश्यकता है)।

— १

Answer 8

PowerShell v3 +, 147 108 67 बाइट्स

$args[0]-in(1..9+(1..8|%{$i=$_;++$_..9|%{-join($i..$_+--$_..$i)}}))

मौलिक रूप से परिवर्तित दृष्टिकोण। सभी संभव गीज़ा संख्या, और फिर जाँच करता है उत्पन्न करता है कि क्या इनपुट $args[0]है -inकि संग्रह। नीचे गीज़ा संख्याओं का संग्रह कैसे बनता है:

1..9+(1..8|%{$i=$_;++$_..9|%{-join($i..$_+--$_..$i)}})
      1..8|%{                                       }  # Loop from 1 up to 8
             $i=$_;                                    # Set $i to the current number
                   ++$_..9|%{                      }   # Loop from one higher up to 9
                                   $i..$_+--$_..$i     # Build two ranges and concatenate
                                                       # E.g., 2..5 + 4..2
                             -join(               )    # Join into a single string
1..9+(                                               ) # Array concatenate with 1 to 9

उदाहरण चलता है:

PS C:\Tools\Scripts\golfing> 12321,5678765,121,4,123321,1232,5678,13631|%{"$_ --> "+(.\giza-numbers.ps1 "$_")}
12321 --> True
5678765 --> True
121 --> True
4 --> True
123321 --> False
1232 --> False
5678 --> False
13631 --> False

Comments

१० like -> ६ looks ... ऐसा लग रहा है कि आप इस बार (और शायद ज्यादातर समय) जीत गए: पी

— योडल

Answer 9

पायथन 3, 65 बाइट्स

lambda x:len(x)<18and x[:len(x)//2+1]in'0123456789'and x[::-1]==x

मुझे पूरा यकीन नहीं है, लेकिन मुझे लगता है कि यह काम करता है।

Comments

ऐसी कोई भी गिज़ा संख्या नहीं है जो 0आपके साथ शुरू होती है , आप उसे हटा सकते हैं :) 17 से अधिक समय तक कोई भी संख्या नहीं होगी जो उस स्थिति को संतुष्ट करती है ताकि आपको इसकी आवश्यकता न हो। यह अनिवार्य रूप से एक ही समाधान है डेनिस के पास :)

— केड

@ शेबंग लेकिन यह एक पहले पोस्ट किया गया था ...

— रॉड

@ मैं दावा नहीं कर रहा था कि उन्होंने नकल की या कुछ भी :)

— Kade

@ शेहेबंग न तो मैं c:

— रॉड

Answer 10

पायथन 2, 68 73 66 बाइट्स

lambda n:n==`int('1'+len(n)/2%9*'1')**2+int(len(n)*`int(n[0])-1`)`

इस तथ्य का दुरुपयोग करते हुए 11^2=121, 111^2=12321और इसी तरह, मैं इसकी गणना करता हूं और 1111..ऑफसेट के रूप में पर्याप्त समय जोड़ता हूं ।
उदाहरण:
23432=111^2+11111*1
676=11^2+111*5

Comments

चूंकि आप कॉल नहीं कर रहे हैं f, इसलिए आपको वास्तव में इसे नाम देने की आवश्यकता नहीं है। आप को हटाने के द्वारा दो बाइट्स बचा सकता हैf=

— DJMcMayhem

आपको इस पर एक टोपी सेट करना चाहिए। इनपुट 1234567900987654321सही है, जब यह गलत होना चाहिए।

— Geobits

@Geobits ooops, फिक्स्ड (मुझे लगता है?)

— रॉड

Answer 11

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

कोड + -pझंडे के 40 बाइट्स ।

s/(.)(?=(.))/$1-$2/ge;$_=/^(-1(?1)1|).$/

आउटपुट 1 यदि इनपुट एक गीज़ा संख्या है, तो कुछ भी नहीं। इसे चलाने के लिए अंतिम न्यूलाइन के बिना इनपुट की आपूर्ति करें:

echo -n '123456787654321' | perl -pe 's/(.)(?=(.))/$1-$2/ge;$_=/^(-1(?1)1|).$/'

स्पष्टीकरण : पहले, s/(.)(?=(.))/$1-$2/geप्रत्येक अंक $1(इसके बाद $2) को बदलें $1-$2। यदि यह एक गीज़ा संख्या है, तो प्रत्येक अंक शुरुआत में अगले की तुलना में एक कम है, और अंत में एक और है, तो स्ट्रिंग में केवल -1पहले भाग में होना चाहिए , और 1दूसरे में (अंतिम को छोड़कर जो अपरिवर्तित है) । यही कारण है कि दूसरे भाग की /^(-1(?1)1|).$/जाँच करता है: एक के -1बाद पुनरावृत्ति द्वारा पीछा के लिए लग रहा है 1।

मार्टिन एंडर के लिए -1 बाइट धन्यवाद।

---

मेरा पिछला संस्करण 15 बाइट्स लंबा है (बहुत अलग है इसलिए मैं इसे यहाँ दूँगा):

echo -n '123456787654321' | perl -F -pe '$\=$_ eq reverse;$\&=$F[$_-1]+1==$F[$_]for 1..@F/2}{'

Comments

इसका एकमात्र हिस्सा मुझे समझ में नहीं आता |कि दूसरे रेगेक्स में इसका उद्देश्य है ।

— गेब्रियल बेनामी

@GabrielBenamy यह पुनरावर्ती ब्लॉक का आधार मामला है (यानी यह कुछ भी मेल नहीं खाता है और पुनरावृत्ति को रोकता है)।

— दादा

Answer 12

> <> फिश 57 52 49 48 बाइट्स

i:1+?!vi00.;n1<
%?v0n;>~l:1-?!^2
{:<11 ^?:=@:$+=

संपादित करें 1: = रिटर्न 0 या 1 यदि सच है तो एक चेक को हटा दिया और वेतन वृद्धि के लिए इस मूल्य का उपयोग किया, तो यह वैसे भी समानता की जांच करता है। (6 बाइट्स को बचाया, नई लाइन के लिए 1 खो दिया)।

संपादित करें 2: 3 दिशात्मक मार्करों को हटा दिया गया और 11 को स्टैक को ऑफसेट करने के लिए अंतराल में रखा गया ताकि झूठे (3 बाइट्स) को मजबूर करने के लिए,

संपादन 3: MOD की जांच के लिए 2 और len (1) के लिए स्टैक की लंबाई को डुप्लिकेट करें, यह पहले दो बार लंबाई डालकर किया गया था लेकिन अब इसने लाइन 2 (1 बाइट सेव) पर एक खाली जगह भर दी।

Answer 13

C #, 120 86 108 102 92 बाइट्स

x=I=>{var Z=I.Length;return Z<2?1>0:I[0]==I[Z-1]&I[1]-0==I[0]+1?x(I.Substring(1,Z-2)):0>1;};

कुछ परीक्षण मामलों के साथ पूरा कार्यक्रम:

class a
{
    static void Main()
    {
        Func<string, bool> x = null;

        x = I=>
        {
            var Z=I.Length;
            return Z==1?                           // length == 1?
                     1>0:                          // return true (middle of #)
                     I[0]==I[Z-1]&I[1]-0==I[0]+1?  // else start == end and the next number is 1 above the current?
                       x(I.Substring(1,Z-2)):      // recursive call on middle
                       0>1;                        // else false
        };

        Console.WriteLine("1 -> " + (x("1") == true));
        Console.WriteLine("9 -> " + (x("9") == true));
        Console.WriteLine("121 -> " + (x("121") == true));
        Console.WriteLine("12321 -> " + (x("12321") == true));
        Console.WriteLine("4567654 -> " + (x("4567654") == true));
        Console.WriteLine("12345678987654321 -> " + (x("12345678987654321") == true));
        Console.WriteLine("12 -> " + (x("12") == false));
        Console.WriteLine("1221 -> " + (x("1221") == false));
        Console.WriteLine("16436346 -> " + (x("16436346") == false));
        Console.WriteLine("123321 -> " + (x("123321") == false));
        Console.WriteLine("3454321 -> " + (x("3454321") == false));
        Console.WriteLine("13631 -> " + (x("13631") == false));
        Console.WriteLine("191 -> " + (x("13631") == false));
        Console.Read(); // For Visual Studio
    }
}

सिंगल लाइन कंडीशन के लिए हुर्रे, अब जावा उत्तर को हराकर :)! मेरी पहली व्याख्या करने वाली टिप्पणियाँ भी लिखीं, हालाँकि यह शायद स्वयं व्याख्यात्मक है। मेरे एल्गोरिथ्म के साथ एक समस्या खोजने के लिए @ दादा का धन्यवाद (उन संख्याओं के लिए सही था, जिन्हें 13631 की तरह दिखाया गया था)। अब उप 100 के बाद से स्पष्ट रूप से लंबाई 2% के लिए जाँच बेमानी है।

Comments

क्या यह trueसंख्याओं के लिए वापस नहीं आएगा 13631? जब से आप एक पुनरावर्ती कॉल करते हैं x, मुझे लगता है कि आपको x=अपनी बाइट की गिनती में शामिल करने की आवश्यकता है ।

— दादा

@ दादा हेह अच्छी बात, जानता था कि मुझे कुछ याद आ रहा है ... और ठीक है, मैं उन लोगों को गिनती में जोड़ दूंगा।

— योदले

रुको, तुम अब क्या कर रहे हो? ;)

— जॉर्ज

@Geobits खतरा! मैं देखूंगा कि मैं कल क्या कर सकता हूं: पी

— योडल

Answer 14

बैश, 111 बाइट्स

अद्यतन करें

ध्यान दें कि इनपुट संख्या सामान्यकरण को पूरी तरह से छोड़ दिया जा सकता है, यदि आप अपने डिजिटली GIZA नंबर में पहला अंक वापस जोड़ते हैं , जैसे:

01210 + 6 => 67876

और फिर सीधे इनपुट के साथ तुलना करें।

अस्वीकरण: यह वास्तव में अनुकूलित नहीं है, इसलिए यह वास्तविक दावेदार की तुलना में अवधारणा का अधिक प्रमाण है

golfed

G() { I=`sed "s/./\0-${1::1}\n/g"<<<$1|bc`;Z=`seq 0 $((${#1}/2))`;A=`rev <<<$Z`;cmp -s <(echo $I) <<<$Z${A:1}

कलन विधि

किसी भी GIZA संख्या को इसके विहित रूप से सामान्य किया जा सकता है, बाकी से इसका पहला अंक घटाकर :

67876 - 6 => 01210
78987 - 7 => 01210

और एक विशेष लंबाई की केवल एक विहित GIZA संख्या है।

इसे जानकर हम आसानी से इनपुट संख्या की लंबाई के आधार पर एक विहित GIZA नंबर उत्पन्न कर सकते हैं :

 Z=`seq 0 $((${#1}/2))`;A=`rev <<<$Z` => $Z${A:1}

फिर इनपुट नंबर को सामान्य करें:

 I=`sed "s/./\0-${1::1}\n/g"<<<$1|bc`

और तुलना करें

 cmp -s <(echo $I) <<<$Z${A:1};

परीक्षा

for i in `seq 0 1000`; do G $i && echo $i; done

0
1
2
3
4
5
6
7
8
9    
121
232
343
454
565
676
787
898

...

G 12345678987654321 && echo "OK" || echo FALSE     
OK

G 123456789987654321 && echo "OK" || echo FALSE
FALSE

Comments

मुझे आशा है कि आपको कोई आपत्ति नहीं है, मैंने अपने उत्तर में इस एल्गोरिथ्म का एक हिस्सा लागू किया :)

— FlipTack

Answer 15

दरअसल , 22 बाइट्स

9uR;∙`xR;RdX+εj`M;░#íu

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

एक उद्धृत स्ट्रिंग (जैसे "12321") के रूप में इनपुट लेता है । आउटपुट सत्य के लिए, और 0असत्य के लिए एक सकारात्मक पूर्णांक है ।

स्पष्टीकरण:

9uR;∙`xR;RdX+εj`M;░#íu
9uR;∙                   cartesian product of [1,2,3,4,5,6,7,8,9,10] with itself
     `xR;RdX+εj`M       for each pair:
      x                   construct the half-open (end-exclusive) range ([1, 5] -> [1, 2, 3, 4])
       R                  reverse
        ;RdX+             duplicate, reverse, remove first element, prepend ([1, 2, 3, 4] -> [1, 2, 3, 4, 3, 2, 1])
             εj           concatenate into a string
                 ;░     filter out empty strings
                   #íu  test for membership

Answer 16

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

(`elem`[[j..pred i]++[i,pred i..j]|i<-['1'..'9'],j<-['1'..i]])

इनपुट को एक स्ट्रिंग के रूप में लिया जाता है।

सभी गिज़ा संख्याओं की एक सूची बनाता है यदि संख्या उसमें है। सूची तत्वों के माध्यम iसे '1'..'9'और फिर के jमाध्यम से पाशन द्वारा बनाई गई है ।'1'..ij .. i-1 , i , i-1 .. j

Answer 17

> <> , 62 बाइट्स

i:0(   ?v
v!1&!~{!<:=$:@&-1=+2=*>l!-3!1(!:?
>l!;2!n=!0?!<-1=n;

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

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

Answer 18

CJam , 20 19 बाइट्स

l_$_W=),\ci>_W<W%+=

परीक्षण सूट।

व्याख्या

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

l       e# Read input.
_$      e# Get a sorted copy of the input.
_W=     e# Get its last character, i.e. the maximum digit M.
),      e# Get a string with all characters from the null byte up to M.
\c      e# Get the first character of the sorted string, i.e. the minimum
        e# character m.
i>      e# Convert to its character code and discard that many leading
        e# characters from the string we generated before. Now we've got
        e# a string with all digits from m to M, inclusive.
_W<W%+  e# Palindromise it, by appending a reversed copy without M.
=       e# Check that it's equal to the input.

न्यूनतम चरित्र के बजाय, हम पहले चरित्र का उपयोग कर सकते हैं, उसी बाइट की गणना के लिए:

l_:e>),1$ci>_W<W%+=

Answer 19

मैथेमेटिका, 62 61 60 बाइट्स

^{@MartinEnder के कारण 2 बाइट्स बचाए ।}

MatchQ[{a:1...,b___}/;{b}==-{a}]@*Differences@*IntegerDigits

कार्यों की संरचना। इनपुट और रिटर्न के रूप में Trueया Falseआउटपुट के रूप में एक संख्या लेता है ।

Answer 20

रेटिना, 55 54 36 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

.
$*1:
+`^(1+:)(1\1.*)\b\1$
$2
^1+:$

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

कॉलोनियों द्वारा अलग किए गए प्रत्येक अंक को एकरी में बदलें। यदि अगला अंक एक और है, तो लूप को बाहरी अंकों के मिलान से हटा दें। बचे हुए एक अंक का मिलान करें।

Comments

यह स्वीकार करता है12312

— मार्टिन एंडर

यह 36 बाइट्स में काम करता है।

— मार्टिन एंडर

Answer 21

PHP, 71 बाइट्स

for($t=$i=max(str_split($s=$argv[1]));$t!=$s&&--$i;)$t="$i$t$i";echo$i;

इनपुट से सबसे बड़ा अंक प्राप्त करता है और गणना और स्ट्रिंग के बराबर होने तक नए अंक को एक स्ट्रिंग में जोड़ देता है - या $iहै 0।

टिम्मी नंबर के लिए सबसे कम अंक प्रिंट करता है, 0और।

Answer 22

पुष्य , 30 15 बाइट्स

मैं आज सुबह उठा और महसूस किया कि मैं अपने उत्तर की आधी लंबाई ...

s&K-kL2/OvhXwx#

_{(भाषा को चुनौती देने के रूप में गैर-प्रतिस्पर्धात्मक)}

इनपुट कमांड लाइन पर दिया गया है $ pushy gizas.pshy 3456543:। सच्चाई के 1लिए और झूठे के लिए आउटपुट 0। यहाँ ब्रेकडाउन है:

s                  % Split the number into its individual digits
 &K-               % Subtract all digits by the last 
    kL2/  h        % Get the halved length of the stack (+1)
        Ov X       % In stack 2, generate range (0, halved length)
            w      % Mirror the range 
             x#    % Check stack equality and output

एल्गोरिथ्म बाश उत्तर से प्रेरित था: पहले, संख्या को सामान्य करें, ( 45654 -> 01210), फिर समान लंबाई के सामान्यीकृत गीज़ा संख्या उत्पन्न करें (केवल एक ही है), और तुलना करें।

---

पुराना हल

s&K-Y?kL2%?L2/:.;&OvhXx#i;;;0#

Answer 23

रैकेट 292 बाइट्स

(let*((s(number->string n))(sn string->number)(st string)(lr list-ref)(sl(string->list s))(g(λ(i)(-(sn(st(lr sl(add1 i))))
(sn(st(lr sl i)))))))(cond[(even?(string-length s))#f][(not(equal? s(list->string(reverse sl))))#f][(andmap identity
(for/list((i(floor(/(length sl)2))))(= 1(g i))))]))

Ungolfed:

(define(f n)
  (let* ((s (number->string n))
         (sn string->number)
         (st string)
         (lr list-ref)
         (sl (string->list s))
         (g (λ (i) (- (sn(st(lr sl (add1 i))))
                      (sn(st(lr sl i)))))))
    (cond
      [(even? (string-length s))
       #f]
      [(not(equal? s (list->string (reverse sl))))
       #f]
      [else
       (andmap identity
               (for/list ((i (floor(/(length sl)2))))
                 (= 1 (g i))))]
      )))

परिक्षण:

(f 12321) 
(f 123321)  ; only this should be false; 

(f 9)
(f 787)
(f 67876)
(f 4567654)
(f 123454321)
(f 12345654321)
(f 1234567654321)
(f 123456787654321)
(f 12345678987654321)

आउटपुट:

#t
#f
#t
#t
#t
#t
#t
#t
#t
#t
#t

Answer 24

जावा 8, 162 + 19 बाइट्स

19 के लिए import java.util.*;

s->{List f=new ArrayList();for(int i=0;i<9;){String l=String.valueOf(++i);for(int j=i;j>0;){f.add(l);String k=String.valueOf(--j);l=k+l+k;}}return f.contains(s);}

अन्य जावा उत्तर के लिए अलग-अलग दृष्टिकोण, मैं कोशिश करना चाहता था और सभी संभव टिम्मी नंबर बनाने और जाँचने की विधि का उपयोग करना चाहता था कि क्या हमारे स्ट्रिंग उनमें निहित थे।

Answer 25

ऑक्टेव, 56 बाइट्स

@(n)nnz(n)<2||~(abs(diff(+n))-1)&&diff(+n(1:1+end/2))==1

यहां सभी परीक्षण मामलों की जांच करें ।

MATLAB में यह दो कम बाइट्स होगा, क्योंकि diff(n)स्ट्रिंग्स के लिए काम करता है। ऑक्टेव में, आपको आवश्यकता है diff(+n)।

स्पष्टीकरण:

@(n)                  % Anonymous function taking a string `n` as argument
    nnz(n)<2          % True if there is only one element in n
            ||        % Short circuit or operator. Expression will be true if this is true
~(abs(diff(+n))-1)    % Takes the absolute value of the difference between adjacent numbers
                      % which should always be 1. Subtracts 1, to get 0
                      % and negates it to get 1 (true)
diff(+n(1:1+end/2))==1   % Checks if the difference between the first half of the numbers
                         % is 1.
                      % If either the first, or both the second and third argument is true
                      % then the function will return 1, otherwise 0. 

Answer 26

मैथेमेटिका, 56 बाइट्स

यह थोड़ा छोटा है:

MatchQ[Differences@IntegerDigits@#,{a:1...,b__}/;b==-a]&

Answer 27

जावा 7, 129 119 109 बाइट्स

boolean e(char[]a){int l=a[0]-1,f=0,b=a.length-1;for(;f<b&&a[f]==++l&a[f++]==a[b--];);return f==b&l==a[b]-1;}

पुरानी पुनरावर्ती विधि, 119

boolean b(char[]a){int b=a.length;return b>1&&a[0]==a[b-1]&a[0]+1==a[1]?b(java.util.Arrays.copyOfRange(a,1,b-1)):b==1;}

-10 बाइट्स जियोबिट्स की बदौलत। हम कर रहे हैं बंधे थे ...

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

Comments

मुझे लगता है कि आप 1 बाइट को बिटवाइज़ के साथ बचा सकते हैं and, मुझे लगता है कि आपने इसे एक बार इस्तेमाल किया था लेकिन दूसरी बार नहीं? या मैं इसे गलत पढ़ रहा हूं।

— योडल

@Yodle मैंने केवल एक बार इसका उपयोग किया क्योंकि मुझे पहली शर्त के लिए शॉर्ट सर्किट की आवश्यकता है।

— पोक

ऐसा लगता है कि आप केवल एक बार आयात का उपयोग कर रहे हैं, इसलिए आपको java.util.Arrays.copyOfRange(...)आयात लाइन को छोड़ने के लिए उपयोग करके इसे छोटा करना चाहिए ।

— जॉर्ज

@Geobits का अच्छा पकड़ ... I derp

— Poke

Answer 28

पर्ल 6 , 43 34 बाइट्स

-9 बाइट्स के लिए जो किंग को धन्यवाद।

{!/0/==set comb $_- S:g/..?/1/²:}

गैब्रियल बेनामी के पर्ल समाधान का बंदरगाह ।

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

Answer 29

Cjam, 35 बाइट्स

शायद बहुत ही अडॉप्टिमल ... मैं अभ्यास से थोड़ा बाहर हूँ!

q__W%=\_,_2%@@2/)<2ew{:-}%e`,1=]:e&

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

Answer 30

पायथन 2, 50 82 81 80 बाइट्स

def f(a):b=len(a)/2+1;print(1,0)[a[:b-1]!=a[b:][::-1]or a[:b]not in'123456789']

सरल दृष्टिकोण। बस स्ट्रिंग को आधे हिस्से में विभाजित करता है (मध्य चरित्र को याद कर रहा है या मध्य चरित्र के बाद एक अगर यह और भी लंबाई का है), तो दूसरी छमाही को उलट देता है फिर दोनों की तुलना करता है और पहले आधे हिस्से की तुलना 1 से 9 के स्ट्रिंग के साथ करता है।

संपादित करें

साथी गोल्फरों से रचनात्मक प्रतिक्रिया और मेरी गलतियों को महसूस करने और सुधारने के बाद फिर से तैयार किया गया।

-1 (जगह की बर्बादी) को खोने के लिए

-1 प्रश्न को फिर से पढ़ने और महसूस करने के लिए कि हमें 0 को ध्यान में रखने की आवश्यकता नहीं है। वास्तव में काम पर एक लंबे दिन के बाद गोल्फ को रोकना चाहिए।

Comments

यह जाँच नहीं करता है कि क्या संख्याएँ सख्ती से बढ़ रही हैं। उदाहरण के लिए, 13531और 6543456दोनों गलत तरीके से सही हैं।

— डीजेएमकेम

इसके अलावा, तार '0'और '1'सच दोनों हैं।

— डेनिस

बिल्कुल सही। यह एक लंबा दिन था। अमान्य के रूप में हटा देगा।

— एलपीड्रो

टिप्पणियों के लिए धन्यवाद और न केवल डाउनवोटिंग।

— एलपेड्रो