33

गैर शून्य एक मानक पर अंक के लिए numpad

789
456
123

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

उनमें से एक है 38, चूंकि नाइट शुरू हो सकता है 3और बाएं और ऊपर जा सकता है 8। 381और 383भी संभव हैं।

3स्वयं ही संभव है यदि कोई जंप नहीं लिया जाता है (जिसकी अनुमति है)। 5वैसे भी है, लेकिन किसी अन्य अंक से नहीं पहुंचा जा सकता है 5, इसलिए यह एकमात्र नंबर है जहां अंक 5दिखाई देता है।

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

बाइट्स में सबसे छोटा कोड जीतता है। टाईब्रेकर पहले जवाब है

उदाहरण

Truthy:

1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 18, 38, 61, 81, 294, 349, 381, 383, 729, 767, 38183, 38383, 18349276, 183492761, 618349276

Falsy:

10, 11, 50, 53, 55, 65, 95, 100, 180, 182, 184, 185, 186, 187, 188, 189, 209, 305, 2009, 5030, 3838384, 4838383, 183492760

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

2

शतरंज शूरवीरों के साथ आज क्या है ? :

— लुइस मेंडो

1

संकेत: यदि आप संख्याओं को रैपिंग लाइन के रूप में लिखते हैं, तो शूरवीर हमेशा या तो चार स्थानों को दक्षिणावर्त या चार स्थानों के काउंटर से कूदता है। मुझे नहीं पता कि यह मददगार है।

— निधि मोनिका का मुकदमा

3

@LuisMendo रैपिंग। जैसे, यदि आप उपचार करते हैं, तो 78963214बार-बार होने वाली अंतहीन सूची के रूप में । दूरियों की गणना करें - यह हमेशा चार होता है, एक ही रास्ता या दूसरा। मुझे स्पष्ट और स्पष्ट रूप से कहा जाना चाहिए कि आपको इसे सर्कल ऑर्डर में लिखना है।

— निधि मोनिका का मुकदमा

@QPaysTaxes ओह, मैंने सोचा कि आप सर्कल का मतलब है लेकिन 123...9। क्षमा करें

— लुइस मेंडो

@LuisMendo कोई चिंता नहीं। जैसा मैंने कहा, मुझे इस बारे में स्पष्ट होना चाहिए कि मेरा क्या मतलब था।

— निधि मोनिका का मुकदमा

16

जेली, 19 15 14 बाइट्स

Doȷ’d3ạ2\P€=2P

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

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

Doȷ’d3ạ2\P€=2P  Main link. Argument: n (integer)

D               Convert n to base 10 (digit array).
  ȷ             Yield 1000.
 o              Logical OR. This replaces each 0 with 1000.
   ’            Decrement each digit.
    d3          Divmod; replace each digit k with [k:3, k%3].
      ạ2\       Pairwise reduce by absolute difference.
                For each pair of adjacent digits [i, j], this computes
                [abs(i:3 - j:3), abs(i%3 - j%3)].
         P€     Compute the product of each result.
                n is a Numpad's Knight Number iff all products yield 2.
           =2   Compare each product with 2.
             P  Multiply the resulting Booleans.

— डेनिस
स्रोत

18

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

f=lambda n:n<6or`n%100`in'18349276167294381'*f(n/10)

जाँचता है कि किसी भी दो लगातार अंक स्ट्रिंग में हैं '18349276167294381'। कार्य करने के बजाय लगातार अंक प्राप्त करने के लिए zip(`n`,`n`[1:]), फ़ंक्शन बार-बार अंतिम दो अंकों की जांच करता है और अंतिम अंक निकालता है।

— XNOR
स्रोत

13

रेटिना , Ret 40 बाइट्स

इस विचार को सुझाने के लिए Sp3000 का धन्यवाद:

M&!`..
O%`.
A`16|18|27|29|34|38|49|67
^$

इसे ऑनलाइन आज़माएं!(थोड़ा परीक्षण सूट को एक साथ चलाने के लिए थोड़ा संशोधित किया गया है।)

प्रिंटों 1 लिए और0 झूठे परिणामों के लिए ।

व्याख्या

M&!`..

सभी ओवरलैपिंग मैचों का .., यानी सभी अंकों के लगातार जोड़े का पता लगाएं , और उन्हें लाइनफीड्स के साथ जुड़ें।

O%`.

प्रत्येक पंक्ति में अंकों को क्रमबद्ध करें, ताकि हमें केवल आधे जोड़े की जाँच करनी पड़े।

A`16|18|27|29|34|38|49|67

सभी लाइनों को हटा दें जो एक वैध कदम के अनुरूप हैं।

^$

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

— मार्टिन एंडर
स्रोत

7

पायथ - 35 28 बाइट्स

!s.bt/@c`C"_xÖ({Î¶z"2tsNYztz

टेस्ट सूट ।

— Maltysen
स्रोत

7

रूबी, 57 बाइट्स

अनाम फ़ंक्शन। तर्क एक तार है।

->n{(0..n.size).count{|i|!"16729438183492761"[n[i,2]]}<1}

परीक्षण सूट के साथ कार्यक्रम:

f=->n{(0..n.size).count{|i|!"16729438183492761"[n[i,2]]}<1}

a=%w{1 2 3 4 5 6 7 8 9 16 18 38 61 81 294 349 381 383 729 767 38183 38383 18349276 183492761 618349276
10 11 50 53 55 65 95 100 180 182 184 185 186 187 188 189 209 305 2009 5030 3838384 4838383 183492760}

a.each {|e|p [e, f[e]]}

मैंने अभी-अभी सभी संभावित शूरवीरों को एक स्ट्रिंग में इनकोड किया और जाँच की कि इनपुट के भीतर हर 2 अंक उस स्ट्रिंग में मौजूद हैं या नहीं।

— मूल्य स्याही
स्रोत

ओह, वह लुकअप स्ट्रिंग मुझे 17 बाइट्स भी बचाएगा। यदि आप मेरे रेटिना उत्तर के लिए उपयोग करते हैं तो क्या आपको बुरा लगता है?

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

इसका लाभ उठाएं! मैं सिर्फ श्रेय देता हूं, मुझे लगता है।

— मूल्य इंक

धन्यवाद, लेकिन मैं sp3000 द्वारा एक सुझाव के आधार पर एक भी छोटे समाधान के साथ समाप्त हुआ :)

— मार्टिन

6

grep 58 बाइट्स

grep "^((?=18|16|29|27|34|38|49|43|61|67|72|76|81|83|94|92).)*.$"

क्योंकि वास्तव में, अगर तुम grep को हरा नहीं सकते ...

— Yakk
स्रोत

2

न तो 5है और न ही 185फेंकना 1अपने आदेश पंक्ति के साथ है, जबकि 5truthy में है, और 185falsy सूची में।

— गुंतराम ब्लोह

1

@GuntramBlohm फिक्स्ड - नियमित रूप से निषेध में खो गया

— Yakk

6

हास्केल 46 बाइट्स

q=zip<*>tail
all(`elem`q"16729438183492761").q

उपयोग उदाहरण: all(`elem`q"16729438183492761").q $ "183492761"->True

यह कैसे काम करता है: यह @ केविन लाउ के उत्तर में पाए जाने वाले लुकअप स्ट्रिंग का उपयोग करता है । qएक स्ट्रिंग से आसन्न वर्णों के जोड़े की सूची बनाता है, जैसे q "1672" -> [('1','6'),('6','7'),('7','2')]। फ़ंक्शन सत्य है यदि इनपुट से सभी जोड़े लुकअप स्ट्रिंग से जोड़े में दिखाई देते हैं। qखाली सूची में एकल अंकों के इनपुट को बदल देता है, इसलिए elemहमेशा सफल होता है।

— nimi
स्रोत

क्यों zip<*>tailफ़्लिप संस्करण की तरह काम करता है zip=<<tail? मुझे लगता है कि मुझे समझ नहीं आ रहा है कि आवेदनकर्ता क्या सामान्य करते हैं।

— 22

@ xnor: मैं अभी इसका इस्तेमाल करता हूं। <*> के रूप में परिभाषित किया गया है (<*>) f g x = f x (g x) ।

— nimi

6

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

s=>[...s].every((c,i)=>!i|"16729438183492761".match(s[i-1]+c))

सच्चा या गलत लौटाता है। मैंने पहले एक पुनरावर्ती समाधान की कोशिश की थी, जिसमें 63 बाइट्स लगते हैं, mapऔर यहां तक किreduce लेकिन उन्होंने मुझे 73 बाइट्स दिए।

संपादित करें: @ उपयोगकर्ता81655 के लिए 3 बाइट्स का धन्यवाद सहेजा गया।

— नील
स्रोत

बेहतर नहीं कर सका, मेरी सबसे अच्छी कोशिश 88 बाइट्स पर थी। वाहवाही!

— नौआक

@ user81655 का मतलब है कि आप matchइसके बजाय काम करते हैं ~search(लेकिन किसी भी तरह से, यह वास्तव में कम आंका गया है) और |प्रतिस्थापित कर सकते हैं ||(लेकिन पुनरावर्ती संस्करण में नहीं, दुख की बात है।)

— नील

@ user81655 मैं उस तरीके का उल्लेख कर रहा था जो !i|...matchकाम करता है क्योंकि मैच परिणाम, यदि सफल होता है, तो दो अंकों के एकल स्ट्रिंग की एक सरणी है, जिसे |ऑपरेटर एक वैध पूर्णांक में जमा करता है।

— नील

@ नील आह, सही है।

— user81655

6

सी, 85 81 बाइट्स

golfed:

i;f(char*b){i=*b++-49;return*b?(*b=="8749x7214"[i]||*b=="6983x1632"[i])&&f(b):1;}

पुराना गैर-पुनरावर्ती संस्करण (85 बाइट्स):

i;f(char*b){for(;(i=*b++-49),*b&&*b=="8749x7214"[i]||*b=="6983x1632"[i];);return!*b;}

सफेद-स्थान और मुख्य कार्यक्रम के साथ पुराना कोड:

i;
f(char*b){
    for (; (i=*b++-49), *b     // i = index of digit + 1 in following arrays
        &&*b=="8749x7214"[i]   // 1st possible jump for 1..9
        ||*b=="6983x1632"[i];  // 2nd possible jump for 1..9
    );
    return !*b;
}

main(){
    char b[16];
    while(scanf("%s", b) == 1) printf("%d",f(b));
    return 0;
}

यह मानक इनपुट और आउटपुट 0 के माध्यम से स्पेस-सीमांकित संख्याओं को स्वीकार करता है यदि नहीं तो सुन्नत-नाइट, या 1 अन्यथा।

नया 81-बाइट पुनरावर्ती संस्करण 4 बाइट को हिलाता है।

— tucuxi
स्रोत

5

MATL , 38 37 29 बाइट्स

यह @QPaysTaxes विचार का उपयोग करता है ।

I:8JK5:7Pvj!Uttnqh?)d|2:EQm}h

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

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

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

1

क्या यह भी अनुमति है ??

— कैलक्यूलेटरफ्लेन

सवाल एक सत्य या एक गलत मूल्य के लिए पूछता है , एक पूरे सरणी नहीं।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

2

@CatsAreFluffy यह हमारी सच्चाई / झूठ की परिभाषा है। MATLAB / ऑक्टेव में, सरणियाँ MATL में सत्य हैं यदि इसके सभी तत्व सत्य हैं। ( उदाहरण )

— डेनिस

CC @ ǹ̷̰ĥ̷̳h @a̷̭̿h̸̡̅ẗ̵̨́d̴̖̋

— डेनिस

4

05AB1E , 29 बाइट्स

कोड:

"1Ôž±ÎqäÚ"•5(«U2÷¹¦2÷«vXyå})P

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

— अदनान
स्रोत

4

MATL, 25 24 33 26 बाइट्स

@LuisMendo के लिए 1 बाइट धन्यवाद से मुंडा!
@ डेनिस को एक बग मिला, और फिर इसे ठीक कर दिया गया! धन्यवाद!

'bSVYXbTUZW'j47-)d2^48\1=A

पूर्णांक को इनपुट के रूप में लेता है। आउटपुट 1/0।

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

— बीकर
स्रोत

@LuisMendo दोनों मायने में सही है, धन्यवाद!

— बीकर

@ डेनिस अपडेट किया गया, और उम्मीद है कि सही होगा। आपकी सहायता के लिए धन्यवाद।

— बीकर

मुझे नहीं लगता कि आपको Aअंत में जरूरत है । Matl के वैक्टर truthy हैं iff वे एक 0. शामिल नहीं है

— डेनिस

4

सी, 140 92 बाइट्स

c;L(char*i){while(*i&&(!c||*i=="6743x1212"[c-49]||*i=="8989x7634"[c-49]))c=*i++;return !*i;}

एएससीआईआई मान रहा है

विस्तृत यहाँ यह कोशिश करो

// valid transition from x to n[x-'1'][0 or 1]

int n[9][2] =
{
    {'6','8'},{'7','9'},{'4','8'},
    {'3','9'},{'x','x'},{'1','7'},
    {'2','6'},{'1','3'},{'2','4'}
};

// i is a pointer to where to start on a string

bool L(char * i)
{
    char c = 0;

    // move if not \0 and (not-first-char or is a valid move)

    while((*i) && (!c || (*i)==n[c-'1'][0] || (*i)==n[c-'1'][1]))
    {
        c = (*i++);
    }

    return !(*i); // success if it's \0
}

— Khaled.K
स्रोत

वे लुकअप टेबल विशाल हैं। यदि आप सभी सीमांकक से छुटकारा पा लेते हैं {,}[]और char*इसके बजाय एक स्ट्रिंग के रूप में एन्कोड करते हैं तो आप अपने स्कोर में बहुत सुधार कर सकते हैं । इसके अलावा, ध्यान दें कि #defineजब आप इसे केवल दो बार उपयोग करते हैं तो आपकी लागत प्रभावी नहीं होती है: इसे हटाने से आप 4 बाइट बचा सकते हैं।

— tucuxi

युक्तियों के लिए @tucuxi धन्यवाद, मैं इसे 92 तक लाने में कामयाब रहा, \0इस सरणी के भीतर अपरिभाषित व्यवहार का कारण बना, इसलिए मैंने इसे बदल दियाx

— खालिद.के

अच्छा - इसके अलावा, <s>oldscore</s> newscoreस्कोर सुधार को प्रतिबिंबित करने के लिए संपादन करते समय उपयोग करना न भूलें और इससे पहले कि आपका कोड वाक्य रचना हाइलाइटिंग को ठीक करना शुरू कर दे। मैं भी लूप को

— गिराकर

आपका 'विस्तृत' गोल्फ कोड के एक सादे विस्तार (जहां nलघु संस्करण में है?) से बहुत अलग दिखता है । इसके अलावा, आपको शायद यह उल्लेख करना चाहिए कि आप ASCII एन्कोडिंग मान रहे हैं - आपको EBCDIC मशीनों पर अलग-अलग नंबर मिलेंगे।

— टोबे स्पाइट

@TobySpeight विस्तृत संस्करण को यह दिखाने के लिए माना जाता है कि यह मूल रूप से कैसे बनाया गया था, हाँ मैं ASCII मान रहा हूं जो सी। में सामान्य मामला है

— खालिद

3

जूलिया, 51 49 बाइट्स

n->diff(["@1634@8725"...][digits(n)+1]).^2%48⊆1

सत्यापन

julia> f=n->diff(["@1634@8725"...][digits(n)+1]).^2%48⊆1
(anonymous function)

julia> all(map(f,(1,2,3,4,5,6,7,8,9,16,18,38,61,81,294,349,381,383,729,767,38183,38383,18349276,183492761,618349276)))
true

julia> any(map(f,(10,11,50,53,55,65,95,100,180,182,184,185,186,187,188,189,209,305,2009,5030,3838384,4838383,183492760)))
false

— डेनिस
स्रोत

3

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

;#pXZdX`Σ"67294381";'1+R+íu`Mπ

एक स्ट्रिंग के रूप में इनपुट लेता है। सच के लिए एक सकारात्मक पूर्णांक और झूठे के लिए 0 आउटपुट देता है।

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

स्पष्टीकरण:

;#pXZdX`Σ"67294381";'1+R+íu`Mπ
                                 (implicit) push input
;#pXZdx                         push zip(n[:-1], n[1;]) (pairs of digits)
       `Σ"67294381";'1+R+íu`M   map:
        Σ                         join digits
         "67294381";'1+R+         push "16729438183492761" (the magic string used in many other solutions)
                         íu       0-based index (-1 if not found), increment so 0 is not found and >=1 is the 1-based index
                             π  product

— मेगो
स्रोत

3

PowerShell v2 +, 105 96 बाइट्स

param($a)((1..$a.length|%{'27618349294381672'.IndexOf($a[$_-1]+$a[$_])+1})-join'*'|iex)-or$a-eq5

इनपुट के माध्यम से Iterates (जिसे साथ एनकैप्सुलेट किया जाना चाहिए "") यह सत्यापित करके कि वर्णों के किसी अनुक्रमिक जोड़े का सूचकांक मान्य लुकअप स्ट्रिंग में है। मुझे लगता है कि केविन लाउ के साथ भी कुछ ऐसा ही था , लेकिन मैं स्वतंत्र रूप से इस पर आया। उन सूचकांकों में से प्रत्येक के साथ जोड़ा जाता है +1, क्योंकि स्ट्रिंग नहीं मिलने पर .IndexOf()फ़ंक्शन वापस आ जाएगा -1। यह "नहीं मिला" में बदल जाएगा0 ।

हम तो -joinसभी परिणामी पूर्णांक मानों के साथ *और पाइप को iex(जैसे eval)। इसका मतलब यह होगा कि यदि कोई भी सूचकांक नहीं मिला है, तो संपूर्ण अभिव्यक्ति में परिणाम होगा 0। यह हमारे परिणामी उत्पादन को प्राप्त करने के लिए इनपुट के विशेष मामले के -orसाथ parens और 'd में संलग्न है ।$a-eq5"5"

टेस्ट रन

PS C:\Tools\Scripts\golfing> 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 18, 38, 61, 81, 294, 349, 381, 383, 729, 767, 38183, 38383, 18349276, 183492761, 618349276 | %{.\numpad-knight-numbers.ps1 "$_"}
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True

PS C:\Tools\Scripts\golfing> 10, 11, 50, 53, 55, 65, 95, 100, 180, 182, 184, 185, 186, 187, 188, 189, 209, 305, 2009, 5030, 3838384, 4838383, 183492760 | %{.\numpad-knight-numbers.ps1 "$_"}
False
False
False
False
False
False
False
False
False
False
False
False
False
False
False
False
False
False
False
False
False
False
False

— AdmBorkBork
स्रोत

2

सी, 78 बाइट्स

char*a="9614397052";f(x){int b=x/10;return!b||abs(a[x%10]-a[b%10])%6==1&f(b);}

चूंकि हर किसी ने इनपुट को एक स्ट्रिंग के रूप में लिया है, इसलिए मैंने इसे पूर्णांक में करने की कोशिश की। यह कम से कम महत्वपूर्ण अंक ( a%10) से पुनरावर्ती कार्य करता है ; यदि यह एकमात्र अंक है, तो सही लौटें। अन्यथा, केवल तभी वापस लौटें जब दसियों अंक ( b%10) इकाइयों के अंक से नहीं पहुंचा जा सकता है, और (पुनरावर्ती रूप से), शेष इनपुट समान परीक्षण को संतुष्ट करता है।

रीचैबिलिटी के लिए परीक्षण नाइट के दौरे को रैखिक रूप से एन्कोडिंग करके और प्रत्येक अंक को दौरे पर उसकी स्थिति (शून्य से सात) में परिवर्तित करके काम करता है। अंकों के लिए 0और 5, हम स्थिति नौ को असाइन करते हैं, जिसे अन्य पदों से डिस्कनेक्ट किया गया है। फिर, पारस्परिक रूप से उपलब्ध संख्या एक (मॉड आठ) से भिन्न होती है; अर्थातa[x%10]-a[b%10] या तो ± 1 या ± 7 है। तो हम 1 के खिलाफ पूर्ण अंतर (मॉड 6) का परीक्षण करते हैं।

यह समाधान किसी भी वर्ण एन्कोडिंग के लिए काम करता है जो C के लिए मान्य है (यानी अंक में 0 से 9 तक सन्निहित कोड हैं)।

— टोबी स्पाईट
स्रोत

1

जावा 8, 179 167 बाइट्स

एक सर्कल में संख्या पैड ints (माइनस 5 और 0) रखें। lइन किलों का वृत्त सूचकांक रखता है। यदि दो सूचकांकों का अंतर +/- 3 mod 8 है, तो उन सूचकांकों के अनुरूप चींटियों के बीच एक शूरवीर चाल है। ध्यान दें कि xहै एक int[]।

x->{if(x.length<2)return 1;int[] l={0,0,1,2,7,0,3,6,5,4};int o=l[x[1]];for(int i:x){int n=l[i];if(i%5==0||(Math.abs(n-o)!=3&&Math.abs(n-o)!=5))return 0;o=n;}return 1;}

अद्यतन करें

-11 [16-12-10] एक लैम्ब्डा में स्विच किया गया
-1 [16-12-10] के <2बजाय का उपयोग करें==1

— NonlinearFruit
स्रोत

एक Numpad की नाइट नंबर

उदाहरण

जेली, 19 15 14 बाइट्स

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

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

रेटिना , Ret 40 बाइट्स

व्याख्या

पायथ - 35 28 बाइट्स

रूबी, 57 बाइट्स

grep 58 बाइट्स

हास्केल 46 बाइट्स

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

सी, 85 81 बाइट्स

MATL , 38 37 29 बाइट्स

05AB1E , 29 बाइट्स

MATL, 25 24 33 26 बाइट्स

सी, 140 92 बाइट्स

जूलिया, 51 49 बाइट्स

सत्यापन

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

PowerShell v2 +, 105 96 बाइट्स

टेस्ट रन

सी, 78 बाइट्स

जावा 8, 179 167 बाइट्स