Séquences contre-Fibonacci

13

Étant donné trois nombres m , n et p , votre tâche consiste à imprimer une liste / un tableau de longueur p commençant par m et n et chaque élément après p représente la différence des 2 nombres qui le précèdent, mn ( séquence Counter- Fibonacci )

Pour ce défi, vous pouvez utiliser une fonction pour retourner ou imprimer le résultat ou un programme complet.

Contribution

Trois entiers, m , n et p , séparés par des retours à la ligne / des espaces / des virgules, quel que soit votre langage, mais vous devez spécifier votre format d'entrée. L'insertion de code n'est pas autorisée.

Production

Les nombres contenus par la séquence Counter-Fibonacci, dans l'un des formats suivants (cet exemple:) m = 50, n = 40, p = 6:

  • 50,40,10,30,-20,50 (ou avec un espacement après des virgules)
  • [50,40,10,30,-20,50] (ou avec un espacement après des virgules)
  • 50 40 10 30 -20 50(ou avec \n(nouvelles lignes) au lieu d'espaces)
  • {50,40,10,30,-20,50} (ou avec des espaces au lieu de virgules)

Exemples

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

Règles

  • Vous avez la garantie que p est supérieur à 1
  • Vous devez fournir un moyen de tester votre programme, si possible
  • Prenez note que ces failles sont interdites et l'insertion de code est interdite, comme mentionné ci-dessus

Score et classement

Votre code doit être aussi court que possible, car il s'agit de code-golf . Aucune réponse ne sera acceptée , car ce défi vise à trouver la réponse la plus courte par langue, en évitant un avantage indu aux langues de golf.

Afficher l'extrait de code

Question connexe par ETHproductions: Lundi Mini-Golf # 1: Solveur Fibonacci inversé

code-golf  math  number  sequence  fibonacci 
— M. Xcoder
source
Associé, doublon possible. C'est fondamentalement le même défi que celui-ci, mais la sortie dans l'ordre inverse à partir d'un endroit spécifique de la séquence.
— ETHproductions
@ETHproductions pourrait être considéré comme une dupe, mais c'est un peu différent, en essayant de voir la solution la plus courte dans chaque langue
— M. Xcoder
Ouais, on ne s'inquiétait pas autant de l'inégalité linguistique à l'époque ;-) Je ne pense pas que cela fasse une grande différence. La principale différence ici est que vous pouvez à peu près ignorer la première étape de l'algorithme que vous auriez utilisé pour résoudre ce défi (en travaillant en arrière pour trouver le point de départ)
— ETHproductions
@ETHproductions en effet il y a de petites différences. Si vous souhaitez que ce défi soit supprimé, je le ferai totalement.
— M. Xcoder
Personnellement, je pense que ça va. À part, avons-nous le droit d'avoir un séparateur arrière?
— ETHproductions

Réponses:

9

Haskell, 29 octets

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

La longueur pest le premier paramètre. Exemple d'utilisation: ( (.(#)).(.).take ) 10 50 40-> [50,40,10,30,-20,50,-70,120,-190,310]. Essayez-le en ligne! .

Raccourcir la liste en péléments prend plus d'octets que de la produire.

— nimi
source
6

Gelée , 6 octets

_@С+Ṗ

Essayez-le en ligne!

Comment ça fonctionne

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

JavaScript (ES6), 33 octets

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

Renvoie une chaîne du format 1,2,3,- sans utiliser de chaînes!

Extrait de test

Afficher l'extrait de code

— ETHproductions
source
5

Perl 6 , 25 octets

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

Essayez-le

Étendu:

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

CJam , 15 octets

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

1 octet supplémentaire car CJam n'utilise pas naturellement l'un des formats de sortie autorisés> _ <

Essayez-le en ligne!

Explication

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
— Chat d'affaires
source
4

05AB1E , 9 7 octets

ÍFÂ2£¥«

Essayez-le en ligne!

Explication

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

Röda , 38 octets

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

Essayez-le en ligne!

Expliqué:

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

Haskell , 33 octets

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

Appelez en utilisant (m!n)p. Travaux en définissant !comme une fonction qui prend en infix met net retourne une fonction qui prend pet renvoie le résultat souhaité.

— Julian Wolf
source
Agréable! Je ne pensais pas à faire la fonction infixe, donc mon meilleur essai avec haskell était 34. BTW vous pouvez remplacer la nouvelle ligne avec ;pour la rendre sur une seule ligne, donc ça a l'air un peu plus de codegolfy.
— AlexJ136
2

Rubis, 31 octets

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

La solution simple

— GB
source
2

PHP, 76 octets

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

PHP, 84 octets

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

Pyth, 18 octets

JEKEVEJ=N-JK=JK=KN

Essayez-le en ligne!

L'entrée et la sortie sont toutes deux délimitées par des retours à la ligne.

Comment ça fonctionne:

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

Mathematica, 26 octets

{-1,1}~LinearRecurrence~##

Lovin 'le builtin. Prend la saisie dans le formulaire {{m, n}, p}. LinearRecurrenceveut connaître les coefficients de la combinaison linéaire des éléments précédents à utiliser pour générer de nouveaux éléments, ce qui est le cas dans ce cas {-1,1}.

— Greg Martin
source
1

QBIC , 35 33 octets

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

Enregistré 2 octets en plaçant le premier PRINTdans un littéral de code.

Explication (version 35 octets):

:::         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
source
Avez-vous une idée d'un interprète en ligne pour tester cela?
— M. Xcoder
@ Mr.Xcoder pas encore d'interprète en ligne, désolé. J'ai ajouté un lien vers l'interpréteur, qui est un projet DOSBOX exécutant QBasic, exécutant QBIC.
— steenbergh
1
L'explication vaut plus que l'interprète @steenbergh, merci d'avoir répondu!
— M. Xcoder
1

C, 128 octets

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

Ce programme analyse les trois arguments m, netp partir de la ligne de commande, et imprime la sortie comme spécifié.

Les compilateurs C modernes vous permettent d'omettre les importations de base, et donc nous pouvons utiliser printfet atoisans le#include s.

Les variables globales sont int par défaut lorsqu'elles sont déclarées sans type - cela économise beaucoup d'espace.

— AlexJ136
source
1

Java, 66 octets

Pour une fois, les lambdas sont l'approche inefficace du golf en raison de la très détournée de leur appliquer la récursivité qui nécessite beaucoup d'octets supplémentaires.

Golfé:

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

Non golfé:

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) : "");
  }
}
— Communauté
source
1

AHK, 68 octets

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

Obtenir » vraiment fatigué de ne pas savoir comment / pouvoir utiliser les arguments passés ( %1%, %2%, ...) directement dans toutes les fonctions mathématiques

— Ingénieur Toast
source
1

Python 2 , 93 90 octets

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

Essayez-le en ligne!

Sauvegardé 3 octets grâce à @ Mr.Xcoder

Il fonctionne en prenant les nombres en entrée et en les formatant correctement, puis en utilisant une boucle for pour générer une liste basée sur les nombres entrés.

— Camarade SparklePony
source
Vous pouvez supprimer l'espace après une virgule dans cette plage pour économiser 1 octet
— M. Xcoder
Et cela peut être plus court si vous mappez votre entrée avec des entiers et input.split
— M. Xcoder
@ Mr.Xcoder J'ai essayé la séparation, mais elle a fini par être plus longue.
— Camarade SparklePony
Ok, je n'ai pas pu le tester. C'est bon quand même.
— M. Xcoder
Et la gamme n'a pas besoin du premier argument
— M. Xcoder
0

Swift - 85 octets

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

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

Swift - 84 octets

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

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

Production:

50
40
10
30
-20
50
— M. Xcoder
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.