Comprimento de uma sequência de Sumac [fechada]


11

Uma sequência Sumac começa com dois números inteiros: t 1 e t 2 .

O próximo termo, t 3 , = t 1 - t 2

De maneira mais geral, t n = t n-2 - t n-1

A sequência termina quando t n <0.

Seu desafio: escreva um programa ou função que imprima o comprimento de uma sequência Sumac, começando com t 1 e t 2 .

  • t 1 e t 2 são números inteiros dentro do intervalo do seu idioma.
  • Aplicam-se brechas padrão.

Casos de teste

t1  t2       sumac_len(t1,t2)

120  71      5
101  42      3
500  499     4
387  1       3

Cred de rua de bônus:

3    -128    1
-314 73      2

Isso é código-golfe, então a resposta mais curta em bytes vence.


Intimamente relacionados , se não for uma duplicata
Mr. Xcoder

2
Este parece ser um bom desafio, mas é um pouco incerto. Devemos tomar t1e t2como entrada? E o que há inos casos de teste?
caird coinheringaahing

2
É garantido que t1 e t2 são> = 0?
user202729

6
@Blacksilver Hein? O que é esse bônus exatamente? Os bônus geralmente são desencorajados de qualquer maneira
Luis Mendo

6
Nós temos que lidar t_1 = t_2 = 0? "Credit street cred" significa que não precisamos lidar t_1 < 0ou t_2 < 0?
Xnor

Respostas:


8

Casca , 8 bytes

→V<¡oG-↔

Aceita entrada como uma lista de 2 elementos. Experimente online!

Explicação

→V<¡oG-↔  Implicit input, say p=[101,42]
   ¡      Iterate on p:
       ↔    Reverse: [42,101]
    oG-     Cumulative reduce by subtraction: [42,59]
          Result is infinite list [[101,42],[42,59],[59,-17],[-17,76],[76,-93]...
 V<       Find the first index where adjacent pairs are lexicographically increasing.
          In our example [42,59] < [59,-17], so this gives 2.
→         Increment: 3

8

Haskell , 22 bytes

a#b|b<0=1|c<-a-b=1+b#c

Experimente online!

Eu realmente gostaria que houvesse uma maneira de combinar padrões para um número negativo ...

Explicação

a#b|b<0=1|c<-a-b=1+b#c

a#b                     -- define a function (#) that takes two arguments a and b
   |b<0                 -- if b is negative...
       =1               -- return 1
         |              -- otherwise...
          c<-a-b        -- assign a-b to c...
                =  b#c  -- and return the result of (#) applied to b and c...
                 1+     -- incremented by 1

Eu acho que a explicação é menos clara que o próprio código pela primeira vez. : P
Post Rock Garf Hunter

@WheatWizard Isso é provavelmente porque sou péssimo em explicações. : P
totallyhuman

3

Casca , 12 11 bytes

V<0t¡ȯF-↑2↔

Experimente online!

Toma o crédito de rua de bônus por tudo o que vale a pena.

Explicação

    ¡ȯ       Repeatedly apply the function to the right to the list of all
             previous values and collect the results in an infinite list.
          ↔  Reverse the list of previous results.
        ↑2   Take the first two values (last two results).
      F-     Compute their difference (using a fold).
   t         Discard the first element.
V<0          Find the first index of a negative value.


2

MATL , 13 bytes

`yy-y0<~]N2-&

Ele lida com entradas negativas (últimos dois casos de teste).

Experimente online! Ou verifique todos os casos de teste .

Explicação

`        % Do...while
  yy     %   Duplicate top two elements. Implicit inputs first time
  -      %   Subtract
  y      %   Duplicate from below: push previous term
  0<~    %   Is it 0 or greater? This is the loop condition
]        % End. Proceed with next iteration if top of the stack is true
N        % Push number of elements in stack
2-       % Subtract 2
&        % Specify that the next function, namely implicit display, should
         % only display the top of the stack

2

Flak cerebral , 142 90 bytes

((()){{}<(({}({}))[({}[{}])({})])([(({})<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}>}<>)

Experimente online!

Não é muito curto. Leva a entrada para trás.

Explicação

(
 (())   #Push 1
 {      #Until 0
  {}    #Pop (+1 to counter)
  <(({}({}))[({}[{}])({})])  #tn = tn-1 - tn-2
  ([(({})<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}>  #Greater than 0?
 }      #End loop
 <>     #Get rid of everything
)       #Push result

2

05AB1E , 11 bytes

[DŠ-D0‹#]NÌ

Experimente online!

Explicação

Aceita entrada como t2, t1

[             # start a loop
 DŠ           # duplicate top of stack and move it down 2 positions
   -          # subtract the top 2 values
    D0‹#      # if a copy of the top value is negative, break loop
        ]     # end loop
         NÌ   # push iteration index+2


1

J , 22 bytes

[:#({:,-/)^:(0<{:)^:a:

Como funciona:

                  ^:a: - Repeat until the result stops changing, store the results in a list
          ^:(0<{:)     - repeat if the second term is positive
   ({:,-/)             - makes a tuple (second, first minus second)
[:#                    - number of elements in the list ([: caps the fork)

Experimente online!




0

JavaScript (ES6), 24 bytes

Retorna true em vez de 1 .

f=(a,b)=>b<0||1+f(b,a-b)

Casos de teste


1
@totallyhuman Então você não precisaria f(b)(a-b)economizar.
Mr. Xcoder

E se a<0? (1 mais para ir)
user202729

Atualização: você não precisa mais dar suporte a entradas negativas, mas é legal se o fizer.
SIGSTACKFAULT

0

Pitão , 11 bytes

Essa é uma função recursiva que recebe dois argumentos Ge H. O link é ligeiramente modificado para realmente chamar a função na entrada fornecida.

M|<H0hgH-GH

Suíte de teste.


0

APL (Dyalog) , 23 bytes

2∘{0>-/⍵:⍺⋄(⍺+1)∇-⍨\⌽⍵}

Experimente online!

Quão?

2∘ - com um acumulador inicial de 2,

-/⍵ - se o próximo termo

0> - é inferior a 0,

- devolva o acumulador. de outra forma,

(⍺+1) - aumentar o acumulador

- e recorrer com

-⍨\⌽⍵ - os dois últimos itens foram revertidos e diferenciados.

      {⍵} 8 2
8 2
      {⌽⍵} 8 2
2 8
      {-⍨\⌽⍵} 8 2
2 6


0

dc , 24 bytes

?[dsb-1rlbrd0<a]dsaxz1-p

Experimente online!

Explicação

?                         # read input                | 71 120
 [dsb-1rlbrd0<a]          # push string               | [string] 71 120
                dsa       # copy top to register a    | [string] 71 120
                   x      # execute the string        | -5 27 1 1 1 1
                    z     # push length of stack      | 6 -5 27 1 1 1 1
                     1-   # decrement top by 1        | 5 -5 27 1 1 1 1
                       p  # print top

 # string in register a:

  dsb                     # copy top to register b    | 71 120
     -                    # subtract                  | 49
      1                   # push 1                    | 1 49
       r                  # swap top two elements     | 49 1
        lb                # load register b           | 71 49 1
          r               # swap top two elements     | 49 71 1
           d0<a           # if top < 0 execute register a

0

Montagem Z80, 10 bytes

Esta versão tenta executar a versão "street cred" da tarefa. No entanto, para o caso de teste sugerido em que t1 = -314, t2 = 73, este programa produz a resposta "0", que, francamente, faz um pouco mais de sentido do que "2".

SumacLen:
        xor a           ; HL = t[1], DE = t[2], A is the counter
Loop:   bit 7,h
        ret nz          ; stop if HL is negative
        inc a
        sbc hl,de       ; HL = t[3], DE = t[2]
        ex de,hl        ; HL = t[2], DE = t[3]
        jr Loop

O programa de teste do ZX Spectrum 48K gravado usando o montador Sjasmplus pode ser baixado aqui . Um instantâneo compilado também está disponível .


Presumivelmente, a versão sem bônus usa em seu Loop: ret clugar?
24517 Neil

Sim, a verificação do bit de sinal de H não seria mais necessária. "bit 7, h" pode ser removido e "ret nz" substituído por "ret c", com "inc a" se movendo bem na frente dele. 8 bytes no total.
Introspec

Sim; o 2resultado é realmente apenas uma coisa no meu programa.
SIGSTACKFAULT

Você quer dizer que 0é uma resposta aceitável para esse caso de teste? Ou você quer dizer que seria melhor modificar meu programa para produzir 2?
introspec



0

Perl 6 ,24 19 bytes

-5 bytes graças a Brad Gilbert b2gills.

{+(|@_,*-*...^0>*)}

Experimente online!

Explicação : A coisa toda entre parênteses é exatamente a sequência em questão ( |@_são os 2 primeiros termos (= os dois parâmetros), *-*é uma função que recebe dois argumentos e retorna sua diferença e * <0é a condição de parada (termo menor que 0) Omitimos o último termo com ^após o ...). Em seguida, forçamos o contexto numérico pelo +operador, que produz o comprimento da sequência.


{+(|@_,*-*...^0>*)}
Brad Gilbert b2gills

@ BradGilbertb2gills: Obrigado. Eu tive uma grande pausa no golfe, então estou um pouco enferrujado. O que eu não entendo, porém, é por isso que você deve colocar o espaço em * <0*, but why you don't need it in 0> * `...
Ramillies

O espaço é necessário para que não se confunda com%h<a>
Brad Gilbert b2gills
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.