İle f(n) = f(n-1)+f(n-2)başlayan nüks ilişkilerine dayanan bir dizi düşünün f(1) = x1, f(2) = x2. Çünkü x1 = 2, x2 = 1, sıra şu şekilde başlar:

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

Bunu bir dizgiye birleştirmek şöyle olur:

213471118294776123199322521843

Şimdi, bu listeyi veren en küçük sayılara bölün y(n) > y(n-1). İlk sayı, sonra ikinci vb. İle başlayın. İlk çıkış numarası her zaman tek haneli olmalıdır. Son sayıyı gereken sayıda sıfırla doldurun.

2 13 47 111 829 4776 12319 93225 218430

(x1, x2)Herhangi bir uygun formatta girdi olarak iki sayı alırsınız ve zorluk sıralı listenin çıktısını almaktır.

Kurallar:

• İşlev ve programlar iyi
• İlk sıra tam olarak 15 sayıya sahip olmalıdır (Son sayı f(15)).
• x1ve x2negatif değildir (sıfır mümkündür).
• Çıktı herhangi bir uygun formatta olabilir
• Çıkış vektörü ybu şekilde oluşturulmalıdır y2 > y1.
  • Önce mümkün olan en küçük y1, sonra mümkün olan en küçük y2, sonra y3vb.
• Daha x1 = x2 = 0sonra 15 sıfır çıkar (diğer çıktılarla aynı formatta, yani değil 000000000000000).

Örnekler :

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

Bayt cinsinden en kısa kod kazanır. Lütfen mümkünse bir çevrimiçi tercümanın bağlantısını ekleyin.

Pyth, 56 bayt

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

Test odası

Açıklama:

İlk olarak, girişin kesin olup olmadığını kontrol ederiz 0, 0. Öyleyse, 15 sıfır yazdırın.

Aksi takdirde, diziyi ile üretiriz jkhM.u,eNsN14Q. Bu, Fibonacci dizisi için standart Pyth algoritmasına benzer.

Sonra, bu dizeyi azaltıyoruz. Akümülatör, bölünmüş dizideki her sayıyı temsil eden dizelerin listesidir. Her bir azaltma adımında, bir sonraki karakteri alırız ve akümülatörün y, tanımlanmış yardımcı işlevini kullanarak LsgM.:sMb2, girişin bozuk olması durumunda doğrudur. Sıralıysa, bir sonraki karakteri listeye kendi numarası olarak ekleriz. Değilse, bir sonraki karakteri son dizenin sonuna ekleriz. Bu ile yapılır u?yGX_1GHaGH ... Y.

Sonra, işlevsel bir while döngüsü gerçekleştiriyoruz. Döngü, yardımcı işlevi yeniden kullanarak, çalışma listesi sıraya girene kadar devam eder. Her adımda, 0listedeki son dizenin sonuna a eklenir. Bu ile yapılır .WyHX_1Z`0.

Son olarak, dizeler ile tamsayılara dönüştürülür sMve yazdırılır.

Pyth, 51 bayt

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

Bunun işe yaradığına inanıyorum, ancak test etmek için çok yavaş - ipi bölmek için kaba bir çözüm.

Ben Xişlev bazı iyileştirmeler yapacağız , ancak yukarıdaki kod soru gönderildiğinde en son Pyth sürümünde çalışır.

JavaScript ES6, 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]")

Ölçek

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>

JavaScript ES6, 187 180 187 184 182 179 175 172 165 160 155 154 bayt

(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')

Çalıştırırken 1,1ve 3,2vakaları test ederken benzer sonuçlar alıyorum .0,026 baytı aştı ...

Golf + sürümü ES5 + demosuna dönüştürüldü:

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)
)

JavaScript (ES6), 162 bayt

(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çıklama

(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
)

Ölçek

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>

Mathematica, 192 bayt

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]])

Test senaryoları:

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} *)

İşlev adlarının uzunlukları beni öldürüyor.

Haskell, 165 159 152 142 141 bayt

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

Kullanım örneği: 3 % 2-> [3,25,71,219,315,811,3121,23435,55898,145300].

Çevrimiçi demo (bir mainpaketleyici ile).

Nasıl çalışır:

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.

PowerShell, 167 166 bayt

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}

$sDeğişkeni ortadan kaldırarak ve çıkış döngüsünü doğrudan besleyerek bir bayt kaydetti .

Ungolfed ve yorum yaptı:

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
}

Perl 6 , 107 bayt

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

Kullanımı:

# 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]

açıklama

içinde @_kaymış ( |) argümanlar ile başlayarak Fibonacci benzeri bir sıra oluşturur

|@_,*+*...*

bu dizinin ilk 15 öğesini alır

(…)[^15]

bunu tek bir dizede birleştirir (.join ) ) dizisine böler ve diziyi değişken bir diziye zorladıktan sonra .comb"varsayılan" skalerde ( $_) depolar, önce anonim bir dizide ( @) saklar.

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

varsayılan skalerdeki değerlerin toplamını bulur ve sıfırsa, 15 sıfırlık bir dizi içerecek varsayılan skaleri döndürür

.sum?? … !!$_

toplam sıfır değilse, önce varsayılan skalerdeki ilk öğeyi kaydırarak bir liste oluşturur

.shift, … 

ardından değerlerin geri kalanını oluşturma, varsayılan skaler değerlerin tükenmesi durumunda bir öncekine ( $^b) göre kontrol etme
, bunun yerine 0 kullanın (//0 )

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

varsayılan skalerde hiç öğe kalmadığında durma

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