Sequências de Contra-Fibonacci

13

Dadas três números de m , n e p , a sua tarefa é imprimir uma lista / matriz de comprimento p começando com m e n e cada elemento após p representa a diferença entre os números 2, antes disso, Mn (Contra Fibonacci Sequência )

Para esse desafio, você pode usar uma função para retornar ou imprimir o resultado ou um programa completo.

Entrada

Três inteiros, m , n e p , separados por novas linhas / espaços / vírgulas, quaisquer que sejam os seus suportes de linguagem, mas você deve especificar o seu formato de entrada. A inserção de código não é permitida.

Resultado

Os números contidos pela sequência Counter-Fibonacci, em qualquer um dos seguintes formatos (neste exemplo m = 50, n = 40, p = 6:):

  • 50,40,10,30,-20,50 (ou com espaçamento após vírgulas)
  • [50,40,10,30,-20,50] (ou com espaçamento após vírgulas)
  • 50 40 10 30 -20 50(ou com \n(novas linhas) em vez de espaços)
  • {50,40,10,30,-20,50} (ou com espaços em vez de vírgulas)

Exemplos

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

Regras

  • Você tem a garantia de que p é maior que 1
  • Você deve fornecer uma maneira de testar seu programa, se possível
  • Observe que essas brechas são proibidas e a inserção de código não é permitida, conforme mencionado acima

Pontuação e Classificação

Seu código deve ser o mais curto possível, pois é um código-golfe . Nenhuma resposta será aceita , porque esse desafio visa encontrar a resposta mais curta por idioma, evitando uma vantagem injusta para os idiomas do golfe.

Mostrar snippet de código

Pergunta relacionada por ETHproductions: Segunda-feira Mini-Golf # 1: Solucionador de Fibonacci reverso

code-golf  math  number  sequence  fibonacci 
— Mr. Xcoder
fonte
Relacionado, possível duplicado. É basicamente o mesmo desafio que este, mas é emitido em ordem inversa a partir de um ponto específico na sequência.
— ETHproductions
@ETHproductions pode ser considerado um ingênuo, mas este é um pouco diferente, tentando ver a solução mais curta em cada idioma
— Mr. Xcoder
Sim, não havia tanta preocupação com a desigualdade de idiomas naquela época ;-) Mas acho que não faz muita diferença. A principal diferença aqui é que você pode muito bem deixar de fora o primeiro passo do algoritmo que você teria usado para resolver esse desafio (para trás trabalhar para encontrar o ponto de partida)
— ETHproductions
@ETHproductions de fato, existem pequenas diferenças. Se você deseja que esse desafio seja removido, eu o farei totalmente.
— Mr. Xcoder
Eu pessoalmente acho que está bem. Além disso, podemos ter um separador à direita?
— ETHproductions

Respostas:

9

Haskell, 29 bytes

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

Comprimento pé o primeiro parâmetro. Exemplo de uso: ( (.(#)).(.).take ) 10 50 40-> [50,40,10,30,-20,50,-70,120,-190,310]. Experimente online! .

Reduzir a lista para pelementos leva mais bytes do que produzi-la.

— nimi
fonte
6

Gelatina , 6 bytes

_@С+Ṗ

Experimente online!

Como funciona

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

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

Retorna uma string do formato 1,2,3,- sem usar strings!

Snippet de teste

Mostrar snippet de código

— ETHproductions
fonte
5

Perl 6 , 25 bytes

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

Tente

Expandido:

{  # 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 bytes

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

1 byte extra porque o CJam não usa naturalmente um dos formatos de saída permitidos> _ <

Experimente online!

Explicação

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
— Gato de negócios
fonte
4

05AB1E , 9 7 bytes

ÍFÂ2£¥«

Experimente online!

Explicação

Í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 bytes

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

Experimente online!

Explicado:

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 bytes

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

Ligue usando (m!n)p. Trabalhos por definição !como uma função infixa que leva em me ne retorna uma função que recebe pe devolve o resultado desejado.

— Julian Wolf
fonte
Agradável! Eu não pensei em criar o infixo da função, então minha melhor tentativa com haskell foi 34. BTW, você pode substituir a nova linha por uma linha ;única, para que pareça um pouco mais de codegolfia.
— AlexJ136
2

Ruby, 31 bytes

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

A solução direta

— GB
fonte
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
fonte
2

Pitão, 18 bytes

JEKEVEJ=N-JK=JK=KN

Experimente online!

Entrada e saída são delimitadas por novas linhas.

Como funciona:

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 bytes

{-1,1}~LinearRecurrence~##

Amando o construído. Recebe entrada no formulário {{m, n}, p}. LinearRecurrencedeseja conhecer os coeficientes da combinação linear de elementos anteriores para gerar novos elementos, o que, neste caso, é {-1,1}.

— Greg Martin
fonte
1

QBIC , 35 33 bytes

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

Economizou 2 bytes colocando o primeiro PRINTem um literal de código.

Explicação (versão de 35 bytes):

:::         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
Tem alguma idéia de um intérprete online para testar isso?
— Mr. Xcoder
@ Mr.Xcoder nenhum intérprete online ainda, desculpe. Adicionei um link ao intérprete, que é um projeto DOSBOX executando o QBasic, executando o QBIC.
— 22417
1
A explicação vale mais do que o intérprete @steenbergh, obrigado por responder!
— Sr. Xcoder 16/03/19
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);}

Este programa analisa os três argumentos m, nep a partir da linha de comando, e imprime a saída, conforme especificado.

Os compiladores C modernos permitem omitir importações básicas e, portanto, podemos usar printfe atoisem o#include s.

As variáveis ​​globais são intpor padrão quando declaradas sem um tipo - isso economiza muito espaço.

— AlexJ136
fonte
1

Java, 66 bytes

Pela primeira vez, lambdas são a abordagem ineficiente para golfe devido ao muito forma indireta de aplicar recursão a eles que requer uma grande quantidade de bytes extras.

Golfe:

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) : "");
  }
}
— Comunidade
fonte
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
}

Obtendo' realmente cansado de não saber / poder usar argumentos passados ( %1%, %2%...) diretamente em quaisquer funções matemáticas

— Engenheiro Toast
fonte
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])

Experimente online!

Guardado 3 bytes graças a @ Mr.Xcoder

Ele funciona pegando os números como entrada e formatando-os corretamente e, em seguida, usando um loop for para gerar uma lista com base nos números introduzidos.

— Camarada SparklePony
fonte
Você pode remover o espaço após a vírgula nesse intervalo para salvar 1 byte
— Mr. Xcoder
E pode ser mais curto se você mapear a sua entrada com ints e input.split
— Mr. Xcoder
@ Mr.Xcoder Eu tentei a divisão, mas acabou sendo mais longa.
— Camarada SparklePony
Ok, eu não pude testar. É bom de qualquer maneira.
— Mr. Xcoder
E o intervalo não precisa do primeiro argumento
— Sr. Xcoder 18/03
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}}

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

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

Resultado:

50
40
10
30
-20
50
— Mr. Xcoder
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.