चले जाओ! नहीं -1 का यहाँ!

16

मैं कुछ नंबरों के साथ खेल रहा था और मुझे एक अनुक्रम मिला, जो निश्चित रूप से OEIS पर है। यह A005823 है : जिन संख्याओं के मध्य विस्तार में कोई 1 नहीं है । यह जाता है:

a (2n) = 3 * a (n) +2

a (2n + 1) = 3 * a (n + 1)

a (1) = 0

a = 0,2,6,8,18,20,24,26,54 ...।

मैंने एक सीजेएम प्रोग्राम लिखा था जो इन नंबरों के पहले एन को बाइनरी में परिवर्तित करके, 1 के 2 के साथ 1 की जगह, और टर्नेरी से दशमलव में परिवर्तित करके लिखता है।

मैंने यह भी देखा कि अनुक्रम में कभी-कभी दो संख्याओं के योग को प्राप्त करके कोई भी संख्या प्राप्त की जा सकती है।

चुनौती:

इनपुट के रूप में किसी भी गैर-नकारात्मक सम संख्या को देखते हुए, इस क्रम में दो संख्याओं के सूचकांकों का उत्पादन करें। (ध्यान दें कि कभी-कभी कई जोड़े संभव हैं।)

नियम:

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

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

मैं 0-इंडेक्सिंग का उपयोग करता हूं। यहां मैं प्रत्येक इनपुट के लिए हर संभव आउटपुट को सूचीबद्ध करता हूं, लेकिन आपको केवल एक आउटपुट की आवश्यकता है।

०:       [० ०]
 २:       [१ ०]
 ४:       [१ १]
 ६:       [२ ०]
       [ : 3 [२ १] [३ ०]
 १०:      [३ १]
 १२:      [२ २]
 १४:      [३ 2]
 16:      [3 3]
 18:      [4 0]
 30:      [6 2]
 32:      [6 3] [7 2]
 46:      [7 5]
 50:      [7 6]
 120:     [10 10]
 338:     [१ ९ १
     31]     ४२ 19 : [३० २३] [३१ २२] [१२
 : [३३ २ 35] [३५ २५] [४१ १ ९] [४३ १]] [४ ९ ११] [५१ ९] [५ 3 ३] [५ ९ १]
 १०१६:    [३ [३ 39] [३ ९ ३६]
टेस्ट केस की मदद के लिए @Luis मेंडू को धन्यवाद।

संबंधित: क्या यह कैंटर के भीतर है?

code-golf  sequence  base-conversion 
— geokavel
स्रोत
क्या हम दो मानों की एक जटिल संख्या का उत्पादन कर सकते हैं? क्या हम दो कार्य प्रदान कर सकते हैं, प्रत्येक एक मूल्य दे रहा है?
— xnor
2
क्या हम सभी संभव मूल्यों का उत्पादन कर सकते हैं, या यह चुनौती से परे है?
— कोल
@cole हाँ, यह ठीक है।
— geokavel
ऐसा लगता है कि श्री स्लोअन वास्तव में अपने नंबर दृश्यों को पसंद करते हैं। "उस के लिए एक सीक्वेंस है" (TM)
— फराप
1
चूंकि कुछ इनपुट के लिए कई समाधान हैं, इसलिए सभी समाधानों को परीक्षण मामलों में शामिल करना अच्छा होगा। यह कार्यक्रम प्रत्येक परीक्षण मामले के लिए सभी समाधान जोड़े दिखाता है, एक ही प्रारूप में चुनौती पाठ (0-आधारित, प्रत्येक जोड़ी को तेजी से हल किया गया) के रूप में
— लुइस मेंडू

जवाबों:

10

भूसी , 21 14 13 बाइट्स

-7 बाइट्स, @ नील के जेएस जवाब के लिए धन्यवाद

-1 बाइट बीटावर्ट्स के पैरडॉक जवाब से प्रेरित है

0-इंडेक्सिंग का उपयोग करता है

mḋTmMo±>ḋ2B3½

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

व्याख्या

            ½    Half the input
          B3     Convert to Base 3
   m             Map over the list
    Mo±>ḋ2       Function such that: 0 -> [0,0], 1 -> [0,1], 2 -> [1,1]
        ḋ2       Binary 2, [1,0]
    M            For each in that list
     o±>         check if the argument is greater than it
  T              Transpose
mḋ               Convert each from binary

पिछला 21 बाइट समाधान

पहली बार मैंने इसके लिए एक उपयोग देखा है »।

mḋT»o%2+ȯ?´eḋε%3`-0B3

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

लंबा, जैसा कि मैं वहन कर रहा था

— H.PWiz
स्रोत
8

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

f=
n=>[1,0].map(i=>parseInt((n/2).toString(3).replace(/./g,c=>+c+i>>1),2))
<input type=number min=0 step=2 oninput=o.textContent=this.value%2?``:f(this.value)><pre id=o>
स्निपेट का विस्तार करें

स्पष्टीकरण: विभाजन इनपुट और A005823 के तत्वों को 2 से बदलना समस्या में परिवर्तन नहीं करता है, हालांकि यह समाधान को सरल बनाता है क्योंकि टर्नरी अभ्यावेदन अब केवल 0 और 1s का उपयोग करते हैं और इसलिए विचार करने के लिए कोई ले जाने वाला नहीं है। यह तत्व से अपने सूचकांक में परिवर्तित करते समय एक कदम भी बचाता है (प्रत्येक तत्व का टर्नरी इसके सूचकांक के द्विआधारी का दोगुना है)। उदाहरण:

                 A005823
                  halved
            n in  values A005823
   n n/2  base 3  base 3 indices
   0   0       0   0   0   0   0  
   2   1       1   1   0   1   0
   4   2       2   1   1   1   1
   6   3      10  10   0   2   0
   8   4      11  11   0   3   0
  10   5      12  11   1   3   1
  12   6      20  10  10   2   2
  14   7      21  11  10   3   2
  16   8      22  11  11   3   3
  18   9     100 100   0   4   0
  30  15     120 110  10   6   2
  32  16     121 111  10   7   2
  46  23     212 111 101   7   5
  50  25     221 111 110   7   6
— नील
स्रोत
6

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

ḶBḤḅ3
ÇŒcS=¥Ðf⁸ḢiЀÇT

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

एक बाइट ने @JonathanAllan को धन्यवाद दिया!

स्पष्टीकरण:

                # Helper link: A005823 to *N* terms
Ḷ               # Lowered range(N)
 B              # Converted to binary
  Ḥ             # Double each digit
   ḅ3           # Converted from base 3 to decimal
                # Main link
Ç               # Last link
 Œc             # All combinations of 2 items (with replacement)
      Ðf        # Remove every combination where this isn't true:
   S=¥          #   The sum of the two items is equal to N
        ⁸Ḣ      # Take the first combination left
          i     # Index of
           Ѐ   # Each element of the combination
             Ç  # In the sequence
              T # Return the truthy indices
— DJMcMayhem
स्रोत
1
@JonathanAllan ओह, के बारे में जानकर अच्छा लगा Œc। और हाँ, डेनिस ने S=¥मेरे साथ समस्या बताई ।
— डीजेएमकेमहेम
ऐसा लगता है कि आपको शून्य के लिए किनारे-केस हैंडलिंग को जोड़ने की आवश्यकता है :(
— जोनाथन एलन
ऐसा लगता है कि यह 1-आधारित है; शायद यह जवाब में यह
— बताने
— डाइलन
3

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

f=lambda n:[n and(n/2%3>r)+2*f(n/3)[r]for r in 0,1]

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

कार्य इस तरह किया जा सकता है:

  1. इनपुट को रोकें
  2. टर्नरी सूची में परिवर्तित करें
  3. दो बाइनरी सूचियों में विभाजित करें जो इसके लिए मूल रूप से योग करते हैं
  4. उन सूचियों को बाइनरी से कन्वर्ट करें

हम 0->0,1->1,2->1एक सूची के 0->0,1->0,2->1लिए और दूसरे के लिए परिवर्तित करके (3) विभाजन कर सकते हैं । यही है, जाँच करके मान 0 या 1 की सीमा से ऊपर है।

दो मान संबंधित पुनरावर्ती कार्यों द्वारा पाए जा सकते हैं:

p=lambda n:n and(n/2%3>0)+2*p(n/3)
q=lambda n:n and(n/2%3>1)+2*q(n/3)

फ़ंक्शन fइन दोनों को एक सूची समझ में जोड़ता है। यह घातीय शाखाओं में बंटने के कारण इसे अक्षम बना देता है।

यदि जटिल संख्याएँ आउटपुट हो सकती हैं, तो हम 10 बाइट्स बचा सकते हैं:

f=lambda n:n and(n%6>1)+n%6/4*1j+2*f(n/3)
— XNOR
स्रोत
मुझे लगता है कि जटिल संख्या ठीक हैं।
— जियोकॉवेल
3

जे, 35 32 बाइट्स

($#:I.@,)@(=[:+/~3#.+:@#:@i.@>:)

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

0-अनुक्रमित और इनपुट को मोनोएडली दिया जाता है। मूल्य के सभी संभावित योग देता है (यह व्यवहार करता है a bऔर b aविभिन्न संभावित योगों के रूप में)।

बूलियन मैट्रिक्स से सूचकांकों में परिवर्तित होने से बहुत सारे कोड लगते हैं ...

मैं बायीं ओर कांटा भी निकालना चाहता हूं, इसलिए मुझे कई कोष्ठक और @चूहे के रूप में उपयोग करने की आवश्यकता नहीं है , लेकिन मैं इसे करने का एक अच्छा तरीका नहीं समझ सकता हूं (मेरा वैकल्पिक दृष्टिकोण किसी भी बाइट को नहीं बचाता है )।

व्याख्या

समझाने और ungolfing के प्रयोजनों के लिए, मुख्य कार्य के निम्नलिखित घटकों पर विचार करें

valid_nums      =. = [: +/~ 3 #. +:@#:@i.@>:
indices_of_ones =. $ #: I.@,

valid_nums एक बूलियन मैट्रिक्स उत्पन्न करता है जहां सूचकांक सुव्यवस्थित अनुक्रम मानों के सूचक होते हैं। अगर उन सूचकांकों में कोई एक है, तो इसका मतलब है कि दो नंबर इनपुट मूल्य के बराबर हैं।

indices_of_ones एक मनमाना रैंक बूलियन मैट्रिक्स में लोगों के निर्देशांक देने के लिए एक जे मुहावरा है

मुख्य कार्य काफी सरल रूप से बना है

indices_of_ones@valid_nums

valid_nums

= [: +/~ 3 #. +:@#:@i.@>:  Input is n
                 #:@i.@>:  Binary numbers in range [0,n]
              +:           Doubled
         3 #.              Interpreted as ternary
     +/~                   Addition table with self (sum all possible pairs)
=                          Equate to n

indices_of_ones

$ #: I.@,
        ,  Ravel matrix into a single list
     I.    Find the indices of ones in that list
  #:       Convert to the base given by
$          The shape of the matrix

,-रेल इस मामले में प्रत्येक पंक्ति में अगले में शामिल होकर काम करता है।

   i.3 3
0 1 2
3 4 5
6 7 8
   , i.3 3
0 1 2 3 4 5 6 7 8

हम देख सकते हैं कि यदि यह एक बूलियन मैट्रिक्स था, तो लोगों के निर्देशांक को उस मैट्रिक्स के आकार के आधारों में व्याख्या के रूप में पाया जा सकता है, जो कि मैट्रिक्स के आकार के आधार में संख्याओं के रूप में कई प्रीपेन्सलल वाक्यांशों का उपयोग करके संभव है ताकि गरीब पाठक को भ्रमित करने में मदद मिल सके। ।

— गोभी
स्रोत
1
आपके निरर्थक आउटपुट ठीक हैं।
— जियोकॉवेल
3

MATL , 22 21 19 17 बाइट्स

tQ:qBEI_ZA&+=R&fh

आउटपुट 1-आधारित है। कार्यक्रम सभी समाधान जोड़े पैदा करता है। इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

t      % Implicit input: n. Duplicate
Q:q    % Range [0 1 ... n]
B      % Convert to binary. Gives a matrix where each row corresponds to a number
E      % Multiply each entry by 2
I_ZA   % Convert each row from ternary to a number
&+     % Matrix of all pair-wise additions
=      % Does each entry equal n?
R      % Upper triangular matrix
&f     % Push row and column indices of nonzero entries
h      % Concatenate horizontally. Implicit didsplay
— लुइस मेंडो
स्रोत
ओपी ने कहा कि सभी समाधानों का निर्माण टिप्पणियों में ठीक था
— एच.पाइविज
@ H.PWiz धन्यवाद! मैंने यह नहीं देखा कि
— लुइस मेंडू
2

पायथ , 37 बाइट्स

0 अनुक्रमित

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

KUQJmi:.Bd\1\23KhfqQ+@JeT@JhTsmm,dkKK

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

— Cowabunghole
स्रोत
1
34 बाइट्स hfqQ+@Jmi:.Bd\1\23QeT@JhTsmm,dkUQU:। सबसे निश्चित रूप से गोल्फ हो सकता है
— श्री Xcoder
1
33 बाइट्स:hfqQ+@Jmi:.Bd\1\23QeT@JhTsmm,dkUQ
— मिस्टर एक्सकोडर
2

पायथ , 29 बाइट्स

यह एक सूचकांकों के सभी संभावित जोड़े को लौटाता है।

fqQ+@Kmi:.Bd\1\23QhT@KeT.cUQ2

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

अजगर , 30 बाइट्स

hfqQ+@Kmi:.Bd\1\23QhT@KeT.cUQ2

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

यह सूचकांकों के जोड़े के रूप में देता है [LowerIndex, HigherIndex]।

यह कैसे काम करता है?

hfqQ+@Kmi:.Bd\1\23QhT@KeT.cUQ2   Full Program. Q means input throughout the whole explanation.

       m          Q               Map over the range [0, Q) with a variable d.
          .Bd                     Convert to binary.
         :   \1\2                 Replace 1 with 2.
        i        3                Convert it from base 3 to integer.
      K                           Assign the mapped range to a variable K.
                         .cUQ2    All possible two-element combinations of the range [0...Q).
    +@             hT@KeT         Sum of the integers on positions in K of the two-element
                                  combination.
 fqQ                              Filter those that equal the input.
h                                 Optional: Head. Take the first element.
                                  Print the result, implicitly.
— श्री एक्सकोडर
स्रोत
2

पारदोक (v0.2.10), 11 बाइट्स (CP-1252)

½3B2>_B™2Bv

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

अल्गोरिदमिक रूप से यह नील के ईएस 6 जवाब की तरह ही है । निचले स्तर पर, H.PWiz के भूसी के जवाब के समान ही । मुझे खुशी है कि हमें तीनों ओवरलोडिंग का इस्तेमाल करना पड़ा B।

स्टैक पर एक पूर्णांक बनाता है, स्टैक पर दो पूर्णांक की एक सूची छोड़ता है।

स्पष्टीकरण:

½           .. Halve input
 3B         .. Convert to ternary
   2        .. 2, which will get implicitly coerced to [0,1]
    >_      .. Greater than, as a block
      B     .. "Bimap": take the block and map it over the Cartesian
            .. product of the last two lists to get a matrix
       ™    .. Transpose
        2Bv .. Convert each row from binary
— betaveros
स्रोत
1

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

-2 बाइट्स मिस्टर एक्सकोडर की बदौलत!

0 अनुक्रमित

def f(a):r=range(a);s=[int(bin(x)[2:].replace(*'12'),3)for x in r];return[(i,j)for i in r for j in r if s[i]+s[j]==a][0]

Ungolfed:

def f(a):
    r=range(a)
    s=[int(bin(x)[2:].replace(*'12'),3)for x in r]
    return[(i,j)for i in r for j in r if s[i]+s[j]==a][0]

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

— Cowabunghole
स्रोत
1
आशा है आप बुरा नहीं मानेंगे। मैंने एक TiO लिंक जोड़ा।
— श्री एक्सकोडर
1

गणितज्ञ, 94 बाइट्स

(w=#;Position[s,#]&/@#&@@(k=Select)[Tuples[s=k[Range@w,DigitCount[#,3,1]==0&],{2}],Tr@#==w&])&


1 अनुक्रमित

— J42161217
स्रोत
1

जावास्क्रिप्ट, 120 101 बाइट्स

n=>[(A=[...Array(n+1)].map(Z=(a,b=a)=>b&&3*Z(b/2|0)+b%2*2))[F='findIndex'](a=>z=~A[F](b=>a+b==n)),~z]

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

0 अनुक्रमित।
यह सूचकांकों की जोड़ी को लौटाता है जहां एक सूचकांक सबसे छोटा संभव है (उदाहरण के लिए 428यह रिटर्न के मामले में 22,31)।

1

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

-54 बिकी विकी पर modulo फ़ंक्शन को देखकर, कुछ संरचनात्मक परिवर्तन की अनुमति देता है

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

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

0 अनुक्रमित।

व्याख्या

अन्य समाधानों में से कई की तरह, यह टर्नेरी विस्तार की गणना n/2करता है और दो बाइनरी संख्याओं में परिवर्तित करता है।

चरण 1: इनपुट को 2 से भाग दें

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

 {              }     until number becomes zero:
     ({}[()()])       subtract two
( ()<          > {})  push number of iterations

चरण 2: गणना टर्नरी विस्तार

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

 ({}(<>))<>         {   (({})){({}[()])<>}{} }{}<> ([{}()]{})         modulo (from wiki)
           (()()())                                                   use 3 as base
                     ()<                    >                         evaluate as 1 every time the 3 rolls over
                   (                              <          >[()])   push number of rollovers (function is now division with remainder)
{                                                                  }  repeat until quotient is zero, leaving all remainders on stack

चरण 3: समाधान में बदलें

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

([]){{}                                                      ([][()])}           repeat while stack height > 1:
                                                                                 (loop happens once when initial stack height is 1, but that's fine)
       <>(({}){})                                                                double smaller output number
                 <>(({}){}                                  )                    double larger output number
                          {                              }{}                     if digit in ternary expansion is nonzero:
                           ()<                          >                        add 1 to larger output number
                              ({}[()]){                }                         if digit is 2:
                                       <>({}())<>(<{}>)                          add 1 to smaller output number
— Nitrodon
स्रोत
0

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

n=>[6,4].map(x=>parseInt((n/2).toString(3).replace(/./g,d=>x>>d&1),2)) // thanks @Neil
n=>[0,1].map(x=>parseInt((n/2).toString(3).replace(/1|2/g,d=>~-d||x),2))

(0-अनुक्रमित, और जाहिरा तौर पर लगभग वही समाधान @Neil के रूप में, भले ही मैंने उसका जवाब नहीं देखा था)

मैंने प्रक्रिया के रिवर्स का उपयोग करके एक नंबर से सूचकांक को वापस पाने के साथ शुरुआत की: बेस 3 के साथ कठोर, प्रत्येक के 2साथ बदलें1 2 के , पार्स को बेस 2 से ।

दो नंबर पाने के लिए, और यह कि हर एक के लिए, हम सिर्फ आधे इनपुट - लेकिन अब, 1अंक भी हो सकते हैं। इसलिए हम इसे 0एक संख्या में और 2दूसरी संख्या में प्रतिस्थापित करते हैं, जो प्रतिस्थापन-और-पार्स चरण से पहले दोनों का योग नहीं बदलता है। यहाँ मैं क्या कर रहा हूँ (दो प्रतिस्थापन करते हुए, 1-> 0-or-2 और 2-> 1एक कदम में):

n=>["001","011"].map(x=>parseInt((n/2).toString(3).replace(/./g,d=>x[d]),2))

बेशक दो प्रतिस्थापन मानचित्र (स्ट्रिंग्स) केवल एक सूचकांक में भिन्न होते हैं, इसलिए हमें केवल जगह 1और 2साथ सरणी सरणी को छोटा करने में सक्षम होना चाहिए d == 2 ? 1 : x। या d-1 || x। कहाँ पे-1 दो अपर संचालकों के समान है - लेकिन वे डरावने लगते हैं :-)

सरणी शाब्दिक और n/2मैं आसपास के कोष्ठक से बचने की कोशिश कर रहा था

n=>Array.from(parseInt,(h=n/2,i)=>parseInt(h.toString(3).replace(/1|2/g,d=>~-d||i),2))

लेकिन यह फलदायक नहीं निकला।

— Bergi
स्रोत
मैंने ["001","011"]संस्करण के साथ भी शुरुआत की (अच्छी तरह से मेरे चर नाम अलग थे)
— नील
मुझे लगता .replace(/./g,d=>d>>1|x)है कि 2 बाइट्स बचाता है।
— नील
@ नील दुर्भाग्य से यह काम नहीं करता है d="0" और x=1- अंक रहना चाहिए0
— बर्गी
हाँ, मैंने अभी कुछ और परीक्षण मामलों को आज़माने के बाद काम किया है। (और मैं तब से एक और संस्करण के साथ आया हूं, लेकिन यह मेरे जवाब में जा रहा है, मुझे डर है।)
— नील
1
ओह, बहुत अच्छा है, और मुझे लगा कि मैं आपके पिछले संस्करण को हराकर चतुर बन रहा हूं ...
— नील
0

पायथ, 22 बाइट्स

J.m}1jb3hQxLJhfqsTQ^J2

इसे ऑनलाइन आज़माएँ: प्रदर्शन

स्पष्टीकरण:

J.m}1jb3hQxLJhfqsTQ^J2
        hQ                input + 1 
 .m                       find all values of [0, 1, 2, ..., input], where
     jb3                     value converted to base 3
   }1                        check if it contains the digit 1
                          this boolean ^ is false
J                         store this list in variable J

                   ^J2    every pair of J
              f           filter for pairs with
                sT           sum of pair
               q             equal
                  Q          the input
             h            take the first of these pairs
          xLJ             and find the corresponding indices of J
— Jakube
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.