50,000 के तहत स्नैकिंग संख्याओं की सूची बनाएं

24

स्नैकिंग नंबर चैलेंज

मुझे आश्चर्य है कि 1 और 50,000 के बीच कितने स्नैकिंग नंबर हैं?

एक नोकिया पर सांप

स्नैकिंग नंबर, इस गेम में, वे नंबर होते हैं जिन्हें एक नंबर, नीचे, बाएं या दाएं की ओर ले जाकर पारंपरिक नंबरपैड (नीचे प्रारूप) पर टाइप किया जा सकता है।

7 8 9
4 5 6
1 2 3
 0

उदाहरण के लिए, यदि आप संख्या 5 से शुरू करते हैं, तो आप अपनी अगली वैध चाल के रूप में 4, 6, 8, या 2 का चयन कर सकते हैं - हालांकि 7, 3, 9 और 1 ऑफ-लिमिट हैं क्योंकि वे वर्तमान कुंजी के लिए तिरछे स्थान पर स्थित हैं। । तो, यदि आपके पास 5 है, तो 2, आपकी अगली व्यवहार्य कुंजी विकल्प 0, 1, 3 या 5 फिर से हैं।

इस कोड गोल्फ अभ्यास में, आप मानदंड को पूरा करने वाले सभी नंबरों की अंतिम गणना के साथ, 1 और 50k के बीच सभी सकारात्मक स्नैकिंग नंबरों की एक सूची का उत्पादन करने के लिए हैं।

नियम

  1. संख्याएं शून्य से शुरू नहीं हो सकती हैं।
  2. संख्या पूरे सकारात्मक पूर्णांक होनी चाहिए।
  3. प्रत्येक लगातार संख्या, बाएं से दाएं पढ़ने के लिए, नंबरपैड के चारों ओर "सांप" होना चाहिए।
  4. साँप कुंजियों में तिरछे नहीं घूम सकता
  5. नंबर 1 को 1 और 2 नंबर दोनों से एक्सेस किया जा सकता है
  6. संख्याओं को जोड़ा नहीं जा सकता (उदाहरण के लिए: 22)

मान्य स्नैकिंग नंबरों के उदाहरण:

12369
45201
1254
10102
1
12
987

अमान्य नंबरों के उदाहरण

1238 - 8 is not connected
0001 - multiple leading 0s
0101 - leading 0
159  - snake cannot travel diagonally
4556 - duplicate 5

सामान्य कोड गोल्फ के अनुसार, उद्देश्य सबसे कम बाइट्स है!

मेरे गणित और नियमों के अनुसार, आपकी सूची में 670 मान्य स्नैकिंग नंबर होने चाहिए, साथ ही 670 अंतिम संख्या के रूप में मुद्रित होने चाहिए।

code-golf 
— MightBeAlon
स्रोत
2
क्या आउटपुट को सॉर्ट किया जाना चाहिए? या किसी भी क्रम में इसकी अनुमति है?
— tsh
2
यह देखते हुए कि आप हमसे पूर्णांक के एक निश्चित और सीमित सेट का उत्पादन करने के लिए कह रहे हैं, मैं सुझाव देता हूं कि कल्पना में पूरी सूची शामिल है।
— झबरा
— अरनौल
4
यह A215009 का सबसेट है ।
— बिगइहुस्सान
क्या पहले 670 प्रिंट करना ठीक होगा ?
— दाना

जवाबों:

14

के (ngn / k) , 60 57 बाइट्स

(x;#x:{*/1=3!5&+/x*x:+1_-':(+0 1,'2*!3 3)@10\x}#1+!50000)

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

!50000की सूची 0।।49999

1+ सभी को 1 जोड़ें

{ }# में फ़ंक्शन के साथ फ़िल्टर करें { }

10\x तर्क के दशमलव अंक

( )@ में सूचकांक के रूप में उपयोग करें ...

  • !3 3 सूचियों की एक जोड़ी: (0 0 0 1 1 1 2 2 2;0 1 2 0 1 2 0 1 2)

  • 2* सभी को 2 से गुणा करें

  • 0 1,'पहले जोड़ें 0पहली सूची के लिए और 1दूसरा

  • +स्थानान्तरण (सूचियों की जोड़ी -> जोड़ियों की सूची)। यह हमें लगभग बटन कोऑर्डर्स देता है।

-':प्रत्येक जोड़ी को पिछली जोड़ी से घटाएं। 0 0पहले एक काल्पनिक तत्व के रूप में उपयोग करें ।

1_ पहले छोड़ दो

+ पक्षांतरित

x*x:वर्ग (असाइन करें xऔर गुणा करें x)। यहाँ xसूचियों की एक जोड़ी है - listsxs और listsys

+/ दो सूचियों का योग (तत्व द्वारा तत्व)

5& 5 के साथ मिनट

3! mod ३

1= बूलियन सूची जहां यह 1 के बराबर है

*/ उत्पाद (बूलियन "और")

(x;#x: )परिणाम और लंबाई ( #) के परिणाम की एक जोड़ी बनाते हैं

— NGN
स्रोत
9

जेली ,  24  23 बाइट्स

5ȷ4µDo1.’d3ZIASĊ’ẸµÐḟṄL

एक पूर्ण कार्यक्रम जो सभी परिणामों की एक सूची प्रिंट करता है और फिर परिणामों की संख्या।

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

कैसे?

5ȷ4µDo1.’d3ZIASĊ’ẸµÐḟṄL - Main Link: no arguments
5ȷ4                     - 5*10^4 = 50000
   µ              µÐḟ   - filter discard those for which this is truthy:
                        -                  e.g.: 8520        ... or           4559 
    D                   -   decimal digits       [8,5,2,0]                    [4,5,5,9]
      1.                -   literal 1.5
     o                  -   logical OR           [8,5,2,1.5]                  [4,5,5,9]
        ’               -   decrement            [7,4,1,0.5]                  [3,4,4,8]
         d3             -   div-mod by 3         [[2,1],[1,1],[0,1],[0,0.5]]  [[1,0],[1,1],[1,1],[2,2]]
           Z            -   transpose            [[2,1,0,0],[1,1,1,0.5]]      [[1,1,1,2],[0,1,1,2]]
            I           -   deltas               [[-1,-1,0],[0,0,-0.5]]       [[0,0,1],[1,0,1]]
             A          -   absolute value       [[1,1,0],[0,0,0.5]]          [[0,0,1],[1,0,1]]
              S         -   sum (vectorises)     [1,1,0.5]                    [1,0,2]
               Ċ        -   ceiling              [1,1,1]                      [1,0,2]
                ’       -   decrement            [0,0,0]                      [0,-1,1]
                 Ẹ      -   any?                 0 (i.e. keep)                1 (i.e. discard)
                     Ṅ  - print and yield
                      L - length
                        - implicit print
— जोनाथन एलन
स्रोत
मुझे यह जानकर अच्छा लगेगा कि यह कैसे काम करता है। कोई भी मौका आप एक ब्रेकडाउन दे सकते हैं?
— mayBeAlon
1
@MightBeAlon बाद में करेगा ...
— जोनाथन एलन
मैं उत्सुक हूं, कैसे 1.मूल्यांकन करता है 1.5?
— इग्नोरेंस
@EmbodimentofIgnorance शाब्दिक अवधि के दौरान एक लापता अंक को पार्स करने के दौरान पांच के रूप में माना जाता है। इंटरप्रेटरहोम में parse_literal का अंतिम क्लॉज
— जोनाथन एलन
7

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

f=lambda s:''==s[1:]or s[1]in'10021234562216565878 43 749 9   5  8'[int(s[0])::10]and f(s[1:])
print(*filter(f,map(str,range(1,50000))),670)

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

मैं सकारात्मक हूं कि कोई व्यक्ति लुकअप स्ट्रिंग के बजाय अभिव्यक्ति के साथ ऐसा कर पाएगा।

— Jitse
स्रोत
7

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

print[n for n in range(1,50000)if all(`n`[i:i+2]in`0x20b33ec8bc49a10589e76b15`for i in range(4))],670

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

हेक्स संख्या दशमलव है 10120214525632365878969854741, जो प्रत्येक क्रमबद्ध जोड़ी अंकों को एन्कोड करता है जो एक दूसरे से सटे दिखाई दे सकते हैं।

— नकारात्मक सात
स्रोत
5

जावास्क्रिप्ट (V8) ,  112 106  104 बाइट्स

2 बाइट @NahuelFouilleul के लिए धन्यवाद बचा लिया

एक पूरा कार्यक्रम।

for(n=0;++n<5e4;)[...n+''].every(x=>'6589632145201478'.match(x+p+'|'+p+(p=x)),p='')&&print(n)
print(670)

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

या 96 बाइट्स अगर हम रिवर्स ऑर्डर में संख्याओं को आउटपुट कर सकते हैं:

for(n=5e4;n--;)[...n+''].every(x=>'6589632145201478'.match(x+p+'|'+p+(p=x)),p='')&&print(n||670)

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

— Arnauld
स्रोत
काम भी आखिरी हटाने 3शायद क्योंकि 36स्ट्रिंग में पहले से ही है
— नाहुएल Fouilleul
@NahuelFouilleul अच्छा कैच। धन्यवाद!
— अरनुलद
1
यह भी 6589632145201478एक बाइट छोटी है
— नाहुएल फूइउल
4

स्टैक्स , 37 35 बाइट्स

ü╞╡~▄ⁿ♪eµïê◙ü╔ï▼ΔJr¥æ≤PH╟♀I♣Δz8─¶Γ╞Ç▓

भागो और इसे staxlang.xyz पर डीबग करें!

यह बहुत अच्छा और छोटा था, जब तक कि यह नहीं था।

अनपैक्ड (42 बाइट्स) और स्पष्टीकरण

49999{E2B{{om"#qYY>!(AFI"%A|E2B{{om-C_Qf%p
49999{                                 f      Filter range [1..49999]:
      E2B                                       All adjacent pairs of digits
         {{om                                   Each sorted
             "#qYY>!(AFI"%A|                    Literal 2012365478963258741
                            E2B{{om             Pairs of digits, each sorted
                                   -            Set difference
                                    C           Cancel block execution if any remain
                                     _Q         Print current value
                                        %p    Print length

2012365478963258741 कीपैड को एन्कोड करता है। आसन्न अंकों के जोड़े देखें। शायद अगर मुझे एक शालीन विकल्प मिल सकता है जो प्रत्येक जोड़ी के लिए दोनों दिशाओं में जाता है, तो मैं आठ बाइट्स काट सकता हूं{{om ।

उस 670 के पीछे के बिना, एक साधारण फ़िल्टर पर्याप्त होगा: के f..!बजाय {..C_Qf%p। इस अनियमितता को संभालने के लिए एक बेहतर तरीका हो सकता है। किसी भी स्थिति में, फ़िल्टर-श्रेणी का यह व्यवहार अनिर्दिष्ट है।

— खुल्द्रेसथ न’बैरी
स्रोत
प्रलेखन अंतराल के बारे में क्षमा करें। FWIW, कि एक अगली रिलीज में होगा, 1.1.7। आप stax.tomtheisen.com पर एक पूर्वावलोकन देख सकते हैं , लेकिन यह एक रहस्य है इसलिए किसी को भी न बताएं। ;)
— पुनरावर्ती
3

PHP , 145 बाइट्स

for(;$i++<5e4;$f&&print$i._)for($f=1,$l=b;''<$d=("$i")[$$i++];$l=$d)$f&=$l>a||strstr([12,240,1053,26,157,2468,359,48,579,68][$l],$d)>'';echo 670;

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

1 से 50,000 तक की प्रत्येक संख्या के लिए, उस संख्या के प्रत्येक अंक को बाएं से दाएं की जाँच करता है। यदि सभी अंक पिछले अंक के मान्य अंकों की सूची में हैं, तो वह संख्या मुद्रित है। अंत में एक कठिन कोडित 670 प्रिंट करता है क्योंकि यह वास्तव में इसे गिनने की तुलना में कम बाइट लेता है।

— Night2
स्रोत
3

05AB1E , 23 बाइट्स

ŽÅKLʒSÌYX;:3‰üαï€OP}=g=

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

पोर्ट ऑफ जोनाथन एलन के जेली उत्तर ।

— ग्रिमी
स्रोत
1
आह, सिर्फ 3 बाइट्स में 50000 को संपीड़ित करने का स्मार्ट। मैं उपयोग कर रहा था ₄50*या 4°5*जब मैं पहले प्रयास कर रहा था। और पहले मैं उलझन में था कि आपके पास €OPसिर्फ इसके बजाय क्यों था OP, लेकिन फिर मुझे एकल अंकों की संख्या का एहसास हुआ (इसके बाद एक खाली सूची होने के üα) फिर [] → 0 → 0इसके बजाय होगा [] → [] → 1। :)
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन 4°5*आप क्यों कर सकते हैं 5°;? मुझे ZAK बेहतर लगता है। और हाँ, एकल-अंकीय संख्याओं के लिए यह धार-केस एक दर्द है।
— ग्रिमी
3

पर्ल 5 ( -M5.01), 96 , 92 बाइट्स

-4 बाइट्स @ @ धन्यवाद के लिए धन्यवाद

$r=join"|",map$t++."[^$_]",12,240,1350,26,157,2648,359,48,579,68;map/$r/||say,1..5e4;say 670

TIO

— नहुएल फौलीउल
स्रोत
92
— Xcali
धन्यवाद वास्तव में, अति-जटिल क्योंकि पहला उत्तर सकारात्मक मैच था
— नाहुएल फौइलुल
3

जावास्क्रिप्ट (स्पाइडरमैन) , 179 173 151 129 बाइट्स

[12,240,1350,26,157,2468,359,48,579,68].map((_,i,l)=>i&&(f=(v,t)=>print(v)|v<5e3&&[...l[t]+''].map(k=>f(v+k,k)))(i,i)),print(670)

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

-22 बाइट्स धन्यवाद अर्नुलद -22 बाइट्स डाना के लिए धन्यवाद

स्पष्टीकरण:

[12,240,1350,26,157,2468,359,48,579,68] 
// an array where keys are current position and values, the possible destinations
.map((_,i,l)=>                    // loop over it
    i&&(                          // if key is not 0
        f=(v,t)=>                 // create a function
                 print(v)|        // which print the value
                          v<5e3&& // and if the limit is not attained
                                 [...l[t]+''].map(k=>f(v+k,k)) 
                    // recurcively call itself with for each destinations
                                                              )(i,i)),
                    // make the first call with each digit
print(670) // finally print 670

@ डडाना ने 123 बाइट्स का घोल भी दिया यदि हम पहले 670 प्रिंट कर सकते हैं

[21,420,5310,62,751,8642,953,84,975,86].map((_,i,a)=>(f=(v,t)=>print(i?v:640)|i&v<5e3&&[...a[t]+''].map(k=>f(v+k,k)))(i,i))
— jonatjano
स्रोत
@Arnauld धन्यवाद मैं इस नियम को भूल गया
— jonatjano
— Arnauld
129 ?
— दाना
123 यदि 640 पहले मुद्रित किया जा सकता है।
— दाना
2

स्टैक्स , 28 26 बाइट्स

Δh┤♣É╦&·é╝n$K»à¶▲v═NÆ;↨m≥8

इसे चलाएं और डीबग करें

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह ऐसा दिखता है।

G               Call to unbalanced trailing '}', then resume here
670P            Print 670
}               Call target
219J            219 squared (47961)
f               Filter 1-based range by the rest of the program; implicitly output
  $2B           Convert to string and get adjacent pairs; e.g. 213 -> ["21", "13"]
  O             Push 1 under list of pairs
  F             Iterate over pairs, using the rest of the program
    o           Order each pair; e.g. "21" -> "12"
    "{<f:[/T8Z" string literal with code points [123 60 102 58 91 47 84 56 90]
    $           concate as string i.e. "12360102589147845690"
    s#          How many times does the current pair appear in the constant string?
    *           Multiply this by running total.  Any zero will cause the result to be zero.

इसको चलाओ

गुप्त सॉस स्ट्रिंग शाब्दिक में है "{<f:[/T8Z"। एक साथ सभी कोडपॉइंट्स को जाम करने के बाद, आपको मिलता है 12360102589147845690। इस स्ट्रिंग में आरोही जोड़े वैध साँप चाल हैं।

— पुनरावर्ती
स्रोत
1
15JJके बजाय के 219Jरूप में अच्छी तरह से काम करेगा, लेकिन मुझे नहीं लगता कि आप वहाँ से किसी भी बाइट को गोल्फ कर सकते हैं जब तक कि वहाँ के लिए 1-बाइट स्थिर न हो 15।
— अरनौल
2

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

(filter(and.(zipWith elem.tail<*>map f).show)[1..50000],670)
f c=words"12 024 0135 26 157 2468 359 48 579 68"!!read[c]

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

एक पहला पास; मैं कम्प्रेशन में अच्छा नहीं हूँ।

s=गिनती नहीं करता, क्योंकि हम वास्तव में परिणाम बाध्य करने की जरूरत नहीं है।

अघोषित कोड ।

— गोभी
स्रोत
1

चारकोल , 42 बाइट्स

≔ΦＩ…·¹×⁵⁰φ⬤ι№”)¶∧XRτ_ΠＧêＲ⁵m⎇λ”✂ιμ⁺²μ¹θθＩＬθ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

≔ΦＩ…·¹×⁵⁰φ

से समावेशी रेंज प्रक्रिया 1को 50,000स्ट्रिंग के लिए डाली।

⬤ι№”)¶∧XRτ_ΠＧêＲ⁵m⎇λ”✂ιμ⁺²μ¹θ

उन लोगों को फ़िल्टर करें जिनके पास संपीड़ित स्ट्रिंग में अंकों के जोड़े नहीं हैं 01478963202125458565236987410।

θＩＬθ

शेष सरणी और इसकी लंबाई को आउटपुट करें।

— नील
स्रोत
1

पर्ल 6 , 64 बाइट्स

{670,grep {[+&](:36<12HGX91H8VCL3MG0FDVQ>X+>m:ov/../)%2},1..5e4}

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

व्याख्या

{670,grep {...},1..5e4}  # Meet questionable output requirements

# Actual decision problem

     :36<12HGX91H8VCL3MG0FDVQ>  # Bit field of allowed transitions
                                # encoded in base 36
                                 m:ov/../  # All 2-digit substrings
                              X+>  # Right shift by each substring
                                   # (implicitly converted to an integer)
[+&](                                    )  # Binary and
                                          %2  # Modulo 2
— nwellnhof
स्रोत
यह अफ़सोस की ~>बात नहीं है, अन्यथा आप इसे केवल स्ट्रिंग ऑपरेटरों के साथ करने में सक्षम हो सकते हैं, साथ ही बिट क्षेत्र एक स्ट्रिंग है
— Jo King
1

पायथ , 68 65 45 बाइट्स

l
f.Am}dCtB+J`65874589632012541_PJCtB`TS50000

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

संशोधित लुकअप प्रक्रिया के लिए प्रेरणा खुल्द्रेसेथ न'बर्या के स्टैक्स जवाब से आई , उन्हें एक अपोटेट दें!

संपादित करें 2: बाइट्स, पिछले संस्करण का एक गुच्छा बचाने के लिए फिर से लिखना: 

l
f.Am}ed@c"12 024 0135 26 157 2468 359 48 579 68";shdCtB`TS50000

संपादित करें: स्ट्रिंग लुक्स का उपयोग करके 3 बाइट्स, पिछला संस्करण:

l
f.Am}ed@sMMc"12 024 0135 26 157 2468 359 48 579 68";hdCtBjT;S50000
— सोक
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.