Dois passos à frente e um passo atrás

15

Digamos que estou a dez passos do meu destino. Eu ando lá seguindo o velho ditado, "Dois passos à frente e um passo atrás". Dou dois passos à frente, um atrás, até estar exatamente no meu destino. (Isso pode envolver ultrapassar meu destino e retornar a ele). Quantos passos eu andei?

Claro, talvez eu não esteja a 10 passos de distância. Eu posso estar a 11 passos, ou 100. Eu poderia medir dez passos e continuar andando para frente e para trás para resolver o problema, ou ... Eu poderia escrever algum código!

  • Escreva uma função para calcular quantos passos são necessários para afastar N passos, na sequência: dois passos adiante, um passo atrás.
  • Suponha que você tenha começado na etapa 0. Conte os "dois passos à frente" como dois passos, não um.
  • Suponha que todas as etapas tenham um comprimento uniforme.
  • Ele deve retornar o número de etapas executadas pela primeira vez quando você alcança esse espaço. (Por exemplo, 10 passos de distância levam 26 passos, mas você o alcançaria novamente no passo 30). Estamos interessados ​​nos 26.
  • Use qualquer idioma que você quiser.
  • Ele deve aceitar qualquer número inteiro positivo como entrada. Isso representa a etapa de destino.
  • Menor número de bytes ganhos.

Exemplo:

Quero dar 5 passos:

| | | | | | <- I'm at step 0, not yet on the grid.
| |X| | | | <- I take two steps forward, I'm on step 2: the count is 2
|X| | | | | <- I take one step back, I'm on step 1: the count is 3
| | |X| | | <- I take two steps forward, I'm on step 3: the count is 5
| |X| | | | <- I take one step back, I'm on step 2 again: the count is 6
| | | |X| | <- I take two steps forward, I'm on step 4: the count is 8
| | |X| | | <- I take one step back, I'm on step 3 again: the count is 9
| | | | |X| <- I take two steps forward, I'm on step 5: the count is 11

Nesse caso, o resultado da função seria 11.

Resultados de exemplo:

1      =>  3
5      =>  11
9      =>  23
10     =>  26
11     =>  29
100    =>  296
1000   =>  2996
10000  =>  29996
100000 =>  299996

Divirta-se, golfistas!

code-golf  math  arithmetic 
— AJFaraday
fonte
7
Hmm ... isso parece muito familiar.
— Shaggy
3
— Rod
@Rod Hooray! Eu me safei disso! ;)
— AJFaraday
Sim, parece com o que eu estava pensando, @Rod.
— Shaggy
@Shaggy Rod mudou um pouco o comentário. O anterior observou que a questão de caracóis / poços está solicitando o número de iterações, mas está solicitando a distância percorrida.
— AJFaraday

Respostas:

5

Oásis , 5 4 bytes

1 byte salvo graças a @Adnan

3+23

Não deve ser confundido com 23+3

Experimente online!

Quão?

      implicitly push a(n-1)
3     push 3
 +    sum and implicitly print
  2   a(2) = 2
   3  a(1) = 3
— Uriel
fonte
1
Você pode deixar de fora o b.
— Adnan
Eu acho que você pretendia multiplicar com 3, não adicioná-lo.
— Erik the Outgolfer
@EriktheOutgolfer O programa calcula a (n) como a (n-1) +3 .
— 26518 Dennis
9

Poliglota: Java 8 / JavaScript / C # .NET, 16 14 12 bytes

n->3*n-1%n*4

Experimente online (Java 8).

n=>3*n-1%n*4

Experimente online (JavaScript).
Experimente online (C # .NET) .

Porta da resposta Python 2 de @Lynn , portanto, certifique-se de votar em sua resposta.

Resposta antiga:

Poliglota: Java 8 / JavaScript / C # .NET, 16 14 bytes

n->n<2?3:n*3-4

Experimente online (Java 8).

n=>n<2?3:n*3-4

Experimente online (JavaScript).
Experimente online (C # .NET) .

Explicação:

n->       // Method with integer as both parameter and return-type
  n<2?    //  If the input is 1:
   3      //   Return 3
  :       //  Else:
   n*3-4  //   Return the input multiplied by 3, and subtract 4
— Kevin Cruijssen
fonte
Poliglota JavaScript, se você usar uma seta gorda.
— Shaggy
@ Shaggy Adicionado, bem como C # .NET :) Embora n=>(--n*3||4)-1também seja possível em JavaScript (também 14 bytes).
— Kevin Cruijssen 26/03
7

R , 20 bytes

N=scan();3*N-4*(N>1)

Experimente online!

Não percebi o padrão até depois de implementar minha solução menos elegante.

— Giuseppe
fonte
3
Parabéns por 10k BTW!
— Luis Mendo
4
@LuisMendo thanks! Acho que meu aniversário de um ano no site foi há alguns dias atrás, por isso tem sido uma boa semana para mim, em termos de PPCG.
— Giuseppe
3
@ Giuseppe Conheço o sentimento: 20k na semana passada, bem como o 2º aniversário do ano. :)
— Kevin Cruijssen 26/03
4

MATL , 7 bytes

Usa a 3*n-4*(n>1)fórmula. Multiplique a entrada por 3 ( 3*), pressione a entrada novamente ( G) e diminua-a ( q). Se o resultado não for zero ( ?), subtraia 4 do resultado ( 4-).

3*Gq?4-

Experimente online!

— David
fonte
6 bytes portando a resposta de Dennis 'Jelly2-|EG+
— Giuseppe
4

Gelatina , 4 bytes

ạ2Ḥ+

Experimente online!

Como funciona

ạ2Ḥ+  Main link. Argument: n

ạ2    Absolute difference with 2; yield |n-2|.
  Ḥ   Unhalve/double; yield 2|n-2|.
   +  Add; yield 2|n-2|+n.
— Dennis
fonte
3

MachineCode em x86_64, 34 32 24 bytes

8d47fe9931d029d08d0447c3

Requer o isinalizador para saída inteira; a entrada é obtida através do acréscimo manual ao código.

Experimente online!

Passei por essas 4 funções C diferentes para encontrar o programa MachineCode de 24 bytes:

  • n+2*abs(n-2)= 8d47fe9931d029d08d0447c3(24 bytes)
  • 3*n-4*!!~-n= 8d047f31d2ffcf0f95c2c1e20229d0c3(32 bytes)
  • n*3-4*(n>1)= 31d283ff028d047f0f9dc2c1e20229d0c3(34 bytes)
  • n<2?3:n*3-4= 83ff01b8030000007e068d047f83e804c3(34 bytes)
— MD XF
fonte
então, o que exatamente é esse idioma?
— QWR
@qwr Confira o README no repositório para obter uma descrição simples.
— MD XF
2

4 , 54 bytes

3.6010160303604047002020003100000180010202046000095024

Experimente online!

Se você questionar o método de entrada, visite o primeiro a entrada numérica e saída pode ser dado como um código de caracteres pós meta.

— Uriel
fonte
Por que isso foi prejudicado?
— Uriel
Porque a resposta parece ser um quarto, o que não é um resultado válido. Até onde eu sei, isso não resolve o problema.
— AJFaraday
@AJFaraday usa entrada e saída de bytes, que é válida por meta consenso. veja a explicação na seção de entrada
— Uriel
Algum recurso sobre como interpretar o resultado? Ou a entrada?
— AJFaraday
1
@AJFaraday, o código do resultado é a resposta. Editei a pergunta para incluir a meta post relevante. 4possui apenas entrada de caracteres.
— Uriel
2

Japonês, 7 bytes

Uma porta da solução Python de Lynn.

*3É%U*4

Tente

Alternativo

Essa foi uma alternativa divertida às soluções de fórmula fechada que, infelizmente, são um byte mais longo:

_+3}gN³²

Tente

— Shaggy
fonte
2

65816 código da máquina, 22 bytes

Eu poderia ter criado esse código de máquina 65C02 facilmente por 3 bytes a menos, mas não o fiz, pois o tamanho do registro no 65C02 é de 8 bits em vez de 16 bits. Funcionaria, mas é chato, porque você só pode usar números realmente baixos ;-)

Despejo xxd:

00000000: 7aa9 0000 aa89 0100 d004 8888 e824 c8e8  z............$..
00000010: 1ac0 0000 d0ef                           ......

desmontagem / explicação do código:

; target is on the stack
  ply              7A                  ; pull target from stack
  lda #$0000       A9 00 00            ; set loop counter to 0
  tax              AA                  ; set step counter to 0
loop:
  bit #$0001       89 01 00            ; sets Z if loop counter is even
  bne odd          D0 04               ; if Z is not set, jump to 'odd'
  dey              88                  ; decrement target twice
  dey              88
  inx              E8                  ; increment step counter
  .byte $24        24                  ; BIT $xx opcode, effectively skips the next byte
odd:
  iny              C8                  ; increment target

  inx              E8                  ; increment step counter
  inc a            1A                  ; increment loop counter

  cpy #$0000       C0 00 00            ; sets zero flag, can be optimized maybe?
  bne loop         D0 EF               ; if Y is non-zero, loop

; result is in register X

Testando-o em um emulador compatível com 65816:

teste

— 2xsaiko
fonte
1

SHELL , 28 bytes

F(){ bc<<<$1*3-$(($1>1))*4;}

Testes:

F 1
3

F 2
2

F 3
5

F 4
8

F5
11

F 11
29

F 100
296

F 100000
299996

Explicação:

A fórmula é: 

if n == 1  ==> F(1) = 3
else F(n) = 3*n - 4

seguindo a sequência de 3 etapas "Dois passos à frente e um passo atrás", teremos a série aritmética:

 +2  2 => 2  ( or 6 )
 -1  1 => 3
 -----------
 +2  3 => 5  ( or 9 )
 -1  2 => 6
 -----------
 +2  4 => 8  ( or 12 )
 -1  3 => 9
 -----------
 +2  5 => 11 ( or 15 )
 -1  4 => 12
 -----------
 +2  6 => 14 ( or 18 )
 -1  5 => 15 
 -----------
 +2  7 => 17 ( or 21 )
 -1  6 => 18

No mínimo, ou primeira coincidência:

 1 => 3
 2 => 2
 3 => 5
 4 => 8
 5 => 11
 6 => 14

em uma fórmula: 

F(n) = 3*n - 4(n>1)     with n>1 is 1 or 0 (if n==1)
— Ali ISSA
fonte
por favor descreva qual shell é esse
— qwr 27/03
testado em Cygwin (CYGWIN_NT-10.0 2.3.1 (0.291 / 5/3) 2015-11-14 12:44 x86_64 Cygwin)
— Ali ISSA
você pode escrever em bc diretamente?
— QWR
Eu não estou familiarizado com bc, mas como o argumento da função ($ 1) é usado várias vezes e algumas coisas específicas do shell (expansão aritmética $((…))) são feitas, provavelmente não.
— 2xsaiko 28/03
1
F(){bc<<<$1*3-$(($1>1))*4}trabalha em zsh embora e remove 2 bytes
— 2xsaiko
1

Python 3 , 48 bytes

def a(x):
    if x!=1:
        return((3*x)-4)
    return(3)

Experimente Online!

— Nathan Dimmer
fonte
Bom trabalho. Você também pode colocar algum código na seção "Rodapé". Dessa forma, você pode testar a sua função sem preenchimento a sua entrada golf ...
— AJFaraday
@AJFaraday O rodapé da minha postagem ou do meu código?
— Nathan Dimmer
Em Experimente Online; você pode adicionar um rodapé que roda com seu código, mas não conta para o comprimento do byte. Em seguida, a saída mostrará seu código no trabalho.
— AJFaraday
— Jo King
@JoKing Você conhece um bom guia para funções lambda em Python? Eu realmente não entendo como a sintaxe funciona.
— Nathan Dimmer
1

Flak cerebral , 38 bytes

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

Experimente online!

A primeira resposta que vejo para calcular a resposta, indo e voltando.

({ while not at 0
  <([()()]{})>()() take two steps forward, counting 2 steps
  {(<((){})>)()}{} take one step back, if not at 0, and add 1 step
}{}) remove the 0 and push step sum
— MegaTom
fonte
1

W d , 7 bytes

♦óÖ╣░Θ$

Explicação

3*1a<4*-

Avalia (a*3)-4*(a>1) .

Outra alternativa possível

3*1am4*-

Avalia(a*3)-4*(1%a) .

— uma'_'
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.