से शुरू करें

18

कड़ाई से सकारात्मक पूर्णांक n को देखते हुए , इन चरणों का पालन करें:

  1. N 1 s के साथ एक सरणी A बनाएँ ।
  2. यदि A के पास केवल एक तत्व है, तो समाप्त करें। अन्यथा, पहले तत्व से शुरू होकर, A के प्रत्येक जोड़े को इसके योग से बदलें , अंतिम तत्व को छोड़ दें जैसे कि A की लंबाई विषम है, और इस चरण को दोहराएं।

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

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

इन उदाहरणों के आउटपुट में प्रत्येक पंक्ति एक स्थिति है। आप किसी भी उचित प्रारूप के माध्यम से आउटपुट कर सकते हैं।

इनपुट: 1

[1]

इनपुट: 4

[1, 1, 1, 1]
[2, 2]
[4]

इनपुट: 13

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[2, 2, 2, 2, 2, 2, 1]
[4, 4, 4, 1]
[8, 5]
[13]

इनपुट: 15

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[2, 2, 2, 2, 2, 2, 2, 1]
[4, 4, 4, 3]
[8, 7]
[15]
code-golf  arithmetic 
— आउटगोल्फ को एरिक करें
स्रोत
क्या मैं रिवर्स ऑर्डर के लिए इस प्रश्न विचार को कॉपी कर सकता हूं? नंबर n, आउटपुट स्टेप वाइज A और इतने पर जब तक आप n 1s तक नहीं पहुंच जाते?
— पिक्समा 140
10
@ Pixma140 मूल रूप से एक ही चुनौती होगी, बस बाद में आउटपुट उलट जाएगा। संशोधन तुच्छ है।
— एर्ग आउटोलॉफ़र

जवाबों:

4

MATL , 10 बाइट्स

:g`t2estnq

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

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

:     % Input n (implicit). Range [1 2 ... n]
g     % Convert to logical. Gives [1 1 ... 1]
`     % Do...while
  t   %   Duplicate
  2   %   Push 2
  e   %   Reshape as 2-column matrix, in column-major order, padding with 0 if needed
  s   %   Sum of each column
  t   %   Duplicate
  n   %   Number of elements
  q   %   Subtract 1. This will be used as loop condition
      % End (implicit). If top of the stack is not zero run new iteration
      % Display stack, bottom to top (implicit)
— लुइस मेंडो
स्रोत
4

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

def f(i,j=1):print(i//j*[j]+[i%j][:i%j]);i>j and f(i,j*2)

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

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

def f(i,j=1):print i/j*[j]+[i%j][:i%j];i>j>f(i,j*2)

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

-6 बाइट्स टीश के लिए कुल धन्यवाद

पुनरावर्ती कार्य। प्रत्येक चरण के लिए, यह शक्तियों की एक सूची का निर्माण करता है 2, जैसे कि योग दिए गए पूर्णांक से छोटा या बराबर है। यह तब शेष को जोड़ता है, यदि यह इससे बड़ा है 0।

— Jitse
स्रोत
1
पायथन 3 61 बाइट्स def f(i,j=1):l=i//j*[j]+[i%j][:i%j];print(l);i>j and f(i,j*2):; पायथन 2 55 बाइट्स:def f(i,j=1):l=i/j*[j]+[i%j][:i%j];print l;i>j>f(i,j*2)
— tsh
@tsh बेशक, धन्यवाद! i>jमेरे पिछले समाधान में काम नहीं किया और मैं इसके बाद की कोशिश करना भूल गया।
— जित्स
3

आर , 65 बाइट्स

Giuseppe के लिए -1 बाइट धन्यवाद।

n=scan();while(T<2*n){cat(rep(+T,n%/%T),if(n%%T)n%%T,"\n");T=2*T}

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

%/%%%k=2^in%/%kkn%%k2n-1

यहाँ मैं Tइसके बजाय का उपयोग कर रहा हूँ k, क्योंकि इसे आरंभिक रूप TRUEमें परिवर्तित किया गया है। मुझे आउटपुट में s के वेक्टर से बचने +Tके Tलिए इसके बजाय प्रिंट करने की आवश्यकता है TRUE।

— रॉबिन राइडर
स्रोत
मुझे लगभग 5 मिनट और लगभग 60 बाइट्स से हराया ... लेकिन Giuseppe सही है, यह अंतिम चरण का उत्पादन नहीं करता है।
— Sumner18
@ Sumner18 को अब तय किया जाना चाहिए।
— रॉबिन राइडर
+Tकी तुलना में कम हैT+0
— Giuseppe
@Giuseppe धन्यवाद, मुझे पता था कि मैं कुछ भूल रहा था।
— रॉबिन राइडर
3

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

.u+McN2m1

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

.u          # Apply until a result is repeated, return all intermediate steps: lambda N,Y:
  +M        # map by + (reduce list on +):
    cN2     # chop N (current value) into chunks of 2, last one is shorter if needed
       m1Q  # map(1, range(Q)) (implicit Q = input)

-1 बाइट थैंक्स टू फ्रायमईएग्मैन

— ar4093
स्रोत
3

जे , 20 17 बाइट्स

_2+/\&.>^:a:<@#&1

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

-5 बाइट्स बब्बलर को धन्यवाद

— जोनाह
स्रोत
20 बाइट्स को खत्म [:करके ()।
— बब्बलर
अच्छा पकड़ा! धन्यवाद।
— जोनाह
— बब्बलर
धन्यवाद @ बब्बलर। जिज्ञासा से बाहर, क्या आप इसे वापस लाया?
— जोनाह
1
मैं बस यादृच्छिक चुनौतियों के माध्यम से ब्राउज़ करता हूं जो "सक्रिय" पर दिखाई देती हैं यह देखने के लिए कि क्या मैं एक उत्तर जोड़ सकता हूं या मौजूदा उत्तर को आगे बढ़ा सकता हूं।
— बब्बलर
2

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

f=(n,t=1,r=n)=>r>t?t+[,f(n,t,r-t)]:n>t?r+`
`+f(n,t+t):r

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

यह मूल रूप से निम्नलिखित कोड का गोल्फ संस्करण है:

function f(n) {
  var output = '';
  t = 1;
  for (t = 1; ; t *= 2) {
    for (r = n; r > t; r -= t) {
      output += t + ',';
    }
    output += r;
    if (n <= t) break;
    output += '\n';
  }
  return output;
}
— TSH
स्रोत
2

ब्रेकीलॉग , 17 बाइट्स

;1j₍ẹẉ₂{ġ₂+ᵐ}ⁱ.ẉȮ

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

जब तक यह बहुत लंबा है, तब भी मैं उपयोग करने के लिए थोड़ा चालाक महसूस करता हूं .ẉȮ: किसी चीज़ को प्रिंट करने का स्पष्ट तरीका, फिर जांचें कि क्या उसकी लंबाई 1 हैẉ₂l1 , ẉ₂~gया ẉ₂≡Ȯ, जहां ≡पिछले एक में आवश्यक है, क्योंकि ẉ₂जोड़ता अपने इनपुट और आउटपुट इससे पहले कि यह उन्हें प्रिंट करता है, और Ȯलंबाई 1 की एक सूची बनने के लिए पहले से विवश है, इसलिए यदि इनपुट की लंबाई की सूची नहीं है तो एकीकरण विफल हो जाता है। 1. एक विधेय के अंत में, इस विशेषता को ẉ₂दरकिनार किया जा सकता है, हालांकि, द्वारा सबस्क्रिप्ट के बजाय आउटपुट चर का उपयोग करना ẉ: .ẉȮपहले आउटपुट चर के साथ अपने इनपुट को एकीकृत करता है, फिर आउटपुट चर को प्रिंट करता है, और उसके बाद ही आउटपुट चर को एकीकृत करता है Ȯ।

— असंबंधित स्ट्रिंग
स्रोत
2

स्टैक्स , 10 बाइट्स

Çë⌐ⁿ┤5π»Å╡

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

प्रक्रिया:

  1. 0-आधारित श्रेणी उत्पन्न करें।
  2. बार-बार प्रत्येक तत्व को तब तक आधा करें जब तक सभी आइटम शून्य न हों।
  3. प्रत्येक अद्वितीय सरणी के लिए रन-लंबाई की गणना करें।

एनोटेट स्रोत:

r       main:[0 .. 5] 
{{hmgu  main:[[0 .. 5], [0, 0, 1, 1, 2, 2], [0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0]] 
m:GJ    main:"1 1 1 1 1 1"
— पुनरावर्ती
स्रोत
1

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

ＮθＩＥ↨⊖⊗θ²Ｅ⪪Ｅθ¹Ｘ²κＬλ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। चारकोल के डिफ़ॉल्ट आउटपुट प्रारूप का उपयोग करता है, जो प्रति पंक्ति एक नंबर है, एक दूसरे से डबल-स्प्रेड के साथ सबरेज़। स्पष्टीकरण:

Ｎθ                  Input `n` into a variable
       θ            `n`
      ⊗             Doubled
     ⊖              Decremented
    ↨   ²           Converted to base 2 (i.e. ceil(log2(input)))
   Ｅ                Map
           Ｅθ¹      List of `1`s of length `n`
          ⪪         Split into sublists of length
               ²    Literal `2`
              Ｘ     To power
                κ   Loop index
         Ｅ          Map over each sublist
                 Ｌλ Take the length
  Ｉ                 Cast to string for implicit print
— नील
स्रोत
1

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

{1 xx$_,*.rotor(2,:partial)>>.sum...1}

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

आंशिक रूप से घूमने के कुछ शॉर्टकट हैं जो मुझे अभी याद नहीं हैं ...

स्पष्टीकरण:

{                                    }  # Anonymous code block
                                 ...    # Return a sequence
 1 xx$_,            # Starting with a list of 1s with input length
        *           # Where each element is
         .rotor(2,:partial)        # The previous list split into chunks of 2 or less
                           >>.sum  # And each chunk summed
                                    1  # Until the list is length 1
— मजाक कर रहा है
स्रोत
1

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

g.pure
g x|x!!0<2=[x]|1>0=(g$(\z->filter(0/=)[-div(-z)2,div z 2])=<<x)++[x]

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

सूची से पीछे की ओर काम करता है [n]जब तक यह सिर्फ लोगों की सूची तक नहीं पहुंचता है।

आगे जा रहे हैं, मैं का उपयोग कर बाइट्स 80 मिल सकता है chunksofसे Data.List.Split:

import Data.List.Split
f x=g$1<$[1..x]
g[n]=[[n]]
g x=x:(g$map sum$chunksOf 2 x)

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

— मजाक कर रहा है
स्रोत
1

केजी , 30 बाइट्स

(|1){!1>|^(:. ,")^
,(!2/|+")}.

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

मैं वास्तव में थोड़ी देर के लिए इस चुनौती को पूरा करने के लिए अर्थ रखता हूं (मेरा मतलब है, मैंने खुद को इसके लिए लिंक ईमेल किया था इसलिए मुझे याद होगा), लेकिन मैंने अब तक ऐसा करने के लिए कभी भी आस-पास नहीं देखा है!

— जोनो 2906
स्रोत
1

गोल्फस्क्रिप्ट , 24 बाइट्स

एक बहुत लंबा जवाब ... एक हार्ड-टू-रीड आउटपुट फॉर्मेट का उपयोग करके 1 बाइट को बाहर निकाला

~[1]*{..2/{{+}*}%\,(}do;

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

व्याख्या

~                        // Dump the contents of the input string
 [1]*                    // Create a 1-list with the length of the input string
     {              }do  // do ... while
                 \,(     // the length of the array is larger than 1
      .                  // Extra evolution step that we need to keep
       .                 // Create a copy of the input
        2/               // That splits into parts of 2 items
          {    }%        // For each over the splitted array:
           {+}*          // Reduce the item with addition
                         // e.g. [1] -> [1], [1 2] -> [3], etc.
                       ; // Discard the abundant copy
— a'_ '
स्रोत
0

ओम v2 , 8 बाइट्स

@Dv·Ω2σΣ

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

यदि वैज्ञानिक संकेतन में आउटपुट की अनुमति है, अन्यथा:

ओम v2 , 9 बाइट्स

@Dv·Ω2σΣì

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

— Cinaski
स्रोत
अगर वैज्ञानिक अंकन संख्या वास्तव में ओम में एक प्राकृतिक संख्या प्रकार (जैसे तैरता है) है तो निश्चित है, यह उचित है।
— को आउटगोल्फर को एरिक करें
0

एपीएल, 28 वर्ण

{1≢≢⎕←⍵:∇+/(⌈.5×≢⍵)2⍴⍵,0}⍴∘1

1s का वेक्टर

⍴∘1

तर्क को आउटपुट करें और जांचें कि क्या लंबाई 1 से भिन्न है: यदि हां, तो चलें

1≢≢⎕←⍵:

लंबाई का आधा भाग प्राप्त करें और गोल करें

⌈.5×≢⍵

यदि आवश्यक हो तो एक अनुगामी 0 जोड़ते हुए एक nx2 मैट्रिक्स में फेरबदल करें

(⌈.5×≢⍵)2⍴⍵,0

पंक्ति से पंक्ति का योग

+/

recurse

∇
— पोपोव
स्रोत
— पोपोव
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.