Counter-Fibonacci-Sequenzen

13

Bei drei gegebenen Zahlen m , n und p besteht Ihre Aufgabe darin, eine Liste / ein Array der Länge p zu drucken, die mit m und n beginnt, und jedes Element nach p stellt die Differenz der beiden Zahlen davor dar, mn (Counter- Fibonacci-Sequenz ).

Für diese Herausforderung können Sie entweder eine Funktion verwenden, um das Ergebnis zurückzugeben oder auszudrucken, oder ein vollständiges Programm.

Eingang

Drei Ganzzahlen, m , n und p , getrennt durch Zeilenumbrüche / Leerzeichen / Kommas, unabhängig von der von Ihnen unterstützten Sprache. Sie sollten jedoch Ihr Eingabeformat angeben. Das Einfügen von Code ist nicht zulässig.

Ausgabe

Die in der Counter-Fibonacci-Sequenz enthaltenen Zahlen in einem der folgenden Formate (dieses Beispiel:) m = 50, n = 40, p = 6:

  • 50,40,10,30,-20,50 (oder mit Abstand nach Komma)
  • [50,40,10,30,-20,50] (oder mit Abstand nach Komma)
  • 50 40 10 30 -20 50(oder mit \n(Newlines) anstelle von Leerzeichen)
  • {50,40,10,30,-20,50} (oder mit Leerzeichen anstelle von Kommas)

Beispiele

Input => Output

50,40,10 => 50,40,10,30,-20,50,-70,120,-190,310
-100,-90,7 => -100,-90,-10,-80,70,-150,220
250,10,8 => 250,10,240,-230,470,-700,1170,-1870

Regeln

  • Es ist garantiert, dass p höher als 1 ist
  • Sie sollten nach Möglichkeit eine Möglichkeit zum Testen Ihres Programms bereitstellen
  • Beachten Sie, dass diese Lücken verboten sind und das Einfügen von Code, wie oben erwähnt, nicht gestattet ist

Wertung & Bestenliste

Ihr Code muss so kurz wie möglich sein, da dies Code-Golf ist . Es wird keine Antwort akzeptiert , da diese Herausforderung darauf abzielt, die kürzeste Antwort nach Sprache zu finden, um einen unfairen Vorteil gegenüber Golfsprachen zu vermeiden.

Code-Snippet anzeigen

Verwandte Frage von ETHproductions: Montag Minigolf # 1: Reverse Fibonacci Solver

code-golf  math  number  sequence  fibonacci 
— Mr. Xcoder
quelle
Verwandte, mögliche Duplikate. Es ist im Grunde die gleiche Herausforderung wie diese, aber die Ausgabe erfolgt in umgekehrter Reihenfolge an einer bestimmten Stelle in der Sequenz.
— ETHproductions
@ETHproductions könnte als Betrug betrachtet werden, aber dies ist ein bisschen anders und versucht, die kürzeste Lösung in jeder Sprache zu finden
— Mr. Xcoder
Ja, es gab damals nicht so viele Sorgen wegen der Ungleichheit der Sprachen ;-) Ich denke, das macht jedoch keinen großen Unterschied. Der Hauptunterschied besteht darin, dass Sie den ersten Schritt des Algorithmus, den Sie verwendet hätten, um diese Herausforderung zu lösen, so
— ziemlich auslassen können
@ETHproductions in der Tat gibt es kleine Unterschiede. Wenn Sie möchten, dass diese Herausforderung beseitigt wird, mache ich das komplett.
— Mr. Xcoder
Ich persönlich finde es in Ordnung. Dürfen wir ein nachgestelltes Trennzeichen haben?
— ETHproductions

Antworten:

9

Haskell, 29 Bytes

a#b=a:b#(a-b)
(.(#)).(.).take

Länge pist der erste Parameter. Anwendungsbeispiel: ( (.(#)).(.).take ) 10 50 40-> [50,40,10,30,-20,50,-70,120,-190,310]. Probieren Sie es online! .

Das Kürzen der Liste auf pElemente benötigt mehr Bytes als das Erzeugen.

— nimi
quelle
6

Gelee , 6 Bytes

_@С+Ṗ

Probieren Sie es online!

Wie es funktioniert

_@С+Ṗ  Main link. Left argument: m. Right argument: n. Third argument: p

    +   Yield (m + n), the term that comes before m.
  С    Execute the link to the left p times, starting with left argument m and
        right argument (m + n). After each execution, replace the right argument
        with the left one and the left argument with the previous return value.
        Yield all intermediate values of the left argument, starting with m.
_@          Subtract the left argument from the right one.
        This yields the first (p + 1) terms of the sequence, starting with m.
    Ṗ   Pop; discard the last term.
— Dennis
quelle
5

JavaScript (ES6), 33 Byte

f=(m,n,p)=>p?m+[,f(n,m-n,p-1)]:[]

Liefert einen String des Formats 1,2,3,- ohne Verwendung von Strings!

Testschnipsel

Code-Snippet anzeigen

— ETHproductions
quelle
5

Perl 6 , 25 Bytes

{($^m,$^n,*-*...*)[^$^p]}

Versuch es

Erweitert:

{  # bare block lambda with placeholder parameters ｢$m｣ ｢$n｣ ｢$p｣
  (
    $^m, $^n,  # declare first two params, and use them

    * - *      # WhateverCode lambda which subtracts two values

    ...        # keep using that to generate values

    *          # never stop (instance of type Whatever)

  )[ ^ $^p ]   # declare last param, and use it to grab the wanted values
               # ｢^ $^p｣ is short form of range op
               # ｢0 ..^ $^p｣ which excludes the ｢$p｣
}
— Brad Gilbert b2gills
quelle
5

CJam , 15 Bytes

q~2-{1$1$-}*]S*

1 zusätzliches Byte, da CJam keines der zulässigen Ausgabeformate> _ <verwendet

Probieren Sie es online!

Erläuterung

q~               e# Read and eval the input
  2-             e# Subtract 2 from p (to account for m and n being in the list)
    {            e# Run this block p-2 times:
     1$1$-       e#   Copy the top values and subtract
          }*     e# (end of block)
            ]    e# Wrap the stack in an array
             S*  e# Join with spaces
— Geschäfts-Katze
quelle
4

05AB1E , 9 7 Bytes

ÍFÂ2£¥«

Probieren Sie es online!

Erläuterung

ÍF          # p-2 times do
  Â         # create a reversed copy of the current list
   2£       # take the first 2 elements of the list
     ¥      # calculate delta
      «     # append to the list
— Emigna
quelle
3

Röda , 38 Bytes

f i,a,b{seq 1,i|{|_|[a];b=a-b;a=a-b}_}

Probieren Sie es online!

Erklärt:

f i,a,b{seq 1,i|{|_|[a];b=a-b;a=a-b}_}
f i,a,b{                             } /* Function declaration */
        seq 1,i                        /* Push numbers 1..i to the stream */
               |{|_|               }_  /* For each number in the stream: */
                    [a];               /*   Push the current value of a */
                        b=a-b;         /*   Set b = the next number */
                              a=a-b    /*   Set a = the previous value of b */
— fergusq
quelle
3

Haskell , 33 Bytes

(m!n)0=[]
(m!n)p=m:(n!(m-n))(p-1)

Mit anrufen (m!n)p. Funktioniert durch Definieren !als eine Infix-Funktion, die einnimmtm und nund gibt eine Funktion , die nimmt , pund gibt das gewünschte Ergebnis.

— Julian Wolf
quelle
Nett! Ich habe nicht daran gedacht, das Funktions-Infix zu machen, deshalb war mein bester Versuch mit haskell 34. Übrigens können Sie die Newline durch eine Singleline ersetzen ;, so dass sie ein bisschen codegolfiger aussieht.
— AlexJ136
2

Ruby, 31 Bytes

->m,n,p{p.times{m,n=n,(p m)-n}}

Die unkomplizierte Lösung

— GB
quelle
2

PHP, 76 Bytes

[,$a,$b,$c]=$argv;for($r=[$a,$b];$c---2;)$r[]=-end($r)+prev($r);print_r($r);

PHP, 84 Bytes

[,$a,$b,$c]=$argv;for($r=[$a,$b];$c>$d=count($r);)$r[]=$r[$d-2]-end($r);print_r($r);
— Jörg Hülsermann
quelle
2

Pyth, 18 Bytes

JEKEVEJ=N-JK=JK=KN

Probieren Sie es online!

Eingabe und Ausgabe werden durch Zeilenumbrüche getrennt.

Wie es funktioniert:

JEKE                Read two lines of input to J and K
    VE              Read another line and loop that many times:
      J               Print J
       =N-JK          Set N to J - K (Pyth uses prefix notation)
            =JK       Set J to K
               =KN    Set K to N
— draziwfozo
quelle
1

Mathematica, 26 Bytes

{-1,1}~LinearRecurrence~##

Lovin 'the builtin. Nimmt Eingaben in das Formular auf {{m, n}, p}. LinearRecurrencewill das wissen die koeffizienten der linearen kombination vorheriger elemente verwenden um neue elemente zu generieren, was in diesem fall so ist {-1,1}.

— Greg Martin
quelle
1

QBIC , 35 33 Bytes

:::?'a;b;`[c-2|e=a-b?e';`┘a=b┘b=e

2 Bytes durch Platzieren des ersten PRINTin ein Code-Literal gespeichert .

Erläuterung (35-Byte-Version):

:::         Get parameters a, b, c from the cmd-line
  ';`       This suppresses a newline when printing
?a   b';`   PRINT a and b
[c-2|       FOR x=1; x<=(c-2); x++
  e=a-b       calculate the next term of the sequence
  ?e';`       Print it, suppressing newline
  ┘a=b        ┘ denotes a syntactic linebreak; shove the numbers one over
  ┘b=e        dito
            FOR-loop is auto-closed
— steenbergh
quelle
Haben Sie eine Idee eines Online-Dolmetschers, um dies zu testen?
— Mr. Xcoder
@ Mr.Xcoder noch kein Online-Dolmetscher, sorry. Ich habe einen Link zum Interpreter hinzugefügt, bei dem es sich um ein DOSBOX-Projekt handelt, in dem QBasic und QBIC ausgeführt werden.
— Steenbergh
1
Die Erklärung ist mehr wert als der Dolmetscher @steenbergh, danke für die Antwort!
— Mr. Xcoder
1

C 128 Bytes

m,n,p,z;main(c,v)char**v;{m=atoi(v[1]);n=atoi(v[2]);p=atoi(v[3])-2;printf("%d,%d",m,n);while(p--)z=m,m=n,n=z-m,printf(",%d",n);}

Dieses Programm analysiert die drei Argumente m, nund pvon der Befehlszeile, und druckt die Ausgabe als angegeben.

Moderne C-Compiler ermöglichen es Ihnen, grundlegende Importe wegzulassen, und so können wir printfund atoiohne die #includes verwenden.

Globale Variablen werden intstandardmäßig ohne Typ deklariert - dies spart viel Platz.

— AlexJ136
quelle
1

Java, 66 Bytes

Ausnahmsweise sind Lambdas die ineffiziente Herangehensweise an das Golfen, da sie auf sehr umständliche Weise rekursiv angewendet werden was eine Menge zusätzlicher Bytes erfordert.

Golf gespielt:

String f(int m,int n,int p){return""+m+(p>1?","+f(n,m-n,p-1):"");}

Ungolfed:

public class CounterFibonacciSequences {

  private static final int[][] INPUTS = new int[][] { //
      { 50, 40, 10 }, //
      { -100, -90, 7 }, //
      { 250, 10, 8 } };

  private static final String[] OUTPUTS = new String[] { //
      "50,40,10,30,-20,50,-70,120,-190,310", //
      "-100,-90,-10,-80,70,-150,220", //
      "250,10,240,-230,470,-700,1170,-1870" };

  public static void main(String[] args) {
    for (int i = 0; i < INPUTS.length; ++i) {
      final int m = INPUTS[i][0];
      final int n = INPUTS[i][1];
      final int p = INPUTS[i][2];
      System.out.println("M: " + m);
      System.out.println("N: " + n);
      System.out.println("P: " + p);
      System.out.println("Expected: " + OUTPUTS[i]);
      System.out.println("Actual:   " + new CounterFibonacciSequences().f(m, n, p));
      System.out.println();
    }
  }

  String f(int m, int n, int p) {
    return "" + m + (p > 1 ? "," + f(n, m - n, p - 1) : "");
  }
}
— Gemeinschaft
quelle
1

AHK, 68 Bytes

m=%1%
n=%2%
3-=2
Send %m%`n%n%`n
Loop,%3%
{
n:=m-n
m-=n
Send %n%`n
}

Erst‘wirklich müde, nicht zu wissen , wie / die Lage, übergebenen Argumente zu verwenden ( %1%, %2%, ...) direkt in irgendwelchen mathematischen Funktionen

— Ingenieur Toast
quelle
1

Python 2 , 93 90 Bytes

u,t=int,input;m,n,p=u(t()),u(t()),u(t());l=[m,n]
for i in range(p-2):l.append(l[-2]-l[-1])

Probieren Sie es online!

3 Bytes gespart dank @ Mr.Xcoder

Es funktioniert, indem die Zahlen als Eingabe genommen und richtig formatiert werden und dann eine for-Schleife verwendet wird, um eine Liste basierend auf den eingegebenen Zahlen zu generieren.

— Genosse SparklePony
quelle
Sie können das Leerzeichen nach dem Komma in diesem Bereich entfernen, um 1 Byte zu speichern
— Mr. Xcoder
Und es kann kürzer sein, wenn Sie Ihre Eingabe mit ints und input.split zuordnen
— Mr. Xcoder
@ Mr.Xcoder Ich habe versucht, die Aufteilung, aber es endete länger.
— Genosse SparklePony
Ok, ich konnte es nicht testen. Es ist trotzdem gut.
— Mr. Xcoder
Und der Bereich braucht nicht das erste Argument
— Mr. Xcoder
0

Swift - 85 Bytes

func y(x:Int,y:Int,z:Int){var m=x,n=y,p=z,c=0;for _ in 1...p{print(m);c=m;m=n;n=c-n}}

Verwendung: y(x:50,y:40,x:6)

Swift - 84 Bytes

func z(l:[Int]){var m=l[0],n=l[1],p=l[2],c=0;for _ in 1...p{print(m);c=m;m=n;n=c-n}}

Verwendung: z(l: [50,40,6])

Ausgabe:

50
40
10
30
-20
50
— Mr. Xcoder
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.