एक क्रमबद्ध क्रमबद्ध करें

Question

पुनरावृत्ति संबंधों पर आधारित अनुक्रम पर विचार करें f(n) = f(n-1)+f(n-2), के साथ शुरू f(1) = x1, f(2) = x2। इस प्रकार x1 = 2, x2 = 1, यह क्रम शुरू होता है:

2  1  3  4  7  11  18  29  47  76  123  199  322  521  843

इसे एक स्ट्रिंग में बदलते हुए:

213471118294776123199322521843

अब, इस सूची को सबसे छोटी संभव संख्याओं में विभाजित करें जो देता है y(n) > y(n-1)। पहली संख्या के साथ शुरू करें, फिर दूसरा आदि। पहला आउटपुट नंबर हमेशा एक अंक का होना चाहिए। शून्य की आवश्यक संख्या के साथ अंतिम संख्या को पैड करें।

2 13 47 111 829 4776 12319 93225 218430

आपको दो नंबर मिलेंगे, (x1, x2)इनपुट के रूप में, किसी भी सुविधाजनक प्रारूप पर, और चुनौती क्रमबद्ध सूची को आउटपुट करने की है।

नियम:

• समारोह और कार्यक्रम ठीक हैं
• प्रारंभिक अनुक्रम में ठीक 15 नंबर होंगे (अंतिम संख्या f(15))।
• x1और x2गैर-नकारात्मक (शून्य संभव है)।
• आउटपुट किसी भी सुविधाजनक प्रारूप पर हो सकता है
• आउटपुट वेक्टर yबनाया जाना चाहिए ताकि y2 > y1।
  • पहले सबसे छोटा संभव y1, फिर सबसे छोटा संभव y2, फिर y3इतना ही।
• यदि x1 = x2 = 0तब 15 शून्य (आउटपुट पर अन्य आउटपुट के समान प्रारूप पर, अर्थात नहीं 000000000000000)।

उदाहरण :

Input: 1 1
Output: 1  12  35  81  321  345  589  1442  3337 7610

Input: 3 2
Output: 3  25  71  219  315  0811 3121  23435 55898 145300
                             |
                             Optional leading zero 
Input: 0 0
Output: 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

बाइट्स में सबसे छोटा कोड जीतता है। यदि संभव हो तो एक ऑनलाइन दुभाषिया के लिए एक लिंक शामिल करें।

Comments

"छोटी से छोटी संभावित संख्या" से आपका क्या तात्पर्य है? सबसे छोटा औसत? सबसे छोटा अधिकतम? कुछ और?

— isaacg

@ लिसाक इसलिए कि nth संख्या (n-1) वें से अधिक है।

— निकेल

मेरे प्रश्न को स्पष्ट करने के लिए, उचित विभाजन क्या होगा 5467? 54 67? 5 46 70?

— isaacg

संबंधित लेकिन थोड़ा अलग

— Sp3000

0 बात एक बल्कि कष्टप्रद और अनावश्यक अपवाद की तरह लगती है।

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

Answer 1

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

LsgM.:sMb2?sQsM.WyHX_1Z`0u?yGX_1GHaGHjkhM.u,eNsN14QYmZ15

परीक्षण सूट

स्पष्टीकरण:

पहले, हम जांचते हैं कि इनपुट ठीक है या नहीं 0, 0। यदि ऐसा है, तो 15 शून्य प्रिंट करें।

अन्यथा, हम अनुक्रम का उत्पादन करते हैं, के साथ jkhM.u,eNsN14Q। यह फाइबोनैचि अनुक्रम के लिए मानक Pyth एल्गोरिथम के समान है।

अगला, हम इस स्ट्रिंग को कम करते हैं। संचायक तार की एक सूची है, विभाजित क्रम में प्रत्येक संख्या का प्रतिनिधित्व करता है। प्रत्येक कमी कदम पर, हम अगला चरित्र लेते हैं, और जांचते हैं कि क्या संचायक क्रम में है, हेल्पर फ़ंक्शन का उपयोग करके , जिसे yपरिभाषित किया गया है LsgM.:sMb2, जो कि यदि इनपुट ऑर्डर से बाहर है तो सत्य है। यदि यह क्रम में है, तो हम अगले वर्ण को अपनी संख्या के रूप में सूचीबद्ध करते हैं। यदि नहीं, तो हम अगले वर्ण को अंतिम स्ट्रिंग के अंत में जोड़ते हैं। इसके साथ पूरा किया जाता है u?yGX_1GHaGH ... Y।

अगला, हम लूप करते हुए एक कार्यात्मक प्रदर्शन करते हैं। लूप तब तक जारी रहता है जब तक कि चल रही सूची क्रम में नहीं होती है, सहायक फ़ंक्शन का पुन: उपयोग कर रहा है। प्रत्येक चरण 0में, सूची में अंतिम स्ट्रिंग के अंत में एक जोड़ा जाता है। इसके साथ पूरा किया जाता है .WyHX_1Z`0।

अंत में, तार पूर्णांक में परिवर्तित हो जाते हैं sM, और मुद्रित होते हैं।

---

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

LsgM.:sMb2?sQsM.WyHX_1Z`0hf!yT_./jkhM.u,eNsN14QmZ15

मेरा मानना ​​है कि यह काम करता है, लेकिन यह परीक्षण करने के लिए बहुत धीमा है - यह स्ट्रिंग को विभाजित करने के लिए एक क्रूर बल समाधान है।

---

मैं Xफ़ंक्शन में कुछ सुधार कर रहा हूं , लेकिन उपरोक्त कोड पायथ के संस्करण में काम करता है जो कि सबसे हाल ही में था जब सवाल पोस्ट किया गया था।

Answer 2

जावास्क्रिप्ट ईएस 6, 127 135

(a,b)=>eval("for(n=r=[],v=13,o=a+n+b;v--;a=b,b=t)o+=t=b+a;for(d of o+'0'.repeat(99))(n+=d)>+v&&(r.push(v=n),n='');+v?r:[...o]")

परीक्षा

F=(a,b)=>eval("for(n=r=[],v=13,o=a+n+b;v--;a=b,b=t)o+=t=b+a;for(d of o+'0'.repeat(99))(n+=d)>+v&&(r.push(v=n),n='');+v?r:[...o]")

// less golfed

U=(a,b)=>{
  for(n=r=[], o=a+n+b, v=13; v--; a=b, b=t)
    o+= t= b+a;
  for(d of o+'0'.repeat(99))
    if ((n+=d) > +v)
      r.push(v=n), n='';
  return +v ? r : [...o]
}

function test(){
  var i = I.value.match(/\d+/g)
  O.textContent = i.length > 1 ? F(+i[0],+i[1]) : ''
}
test()

A,B : <input id=I value='0 1' oninput='test()'>
<pre id=O></pre>

Comments

X1 = 0, x2> 0, जैसे इनपुट "0 1" के लिए एक त्रुटि है।

— फटाके

@flornquake तय। बाइट की गिनती एक समान रहती है, जिससे शून्य भरने वाला कोड कम हो जाता है

— edc65

Answer 3

जावास्क्रिप्ट ईएस 6, 187 180 187 184 182 179 175 172 165 160 155 154 बाइट्स

(a,b)=>eval('d=""+a+b;for(i=-12,j=1;++i<99;)i<2?(c=b,d+=b=a+b,a=c,r=a?[d[0]]:"0,".repeat(15)):(f=+d.slice(j,i))>r[r.length-1]?(r.push(f),j=++i-1):d+=0;r')

जब मैं इसे चलाता हूं 1,1और 3,2मामलों का परीक्षण करता हूं तो मुझे ऐसे ही परिणाम मिलते हैं।0,0एक अतिरिक्त 26 बाइट्स लिया है ...

डे-गोल्फ + ES5 + डेमो में परिवर्तित:

function s(a, b) {
  d = "" + a + b;
  for (i = -12, j = 1; ++i < 99;)
    i < 2 ?
      (c = b, d += b = a + b, a = c, r = a ? [d[0]] : "0,".repeat(15))
    : (f = +d.slice(j, i)) > r[r.length - 1] ?
      (r.push(f), j = ++i - 1)
      : d += 0;
  return r
}
document.write(
   s(1,1)+"<br>"+
   s(3,2)+"<br>"+
   s(0,0)
)

Comments

यह अधिक संख्या क्यों उत्पन्न करता है? और इसे ठीक करना आसान नहीं होना चाहिए? आवश्यकता है n <= 15।

— स्टीवी ग्रिफिन

@ स्टेवी लेकिन हे, पहला 12 का उत्पादन करता है और दूसरा 11. वह 15 से छोटा है।

— 12

प्रारंभिक अनुक्रम f(n) = f(n-1)+f(n-2)में ठीक 15 का अधिकतम मूल्य है। आउटपुट मानों की संख्या एल्गोरिथ्म के आधार पर निर्धारित की जाती है, और कुछ नहीं।

— स्टिव ग्रिफ़िन

@Stewie ठीक है, तो यह बिल्कुल 15 होना चाहिए, है ना? फिर, n <= 15 से आपका मतलब है कि इनपुट नंबर 15 से कम हैं?

— निकेल

प्रारंभिक अनुक्रम में मूल्यों की संख्या 15 है। शुरुआती मूल्य f(1)=x1और f(2)=x215. से अधिक हो सकते हैं। आउटपुट मानों की संख्या इनपुट मूल्यों के आधार पर निर्धारित की जाती है। इसके लिए 3 210.

— स्टीवी ग्रिफिन

Answer 4

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

(a,b)=>(k=[...Array(15).keys(y="")],p=-1,z=k.map(_=>0),a|b?[...k.map(f=n=>n--?n?f(n)+f(n-1):b:a).join``,...z].map(d=>+(y+=d)>p?(p=y,y=" ",p):"").join``:z.join` `)

व्याख्या

(a,b)=>(
  k=[...Array(15).keys(y="")],     // k = array of numbers 0 to 14, initialise y
  p=-1,                            // initialise p to -1 so that 0 is greater than p
  z=k.map(_=>0),                   // z = array of 15 zeroes
  a|b?[                            // if a and b are not 0
      ...k.map                     // for range 0 to 14
      (f=n=>n--?n?f(n)+f(n-1):b:a) // recursive sequence function (0 indexed)
      .join``,                     // join result of f(0) to f(14) as a string
      ...z                         // append zeroes for padding
    ].map(d=>                      // for each digit of concatenated result
      +(y+=d)                      // append the digit to the current number y
      >p?(                         // if the current number is greater than the previous p
        p=y,                       // set previous to the current number
        y=" ",                     // reset y (with space as a separator)
        p                          // output the current number (with space at the start)
      ):""                         // else add nothing to the output
    )
    .join``                        // return the output as a string
  :z.join` `                       // return a bunch of zeroes if a and b are 0
)

परीक्षा

var solution = (a,b)=>(k=[...Array(15).keys(y="")],p=-1,z=k.map(_=>0),a|b?[...k.map(f=n=>n--?n?f(n)+f(n-1):b:a).join``,...z].map(d=>+(y+=d)>p?(p=y,y=" ",p):"").join``:z.join` `)

x1 = <input type="number" id="x1" value="3" /><br />
x2 = <input type="number" id="x2" value="2" /><br />
<button onclick="result.textContent=solution(+x1.value,+x2.value)">Go</button>
<pre id="result"></pre>

Answer 5

मैथेमेटिका, 192 बाइट्स

f[{0,0}]:=0~Table~15
f@l_:=(t=0;q={};If[#>0,q~Join~{10^⌈Log10[t/#]⌉#},q]&[Last@#]&@FoldList[If[#>t,AppendTo[q,t=#];0,#]&[10#+#2]&,0,Flatten@IntegerDigits@SequenceFoldList[#+#2&,l,Range@13]])

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

f[{2, 1}]
(* {2, 13, 47, 111, 829, 4776, 12319, 93225, 218430} *)
f[{3, 2}]
(* {3, 25, 71, 219, 315, 811, 3121, 23435, 55898, 145300} *)
f[{0, 0}]
(* {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} *)

फ़ंक्शन नामों की लंबाई मुझे मार रही है।

Answer 6

हास्केल, 165 159 152 142 141 बाइट्स

w=take 15
x#y=x:scanl(+)y(x#y)
0%0=w[0,0..]
x%y=g(-1)(w(x#y)++0%0>>=show)(-1)
g _""_=[]
g b l@(h:t)a|b>a=b:g 0l b|1<2=g(max 0b*10+read[h])t a

प्रयोग उदाहरण: 3 % 2-> [3,25,71,219,315,811,3121,23435,55898,145300]।

ऑनलाइन डेमो (ए के साथmain आवरण के )।

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

w=take 15
x#y=x:scanl(+)y(x#y)              -- fibonacci sequence generator for x and y

0%0=w[0,0..]                      -- special case 0%0
x%y=g(-1)(w(x#y)++0%0>>=show)(-1) -- calculate fib sequence, add some extra 0 and
                                  -- flatten all digits into a single string.
                                  -- start calculating the resulting sequence

g _""_=[]                         -- if we don't have digits left, stop.
                                  -- the final 0 in the second parameter is ignored.
g b l@(h:t)a
  |b>a=b:g 0l b                   -- if the current number is greater than the
                                  -- previous one, take it and start over.
  |1<2=g(max 0b*10+read[h])t a    -- otherwise add the next digit and retry.
                                  -- The "max" fixes the initial call with -1.

Answer 7

पॉवरशेल, 167 166 बाइट्स

param($x,$w)if($w-lt($x-eq0)){"0`n"*15;exit}[char[]]("$x"+-join(0..13|%{$w;$w=$x+($x=$w)}))|%{$z+="$_";if(+$z-gt$y){($y=$z);$z=""}};if($z){while(+$z-lt$y){$z+="0"}$z}

एक बाइट को समाप्त करके बचा लिया $sचर और सीधे आउटपुट लूप को खिलाया।

असंबद्ध और टिप्पणी:

param($x,$w)           # Take input parameters as x and w
if($w-lt($x-eq0)){     # If x=0, ($x-eq0)=1, so $w-lt1 implies w=0 as well
  "0`n"*15             # Print out 15 0's separated by newlines
  exit                 # And exit program
}                      # otherwise ...
[char[]](              # Construct the sequence string as a char-array
"$x"+-join(            # Starting with x and concatenated with a joined array
  0..13|%{             # Loop
    $w                 # Add on w
    $w=$x+($x=$w)      # Recalculate for next loop iteration
  }
))|%{                  # Feed our sequence as a char-array into a loop
  $z+="$_"             # z is our output number, starts with the first digit
  if(+$z-gt$y){        # If z is bigger than y (initialized to 0)
    ($y=$z)            # Set y equal to z and print it
    $z=""              # Reset z to nothing to start building the next number
  }
}
if($z){                # If there is remaining digits, we need to pad zeroes
  while(+$z-lt$y){     # Until z is bigger than y
    $z+="0"            # Tack on a zero
  }
  $z                   # Print the final number
}

Answer 8

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

{$_=@=(|@_,*+*...*)[^15].join.comb;.sum??[.shift,{last if !@$_;until (my$a~=.shift//0)>$^b {};$a}...*]!!$_} # 107

उपयोग:

# give it a lexical name for ease of use
my &code = {...}

# use ｢eager｣ because the anonymous block returns a lazy array
# and ｢say｣ doesn't ask it to generate the values
say eager code 2, 1;
# [2 13 47 111 829 4776 12319 93225 218430]
say eager code 1, 1;
# [1 12 35 81 321 345 589 1442 3337 7610]
say eager code 3, 2;
# [3 25 71 219 315 0811 3121 23435 55898 145300]
say eager code 0, 0;
# [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
say eager code 0, 1;
# [0 1 12 35 81 321 345 589 1442 3337 7000]

व्याख्या

अनुक्रम की तरह एक फिबोनाची बनाता है, जो तर्कों ( @_) फिसल गया ( |) में शुरू होता है

|@_,*+*...*

उस क्रम के पहले 15 तत्वों को लेता है

(…)[^15]

एक ही तार में ( .join) को जोड़ती है , इसे अलग-अलग वर्णों के अनुक्रम में विभाजित करती है ( .comb) और स्टोर करती है कि "डिफ़ॉल्ट" स्केलर में ($_ ) में अनुक्रम को एक उत्परिवर्तित सरणी में रखने के बाद, इसे पहले एक अनाम सरणी में संग्रहीत करके ( @)

$_=@=(…)[^15].join.comb;

यह डिफ़ॉल्ट स्केलर में मानों का योग पाता है, और यदि शून्य डिफ़ॉल्ट स्केलर लौटाता है, जिसमें 15 शून्य का सरणी होगा

.sum?? … !!$_

यदि राशि शून्य नहीं है, तो यह डिफ़ॉल्ट अदिश में पहले तत्व को पहले स्थानांतरित करके एक सूची बनाता है

.shift, … 

बाकी मान उत्पन्न करने के बाद, पिछले एक के खिलाफ इसकी जाँच करें ( $^b)
यदि डिफ़ॉल्ट स्केलर मानों से बाहर चला जाता है, तो इसके बजाय 0 का उपयोग करें ( //0)

…,{ … ;until (my$a~=.shift//0)>$^b {};$a}...*

डिफ़ॉल्ट स्केलर में कोई तत्व नहीं रहने पर रोकना

…,{last if !@$_; … }...*

Comments

इसमें कोई स्थान क्यों होना चाहिए until (my$a...? क्या (कोई विशेष परिसीमन नहीं है?

— बिल्ली

@cat नाम के सबरूटीन के लिए एक कॉल होगा until, जो मौजूद नहीं है।

— ब्रैड गिलबर्ट 2