जेनरेट कीबोर्ड फ्रेंडली नंबरों से प्रेरित ।

पृष्ठभूमि

कई नंबर पैड में निम्नलिखित लेआउट हैं:

789

456

123

0

हम संख्याओं के पड़ोस को परिभाषित करते हैं, क्योंकि यह अपने आप में दिखाए गए संख्यात्मक पर कोशिकाओं के समूह के रूप में होता है। उदाहरण के लिए, 2 का पड़ोस है {1,5,3,0,2}और 0 का पड़ोस है {1,2,0}। परीक्षण मामलों के नीचे, प्रत्येक संख्या के पड़ोस की एक सूची है।

हम एक संख्यात्मक अनुकूल संख्या को एक सकारात्मक पूर्णांक के रूप में परिभाषित करते हैं , जहां, जब प्रमुख शून्य के बिना दशमलव में लिखा जाता है, तो पहले को छोड़कर प्रत्येक अंक पिछले अंक के पड़ोस में होता है।

उदाहरण के लिए,

7856 एक संख्यात्मक अनुकूल संख्या है क्योंकि 8 7 के पड़ोस में है, 5 8 के पड़ोस में है, और 6 5 के पड़ोस में है।
1201 एक संख्यात्मक अनुकूल संख्या है क्योंकि 2 1 के पड़ोस में है, 0 2 के पड़ोस में है, और 1 0 के पड़ोस में है।
82 है नहीं एक numpad अनुकूल नंबर क्योंकि 2 से 8 के पड़ोस में नहीं है।
802 है नहीं एक numpad अनुकूल नंबर क्योंकि 0 के 8 (आस-पड़ोस के आसपास लपेट नहीं है) पड़ोस में नहीं है।

संबंधित OEIS अनुक्रम । ध्यान दें कि यह संबंधित अनुक्रम अलग है क्योंकि यह और के बजाय 0आसन्न के रूप में गिना जाता है ।712

चुनौती

एक सकारात्मक पूर्णांक को देखते हुए n, n-th या पहले nनंबरपैड के अनुकूल नंबर लौटाएं , जहां पहला है। आप 0-आधारित इंडेक्सिंग का उपयोग कर सकते हैं, जहां 0-वें नंबर के अनुकूल नंबर 1 होगा।

पड़ोस

प्रत्येक अंक का पड़ोस यहां सूचीबद्ध है:

0:{0,1,2}
1:{0,1,2,4}
2:{0,1,2,3,5}
3:{2,3,6}
4:{1,4,5,7}
5:{2,4,5,6,8}
6:{3,5,6,9}
7:{4,7,8}
8:{5,7,8,9}
9:{6,8,9}

परीक्षण मामले / अनुक्रम

ये पहले 100 पद हैं

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 20, 21, 22, 23, 25, 32, 33, 36, 41, 44, 45, 47, 52, 54, 55, 56, 58, 63, 65, 66, 69, 74, 77, 78, 85, 87, 88, 89, 96, 98, 99, 100, 101, 102, 110, 111, 112, 114, 120, 121, 122, 123, 125, 141, 144, 145, 147, 200, 201, 202, 210, 211, 212, 214, 220, 221, 222, 223, 225, 232, 233, 236, 252, 254, 255, 256, 258, 320, 321, 322, 323, 325, 332, 333, 336, 363, 365, 366, 369, 410, 411, 412, 414, 441, 444, 445, 447]

— fireflame241
स्रोत

5

मुझे पसंद है कि यह चुनौती केवल सकारात्मक पूर्णांक कैसे मानती है (जो सार रखता है और अधिक भाषाओं को भाग लेने की अनुमति देता है) और लचीलेपन के लिए या तो n -th या पहले n आउटपुट प्रदर्शित करने की अनुमति देता है

— लुइस मेंडू

मैंने चुनौती को पूरी तरह से गलत किया है, यहां "यह अनुक्रम में मान्य शब्द है" स्क्रिप्ट: इसे ऑनलाइन आज़माएं!

— मैजिक ऑक्टोपस यूरेन

9

जावास्क्रिप्ट (ईएस 6), 104 93 89 88 बाइट्स

अनुक्रम के एन-वें शब्द को लौटाता है, 1-अनुक्रमित।

f=(i,k,n=k,N=n/5>>1)=>(N?8530025>>(n%10*6191^N%10*6191)%26&1:!i--)?N?f(i,k,N):k:f(i,-~k)

डेमो

कोड स्निपेट दिखाएं

f=(i,k,n=k,N=n/5>>1)=>(N?8530025>>(n%10*6191^N%10*6191)%26&1:!i--)?N?f(i,k,N):k:f(i,-~k)

for(n = 1; n <= 50; n++) {
  console.log('a(' + n + ') = ' + f(n))
}

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

— Arnauld
स्रोत

सबसे अच्छा मुझे मिल सकता है 151

k=(n,a=1)=>n?k(n-([...(x=a+[]).slice(0,-1)].reduce((a,c)=>a*!!~"012 0124 01235 236 1457 24568 3569 478 5789 689".split` `[c].indexOf(x[i++]),i=1)),a+1):a-1

शायद वहाँ कुछ मदद करता है, मेरा परीक्षण शायद बहुत लंबा है

— कॉनर ओ'ब्रायन

यह उत्तर जादू की संख्या की अवधारणा को एक नए स्तर पर लाता है ... मुझे यह भी समझ में नहीं आता है कि आपने उन्हें कैसे

— ओ_ओ

2

@scottinet काफी हद तक, इस उत्तर के लिए मेरा स्पष्टीकरण इस पर भी लागू होता है। पूर्ण अंतर उस एक पर बहुत अच्छी तरह से काम नहीं करता था, इसलिए मैंने इसके बजाय XOR के साथ प्रयास किया। एक साइड नोट के रूप में, मुझे एक और सूत्र मिला, जिसने 96% मामलों में लुकअप बिटकॉम्ब की आवश्यकता के बिना काम किया। लेकिन शेष 4% को अलग से संसाधित करना JS में बहुत महंगा था। मैंने जेली में कोशिश नहीं की , और अब मुझे वैसे भी फॉर्मूला याद नहीं है ... (\ _ (in) _ / ul

— Arnauld

स्पष्टीकरण के लिए धन्यवाद। यह अभी भी प्रभावशाली है :-)

— scottinet

4

पर्ल ५ , 123 + 1 (-पी) = 124 बाइट्स

while($_){$r=@d=++$\=~/./g;map$r&&=(120,1240,12350,236,1457,24568,3569,478,5789,689)[$d[$_-1]]=~/$d[$_]/,1..$#d;$r&&$_--}}{

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

— Xcali
स्रोत

3

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

अनुक्रम के एन पहले शब्द देता है।

D⁽ÞȦ×^2\%26“⁷wð’æ»ḂẠ
1Ç#

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

यह मेरे जेएस जवाब का एक बंदरगाह है ।

D⁽ÞȦ×^2\%26“⁷wð’æ»ḂẠ    - helper link: test numpad-friendliness of a number, e.g. 1257
D                       - get decimal digits             -> [1, 2, 5, 7]
    ×                   - multiply by ...
 ⁽ÞȦ                    - ... the integer 6191           -> [6191, 12382, 30955, 43337]
     ^2\                - bitwise XOR overlapping reduce -> [10353, 18613, 53666]
        %26             - modulo 26                      -> [5, 23, 2]
                æ»      - right-shift by each value ...
           “⁷wð’        - ... the integer 8530025        -> [266563, 1, 2132506]
                  Ḃ     - isolate the LSB                -> [1, 1, 0] which means that 1->2
                                                            and 2->5 are OK and 5->7 is not
                   Ạ    - all (0 if there's any 0)       -> 0, i.e. not numpad-friendly :'(

1Ç#                     - main link: return the [input] first matching numbers,
                          using our helper link as a monad and starting with 1

— Arnauld
स्रोत

3

05AB1E , 24 23 बाइट्स

µNSü‚εW_iO<ë<3BÆ}ÄR2‹}P

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

अनुक्रम में nth नंबर देता है।

स्पष्टीकरण:

µNSü‚εW_iO<ë<3BÆ}ÄR2‹}P    Full program
µ                          Until counter is equal to input
 N                         Push current iteration number (e.g. 1025)
  S                        Split to a list of chars (-> ['1', '0', '2', '5'])
   ü‚                      Group into pairs (-> ['1', '0'], ['0', '2'], ['2', '5'])
     ε                     For each pair
      W_                      Is smallest digit equal to 0?
        iO<                      True: sum all digits and decrement 
           ë                     False: 
            <                       - decrement all digits
             3B                     - convert to base 3
               Æ                    - reduced substraction
                }             End if
                 Ä            Absolute value
                  R           Reverse 
                   2‹         1 if result is < 2, 0 otherwise
                     }     End for each
                      P    Cumulative product (1 if all pair results are 
                                     1, 0 otherwise)
                           -- implicit counter increment if stack value is 1

मुख्य विचार यह है कि, 0कुंजी के अलावा , किसी भी अंक को घटाया और आधार 3 में परिवर्तित किया गया है, निम्नलिखित गुण हैं:

बाएं और दाएं पड़ोसियों में 1 का पूर्ण अंतर है
ऊपर और नीचे के पड़ोसियों में 10 का पूर्ण अंतर होता है, जो उलटा होता है, यह आसानी से 1 के बराबर होता है
किसी भी अन्य जोड़ी कीपैड की चाबियाँ अलग-अलग मूल्यों में परिणामित होती हैं, यहां तक कि उलट होने पर भी

बेशक, हमें सुमेल कुंजी ifको संभालने के लिए एक बयान की आवश्यकता है 0।

— scottinet
स्रोत

ठोस जवाब, अधिक सुधार की पेशकश करने के लिए आया था, कोई भी नहीं मिल सकता है। Oooo ... और उस जोड़ी ने आपको भी लीड में रखा :)।

— मैजिक ऑक्टोपस यूरन

मुझे नहीं लगता कि मैं उन 3 नियमों के साथ आ सका हूं, जो कि बहुत प्रभावशाली हैं; आपने क्या विचार दिया?

— मैजिक ऑक्टोपस यूरिन

2

MATL , 29 27 बाइट्स

`@J3:qEt!J*+hYAd|2>~A?@]NG-

पहले nनंबरपैड के अनुकूल नंबर आउटपुट करता है ।

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

व्याख्या

से प्रत्येक अंक 1के लिए9स्टेप -2 ग्रिड में, जहां वास्तविक भाग ऊर्ध्वाधर स्थिति का प्रतिनिधित्व करता है और काल्पनिक भाग क्षैतिज स्थिति का प्रतिनिधित्व करता है, को अंकपैड में अपनी स्थिति का प्रतिनिधित्व करने वाली एक जटिल संख्या के रूप में एन्कोड किया है। तो 1है 0+0j, 2है 0+2j, 3है 0+4j, 4है 2+0j, ..., 9है4+4j ।

अंकों 0के रूप में एन्कोड किया गया है 0+1jयानी, जैसे कि यह के बीच वास्तव में रखा गया था 1और2 ।

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

कोड एक do... whileलूप का उपयोग करता है , जो तब बाहर निकलता है जब स्टैक में संख्याओं की मात्रा इनपुट के बराबर होती हैn ।

एक यूनिट ग्रिड एक अधिक प्राकृतिक विकल्प होता। अंक 1, 2और 0उसके बाद के अनुरूप होगा 0+0j, 1+0jऔर 0.5+0jrespecrively। लेकिन यह एक चरण -2 ग्रिड का उपयोग करने के लिए गोल्फर है, क्योंकि 2(फ़ंक्शन E) से गुणा करना और धक्का देना 0+1j(फ़ंक्शन J) एक बाइट से धक्का होता है 0+0.5j(J2/ या .5j)

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

2

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

’d-,.⁸?3µ€ạ/S
Dṡ2Ç€<2Ạ
1Ç#

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

-2 बाइट्स के लिए धन्यवाद caird coinheringaahing
-2 बाइट्स के लिए धन्यवाद एग्री द आउटग्रॉफ़र

व्याख्या

’d-,.⁸?3µ€ạ/S  Helper Link; compute the distance between two keys z = [x, y]
      ?        Switch:
     ⁸         If z (is not 0):
’              Decrement
 d             Divmod by:
  -,.          Else: [-1, 0.5] (special position for 0)
       3       3; right argument for divmod otherwise ignored
        µ      Begin a new monadic link / end this link
         €     Compute the position for each [x, y]
           /   Reduce on
          ạ    Absolute Difference
            S  Sum (this gives the Manhattan Distance)
Dṡ2Ç€<2Ạ       Helper Link; determine if a number <z> is numpad friendly
D              Convert number to decimal digits
 ṡ             Slice into overlapping slices of length
  2            2 (pairs)
    €          For each pair,
   Ç           The distance between the keys
     <2        Compare with 2 (the distance between two adjacent keys is 1; corners 2; 0 - 1 and 0 - 2 are 1.5)
       Ạ       All; either all of the distances are less than 2 or there were no distances
1Ç#            Main Link; find the first (input) numpad friendly numbers
  #            nfind; counting up from _ collect the first _______ matches that are
1                                      1
                                                           (input)
 Ç             Numpad Friendly

— HyperNeutrino
स्रोत

आप []2 बाइट्स के लिए निकाल सकते हैं

— caird coinheringaahing

@cairdcoinheringaahing धन्यवाद!

— HyperNeutrino

1

गोल्फ एक युगल बंद।

— आउटगॉल्फ

2

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

g=lambda n,k=1:n and g(n-(lambda l:all(abs(a-b)<1.2for a,b in zip(l,l[1:])))([~-d%3+~-d/3*1j-d/~d*1.5for d in map(int,`k`)]),k+1)or~-k

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

— लिन
स्रोत

जैसा कि आप परिभाषित करते हैं fऔर फिर एक बार इसका उपयोग करते हैं , आप इसे इनलाइन कर सकते हैं और दो बाइट्स बचा सकते हैं ।

— जोनाथन फ्रेच

1

गणितज्ञ, 249 234 202 बाइट्स

(a=o=1;While[a<=#,s=IntegerDigits@o;t=1;p=0;While[t+p<Length@s,If[!FreeQ[(IntegerDigits/@{210,4210,53210,632,7541,86542,9653,874,9875,986})[[s[[t]]+1]],s[[t+1]]],t++,p++]];If[t==Length@s,a++];o++];o-1)&

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

डेटा (-32 बाइट्स) को संपीड़ित करने के लिए धन्यवाद उपयोगकर्ता 202729

मेरे परिणाम:

100 -> 447
1000
-> 20023 10000 -> 788777

— J42161217
स्रोत

मुझे लगता है कि आप डेटा का उपयोग करके संपीड़ित कर सकते हैं IntegerDigits: IntegerDigits/@{210,4210,53210,632,7541,86542,9653,874,9875,986}और FreeQ, के बजाय का Trउपयोग करें , का उपयोग करें , बार-बार दोहराने के बजाय का उपयोग करने के लिए infix संकेतन का उपयोग करें और चर को भी समाप्त करें । इसके अलावा आपने यह साबित नहीं किया है कि एल्गोरिथ्म सही है, अर्थात् परिणामी संख्या हमेशा इसके सूचकांक के वर्ग से कम है, जो एक उत्तर को वैध बनाने के लिए आवश्यक है। DoForAppendToDoWhileTr[1^s]p

— user202729

1

@ user202729 मैंने बहुत सारी चीज़ें बदलीं। मेरा जवाब निश्चित रूप से मान्य है। मैं अब डेटा को कंप्रेस करूंगा।

— J42161217

डाउनवोट क्यों?

— J42161217

1

PHP, 124 + 1 बाइट्स

while($argn-=$r)for($p=$r=~0,$x=++$n;$x>=1;$p=[7,23,47,76,178,372,616,400,928,832][$c],$x/=10)$r&=!!($p&1<<$c=$x%10);echo$n;

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

— टाइटस
स्रोत

0

जावा 8, 192 190 बाइट्स

n->{int r=1,p;a:for(;n>0;){p=-1;for(int c:(r+++"").getBytes())if(p>-1&!"012;0124;01235;236;1457;24568;3568;478;5789;689".split(";")[c-=48].contains(p+""))continue a;else p=c;n--;}return~-r;}

लौटाता है (1-अनुक्रमित) nअनुक्रम में वें नंबर देता है।

यह आश्चर्यजनक रूप से कठिन था जितना मैंने सोचा था .. शायद आज दोपहर को केवल कुछ मस्तिष्क-मस्तिष्क हो रहा है ..

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

n->{                 // Method with integer as both parameter and return-type
  int r=1,           //  Return-integer
      p;             //  Previous digit
  a:for(;n>0;){      //  Loop (1) as long as the input is larger than 0
    p=-1;            //   Start `p` at an integer that is not 0-9 (-1 in this case)
    for(int c:(r+++"").getBytes())
                     //   Loop (2) over the digits of the current number
      if(p>=0        //    If this is not the first digit (`p` != -1),
         &!"012;0124;01235;236;1457;24568;3568;478;5789;689".split(";")[c-=48]
           .contains(p+""))
                     //    and the adjacent digits are NOT part of a NumberPad-Friendly Nr:
        continue a;  //     Go to the next iteration of loop (1)
      else           //    Else:
        p=c;         //     Set `p` to the current digit for the next iteration
                     //   End of loop (2) (implicit / single-line body)
      n--;           //   If we haven't encountered the `continue`, decrease `n` by 1
  }                  //  End of loop (1)
  return~-r;         //  Return the result-integer - 1
}                    // End of method

— केविन क्रूज़सेन
स्रोत

Numpad के अनुकूल नंबर उत्पन्न करें

पृष्ठभूमि

चुनौती

पड़ोस

परीक्षण मामले / अनुक्रम

जावास्क्रिप्ट (ईएस 6), 104 93 89 88 बाइट्स

डेमो

पर्ल ५ , 123 + 1 (-पी) = 124 बाइट्स

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

05AB1E , 24 23 बाइट्स

MATL , 29 27 बाइट्स

व्याख्या

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

व्याख्या

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

गणितज्ञ, 249 234 202 बाइट्स

PHP, 124 + 1 बाइट्स

जावा 8, 192 190 बाइट्स