Sequenze anti-fibonacci

13

Dati tre numeri m , n e p , il tuo compito è quello di stampare un elenco / matrice di lunghezza p che inizia con m e n e ogni elemento dopo p rappresenta la differenza dei 2 numeri prima di esso, mn ( sequenza contro-fibonacci )

Per questa sfida è possibile utilizzare una funzione per restituire o stampare il risultato o un programma completo.

Ingresso

Tre numeri interi, m , n e p , separati da newline / spazi / virgole, qualunque sia la tua lingua supportata, ma dovresti specificare il tuo formato di input. L'inserimento del codice non è consentito.

Produzione

I numeri contenuti nella sequenza Counter-Fibonacci, in uno dei seguenti formati (questo esempio:) m = 50, n = 40, p = 6:

  • 50,40,10,30,-20,50 (o con spaziatura dopo le virgole)
  • [50,40,10,30,-20,50] (o con spaziatura dopo le virgole)
  • 50 40 10 30 -20 50(o con \n(newline) invece di spazi)
  • {50,40,10,30,-20,50} (o con spazi anziché virgole)

Esempi

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

Regole

  • Hai la garanzia che p è maggiore di 1
  • Dovresti fornire un modo per testare il tuo programma, se possibile
  • Si noti che queste scappatoie sono vietate e l'inserimento del codice è vietato, come menzionato sopra

Punteggio e classifica

Il tuo codice deve essere il più breve possibile, poiché si tratta di code-golf . Nessuna risposta sarà accettata , perché questa sfida ha lo scopo di trovare la risposta più breve per lingua, evitando un ingiusto vantaggio per le lingue del golf.

Mostra snippet di codice

Domanda correlata di ETHproductions: Monday Mini-Golf # 1: Reverse Fibonacci Solver

code-golf  math  number  sequence  fibonacci 
— Mr. Xcoder
fonte
Correlato, possibile duplicato. Fondamentalmente è la stessa sfida di questa, ma in ordine inverso da un punto specifico della sequenza.
— ETHproductions
@ETHproductions potrebbe essere considerato un duplicato, ma questo è un po ' diverso, cercando di vedere la soluzione più breve in ogni lingua
— Mr. Xcoder
Sì, allora non c'era molta preoccupazione per la disuguaglianza linguistica ;-) Non penso che faccia una grande differenza. La differenza principale qui è che puoi praticamente tralasciare il primo passo dell'algoritmo che avresti usato per risolvere quella sfida (lavorando all'indietro per trovare il punto di partenza)
— ETHproductions
@ETHproductions in effetti ci sono piccole differenze. Se desideri che questa sfida venga rimossa, la farò totalmente.
— Mr. Xcoder
Personalmente penso che vada bene. A parte, ci è permesso avere un separatore finale?
— ETHproductions

Risposte:

9

Haskell, 29 byte

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

La lunghezza pè il primo parametro. Esempio di utilizzo: ( (.(#)).(.).take ) 10 50 40-> [50,40,10,30,-20,50,-70,120,-190,310]. Provalo online! .

Accorciare l'elenco in pelementi richiede più byte che produrlo.

— Nome del modello
fonte
6

Gelatina , 6 byte

_@С+Ṗ

Provalo online!

Come funziona

_@С+Ṗ  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
fonte
5

JavaScript (ES6), 33 byte

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

Restituisce una stringa del formato 1,2,3, - senza usare stringhe!

Test snippet

Mostra snippet di codice

— ETHproductions
fonte
5

Perl 6 , 25 byte

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

Provalo

Allargato:

{  # 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
fonte
5

CJam , 15 byte

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

1 byte extra perché CJam non utilizza naturalmente uno dei formati di output consentiti> _ <

Provalo online!

Spiegazione

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
— Gatto di affari
fonte
4

05AB1E , 9 7 byte

ÍFÂ2£¥«

Provalo online!

Spiegazione

Í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
fonte
3

Röda , 38 byte

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

Provalo online!

Ha spiegato:

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
fonte
3

Haskell , 33 byte

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

Chiama usando (m!n)p. Opere definendo !come funzione infisso che accoglie med ne restituisce una funzione che prende pe restituisce il risultato desiderato.

— Julian Wolf
fonte
Bello! Non ho pensato di fare la funzione infix, quindi il mio miglior tentativo con haskell è stato 34. A proposito, puoi sostituire la nuova riga con ;per renderla a linea singola, quindi sembra un po 'più codegolfy.
— AlexJ136,
2

Rubino, 31 byte

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

La soluzione semplice

— GB
fonte
2

PHP, 76 byte

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

PHP, 84 byte

[,$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
fonte
2

Pyth, 18 byte

JEKEVEJ=N-JK=JK=KN

Provalo online!

Input e output sono entrambi delimitati da newline.

Come funziona:

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
fonte
1

Mathematica, 26 byte

{-1,1}~LinearRecurrence~##

Adoro l'edificio. Accetta input nel modulo {{m, n}, p}. LinearRecurrencevuole conoscere i coefficienti della combinazione lineare di elementi precedenti da utilizzare per generare nuovi elementi, che in questo caso è {-1,1}.

— Greg Martin
fonte
1

QBIC , 35 33 byte

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

Salvato 2 byte inserendo il primo PRINTin un codice letterale.

Spiegazione (versione 35 byte):

:::         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
fonte
Hai idea di un interprete online per testarlo?
— Mr. Xcoder
@ Mr.Xcoder ancora nessun interprete online, scusa. Ho aggiunto un link all'interprete, che è un progetto DOSBOX che esegue QBasic, che esegue QBIC.
— Steenbergh,
1
La spiegazione vale più dell'interprete @steenbergh, grazie per aver risposto!
— Mr. Xcoder
1

C, 128 byte

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

Questo programma analizza i tre argomenti m, nep dalla riga di comando, e stampa l'output come specificato.

I moderni compilatori C ti consentono di omettere le importazioni di base, e quindi possiamo usare printfe atoisenza#include s.

Le variabili globali sono intpredefinite se dichiarate senza un tipo: ciò consente di risparmiare molto spazio.

— AlexJ136
fonte
1

Java, 66 byte

Per una volta, i lambda sono l'approccio inefficace al golf a causa del modo molto rotondo di applicare la ricorsione a loro che richiede molti byte extra.

golfed:

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) : "");
  }
}
— Comunità
fonte
1

AHK, 68 byte

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

Ottenere' veramente stanco di non saper / poter utilizzare argomenti passati ( %1%, %2%, ...) direttamente in tutte le funzioni matematiche

— Ingegnere Toast
fonte
1

Python 2 , 93 90 byte

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

Provalo online!

Salvato 3 byte grazie a @ Mr.Xcoder

Funziona prendendo i numeri come input e formattandoli correttamente, quindi usando un ciclo for per generare un elenco basato sui numeri immessi.

— Compagno SparklePony
fonte
È possibile rimuovere lo spazio dopo la virgola in quell'intervallo per salvare 1 byte
— Mr. Xcoder
E potrebbe essere più breve se si mappa l'input con ints e input.split
— Mr. Xcoder
@ Mr.Xcoder Ho provato la divisione, ma alla fine è stata più lunga.
— Compagno SparklePony,
Ok, non ho potuto provarlo. Va bene lo stesso.
— Mr. Xcoder
E la gamma non ha bisogno del primo argomento
— Mr. Xcoder
0

Rapido - 85 byte

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

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

Swift - 84 byte

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

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

Produzione:

50
40
10
30
-20
50
— Mr. Xcoder
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.