Pertimbangkan urutan berdasarkan hubungan perulangan f(n) = f(n-1)+f(n-2),, dimulai dengan f(1) = x1, f(2) = x2. Sebab x1 = 2, x2 = 1, urutannya dimulai seperti ini:

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

Menggabungkan ini menjadi string akan memberikan:

213471118294776123199322521843

Sekarang, bagilah daftar ini ke dalam angka terkecil yang memungkinkan y(n) > y(n-1). Mulai dengan angka pertama, lalu yang kedua dll. Nomor output pertama harus selalu satu digit. Pad nomor terakhir dengan jumlah nol yang diperlukan.

2 13 47 111 829 4776 12319 93225 218430

Anda akan mendapatkan dua angka, (x1, x2)sebagai input, pada format apa pun yang nyaman, dan tantangannya adalah mengeluarkan daftar yang diurutkan.

Aturan:

• Fungsi dan programnya OK
• Urutan awal harus memiliki tepat 15 angka (Angka terakhir adalah f(15)).
• x1dan x2tidak negatif (nol adalah mungkin).
• Outputnya bisa dalam format apa pun yang nyaman
• Vektor keluaran yharus dibuat sedemikian rupa y2 > y1.
  • Pertama yang terkecil mungkin y1, lalu yang terkecil mungkin y2, lalu y3dan seterusnya.
• Jika x1 = x2 = 0kemudian output 15 nol (pada format yang sama dengan output lainnya, yaitu tidak 000000000000000).

Contoh :

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

Kode terpendek dalam byte menang. Harap sertakan tautan ke juru bahasa online jika memungkinkan.

Pyth, 56 byte

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

Suite uji

Penjelasan:

Pertama, kami memeriksa apakah inputnya tepat 0, 0. Jika demikian, cetak 15 nol.

Kalau tidak, kami menghasilkan urutan, dengan jkhM.u,eNsN14Q. Ini mirip dengan algoritma Pyth standar untuk urutan Fibonacci.

Selanjutnya, kami mengurangi lebih dari string ini. Akumulator adalah daftar string, yang mewakili setiap angka dalam urutan yang dibagi. Pada setiap langkah reduksi, kita mengambil karakter berikutnya, dan memeriksa apakah akumulator dalam urutan, menggunakan fungsi helper y, didefinisikan dengan LsgM.:sMb2, yang benar jika inputnya rusak. Jika sesuai, kami menambahkan karakter berikutnya ke daftar sebagai nomornya sendiri. Jika tidak, kami menambahkan karakter berikutnya ke akhir string terakhir. Ini dipenuhi dengan u?yGX_1GHaGH ... Y.

Selanjutnya, kami melakukan loop sementara fungsional. Pengulangan berlanjut hingga daftar berjalan, menggunakan kembali fungsi pembantu. Pada setiap langkah, a 0ditambahkan ke akhir string terakhir dalam daftar. Ini dipenuhi dengan .WyHX_1Z`0.

Akhirnya, string dikonversi menjadi bilangan bulat, dengan sM, dan dicetak.

Pyth, 51 byte

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

Saya percaya ini berhasil, tetapi terlalu lambat untuk menguji - ini adalah solusi brute force untuk membagi string.

Saya akan membuat beberapa perbaikan pada Xfungsi, tetapi kode di atas berfungsi dalam versi Pyth yang paling baru ketika pertanyaan diposting.

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

Uji

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 byte

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

Saya mendapatkan hasil yang sama ketika menjalankannya untuk 1,1dan 3,2menguji kasus. 0,0telah mengambil kelebihan 26 byte ...

De-golf + dikonversi ke ES5 + demo:

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 byte

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

Penjelasan

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

Uji

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 byte

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

Kasus uji:

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

Panjang nama fungsi membunuhku.

Haskell, 165 159 152 142 141 byte

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

Contoh penggunaan: 3 % 2-> [3,25,71,219,315,811,3121,23435,55898,145300].

Demo online (dengan mainpembungkus).

Bagaimana itu bekerja:

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 byte

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}

Menyimpan byte dengan menghilangkan $svariabel dan langsung memberi makan loop output.

Tidak dikumpulkan dan berkomentar:

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 byte

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

Pemakaian:

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

Penjelasan

menciptakan urutan seperti Fibonacci, dimulai dengan argumen ( @_) tergelincir ( |) di

|@_,*+*...*

mengambil 15 elemen pertama dari urutan itu

(…)[^15]

menggabungkannya menjadi string tunggal ( .join), membaginya menjadi urutan karakter individu ( .comb) dan menyimpannya dalam skalar "default" ( $_) setelah memaksa urutan tersebut ke dalam array yang dapat diubah, dengan terlebih dahulu menyimpannya dalam array anonim ( @)

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

ia menemukan jumlah nilai dalam skalar default, dan jika itu nol mengembalikan skalar default, yang akan berisi array 15 nol

.sum?? … !!$_

jika jumlahnya bukan nol, itu membuat daftar dengan terlebih dahulu menggeser elemen pertama dalam skalar default

.shift, … 

diikuti dengan menghasilkan sisa nilai, mengeceknya dengan nilai sebelumnya ( $^b)
jika skalar default kehabisan nilai, gunakan 0 sebagai gantinya ( //0)

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

berhenti ketika tidak ada elemen yang tersisa di skalar default

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