Betrachten Sie eine Sequenz, die auf Wiederholungsrelationen basiert f(n) = f(n-1)+f(n-2), beginnend mit f(1) = x1, f(2) = x2. Denn x1 = 2, x2 = 1die Sequenz beginnt so:

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

Wenn Sie dies in eine Zeichenfolge verketten, erhalten Sie Folgendes:

213471118294776123199322521843

Teilen Sie diese Liste nun in die kleinstmöglichen Zahlen auf y(n) > y(n-1). Beginnen Sie mit der ersten Nummer, dann mit der zweiten usw. Die erste Ausgangsnummer sollte immer eine einzelne Ziffer sein. Füllen Sie die letzte Zahl mit der erforderlichen Anzahl von Nullen auf.

2 13 47 111 829 4776 12319 93225 218430

Sie erhalten zwei Zahlen (x1, x2)als Eingabe in einem beliebigen Format, und die Herausforderung besteht darin, die sortierte Liste auszugeben.

Regeln:

• Funktion und Programme sind OK
• Die Anfangssequenz muss genau 15 Ziffern haben (die letzte Ziffer ist f(15)).
• x1und x2sind nicht negativ (Null ist möglich).
• Die Ausgabe kann in jedem beliebigen Format erfolgen
• Der Ausgabevektor ymuss so erstellt werden y2 > y1.
  • Zunächst wird die kleinstmögliche y1, dann ist die kleinstmögliche y2, dann y3und so weiter.
• Wenn x1 = x2 = 0dann 15 Nullen ausgeben (im selben Format wie andere Ausgaben, dh nicht 000000000000000).

Beispiele :

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

Der kürzeste Code in Bytes gewinnt. Bitte fügen Sie nach Möglichkeit einen Link zu einem Online-Dolmetscher bei.

Pyth, 56 Bytes

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

Testsuite

Erläuterung:

Zuerst prüfen wir, ob die Eingabe genau ist 0, 0 . Wenn ja, drucken Sie 15 Nullen.

Ansonsten erstellen wir die Sequenz mit jkhM.u,eNsN14Q . Dies ähnelt dem Standard-Pyth-Algorithmus für die Fibonacci-Sequenz.

Als nächstes reduzieren wir diesen String. Der Akkumulator ist eine Liste von Zeichenfolgen, die jede Zahl in der unterteilten Sequenz darstellen. Bei jedem Verkleinerungsschritt nehmen wir das nächste Zeichen und prüfen mithilfe der ymit definierten LsgM.:sMb2Hilfsfunktion , ob der Akku in Ordnung ist , was wahr ist, wenn die Eingabe nicht in Ordnung ist. Wenn es in Ordnung ist, hängen wir das nächste Zeichen als eigene Nummer an die Liste an. Wenn nicht, fügen wir das nächste Zeichen am Ende der letzten Zeichenfolge hinzu. Dies geschieht mit u?yGX_1GHaGH ... Y.

Als nächstes führen wir eine funktionale while-Schleife durch. Die Schleife wird fortgesetzt, bis die Laufliste in Ordnung ist, und die Hilfsfunktion erneut verwendet. Bei jedem Schritt wird ein 0an das Ende der letzten Zeichenfolge in der Liste angefügt. Dies geschieht mit .WyHX_1Z`0.

Schließlich werden die Zeichenfolgen in Ganzzahlen konvertiert, mit sMund gedruckt.

Pyth, 51 Bytes

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

Ich glaube, das funktioniert, aber es ist viel zu langsam zum Testen - es ist eine Brute-Force-Lösung zum Teilen der Saite.

Ich werde einige Verbesserungen an der XFunktion vornehmen, aber der obige Code funktioniert in der Version von Pyth, die zuletzt verwendet wurde, als die Frage gepostet wurde.

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

Prüfung

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

Ich erhalte ähnliche Ergebnisse beim Ausführen 1,1und 3,2Testen von Fällen. 0,0hat mehr als 26 Bytes benötigt ...

De-Golf + konvertiert zu 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` `)

Erläuterung

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

Prüfung

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 Bytes

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

Testfälle:

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

Die Länge der Funktionsnamen bringt mich um.

Haskell, 165 159 152 142 141 Bytes

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

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

Online-Demo (mit einem mainWrapper).

Wie es funktioniert:

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 Bytes

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}

Ein Byte wurde gespeichert, indem die $sVariable entfernt und nur die Ausgangsschleife direkt gespeist wurde.

Ungolfed und kommentiert:

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 Bytes

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

Verwendung:

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

Erläuterung

Erstellt eine Fibonacci-ähnliche Sequenz, beginnend mit den Argumenten ( @_), in die slipped ( |) eingefügt wurde

|@_,*+*...*

Nimmt die ersten 15 Elemente dieser Sequenz

(…)[^15]

kombiniert dies zu einer einzelnen Zeichenfolge ( .join), teilt sie in eine Folge von einzelnen Zeichen ( .comb) auf und speichert sie im "Standard" $_-Skalar ( ), nachdem die Folge in ein veränderbares Array umgewandelt wurde, indem sie zuerst in einem anonymen Array ( @) gespeichert wird.

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

Er findet die Summe der Werte im Standardskalar. Wenn dies Null ist, wird der Standardskalar zurückgegeben, der ein Array mit 15 Nullen enthält

.sum?? … !!$_

Wenn die Summe nicht Null ist, wird eine Liste erstellt, indem zuerst das erste Element im Standardskalar entfernt wird

.shift, … 

Anschließend werden die restlichen Werte generiert und mit den vorherigen verglichen. ( $^b)
Wenn der Standard-Skalar keine Werte mehr enthält, verwenden Sie stattdessen 0 ( //0).

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

Anhalten, wenn im Standardskalar keine Elemente mehr vorhanden sind

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