Dos pasos adelante y uno atrás

15

Digamos que estoy a diez pasos de mi destino. Camino allí siguiendo el viejo dicho: "Dos pasos adelante y uno atrás". Doy dos pasos hacia adelante, uno hacia atrás, hasta que estoy exactamente en mi destino. (Esto podría implicar pasar mi destino y volver a él). ¿Cuántos pasos caminé?

Por supuesto, podría no estar a 10 pasos de distancia. Podría estar a 11 pasos de distancia, o 100. Podría medir diez pasos y seguir caminando de un lado a otro para resolver el problema, o ... ¡podría escribir un código!

  • Escriba una función para calcular cuántos pasos se necesitan para alejar N pasos, en la secuencia: dos pasos hacia adelante, uno hacia atrás.
  • Suponga que ha comenzado en el paso 0. Cuente los "dos pasos adelante" como dos pasos, no uno.
  • Suponga que todos los pasos tienen una longitud uniforme.
  • Debería devolver el número de pasos que se dieron por primera vez cuando llegas a ese espacio. (Por ejemplo, a 10 pasos de distancia se necesitan 26 pasos, pero volvería a golpearlo en el paso 30). Estamos interesados ​​en los 26.
  • Usa el idioma que quieras.
  • Debe aceptar cualquier entero positivo como entrada. Esto representa el paso objetivo.
  • El menor número de bytes gana.

Ejemplo:

Quiero alejarme a 5 pasos:

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

En este caso, el resultado de la función sería 11.

Resultados de ejemplo:

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

¡Diviértanse, golfistas!

code-golf  math  arithmetic 
— AJFaraday
fuente
77
Hmm ... esto se siente muy familiar.
— Shaggy
3
— Rod
@ Rod Hooray! Me salí con la suya! ;)
— AJFaraday
Sí, se parece al que estaba pensando, @ Rod.
— Shaggy
@Shaggy Rod cambió su comentario un poco. El anterior señaló que la pregunta de los caracoles / pozos es la cantidad de iteraciones, pero esto es la distancia recorrida.
— AJFaraday

Respuestas:

5

Oasis , 5 4 bytes

1 byte guardado gracias a @Adnan

3+23

No debe confundirse con 23+3

Pruébalo en línea!

¿Cómo?

      implicitly push a(n-1)
3     push 3
 +    sum and implicitly print
  2   a(2) = 2
   3  a(1) = 3
— Uriel
fuente
1
Puedes dejar de lado el b.
— Adnan
Creo que querías multiplicar por 3, no agregarlo.
— Erik the Outgolfer
@EriktheOutgolfer El programa calcula un (n) como un (n-1) +3 .
— Dennis
9

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

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

Pruébelo en línea (Java 8).

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

Pruébelo en línea (JavaScript).
Pruébelo en línea (C # .NET) .

Puerto de la respuesta Python 2 de @Lynn , así que asegúrese de votar su respuesta.

Vieja respuesta:

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

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

Pruébelo en línea (Java 8).

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

Pruébelo en línea (JavaScript).
Pruébelo en línea (C # .NET) .

Explicación:

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
fuente
JavaScript políglota, si usa una flecha gruesa.
— Shaggy
@Shaggy Agregado, así como C # .NET :) Aunque n=>(--n*3||4)-1también es posible en JavaScript (también 14 bytes).
— Kevin Cruijssen
7

R , 20 bytes

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

Pruébalo en línea!

No noté el patrón hasta después de haber implementado mi solución menos elegante.

— Giuseppe
fuente
3
¡Felicidades por 10k BTW!
— Luis Mendo
44
@LuisMendo gracias! Creo que mi primer aniversario en el sitio fue hace un par de días, así que ha sido una buena semana para mí, en cuanto a PPCG.
— Giuseppe
3
@Giuseppe Conozco la sensación: 20k la semana pasada, así como el segundo aniversario. :)
— Kevin Cruijssen
4

MATL , 7 bytes

Utiliza la 3*n-4*(n>1)fórmula Multiplique la entrada por 3 ( 3*), presione la entrada nuevamente ( G) y disminuya ( q). Si el resultado no es cero ( ?), reste 4 del resultado ( 4-).

3*Gq?4-

Pruébalo en línea!

— David
fuente
6 bytes portando la respuesta de Dennis 'Jelly2-|EG+
— Giuseppe
4

Jalea , 4 bytes

ạ2Ḥ+

Pruébalo en línea!

Cómo 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
fuente
3

MachineCode en x86_64, 34 32 24 bytes

8d47fe9931d029d08d0447c3

Requiere la ibandera para la salida entera; la entrada se toma agregando manualmente al código.

Pruébalo en línea!

Revisé estas 4 funciones C diferentes para encontrar el 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
fuente
Entonces, ¿qué es exactamente este idioma?
— qwr
@qwr Consulte el archivo README en el repositorio para obtener una descripción simple.
— MD XF
2

4 , 54 bytes

3.6010160303604047002020003100000180010202046000095024

Pruébalo en línea!

Si cuestiona el método de entrada, visite primero la entrada numérica y la salida se puede dar como una meta publicación de código de caracteres .

— Uriel
fuente
¿Por qué se rechazó esto?
— Uriel
Porque la respuesta parece ser una cuarta parte, lo que no es un resultado válido. Por lo que puedo decir, no resuelve el problema.
— AJFaraday
@AJFaraday utiliza byte input y output, que es válido por meta consenso. vea la explicación dentro de la sección de entrada
— Uriel
¿Algún recurso sobre cómo interpretar el resultado? O la entrada?
— AJFaraday
1
@AJFaraday el código char del resultado es la respuesta. He editado la pregunta para incluir la meta publicación relevante. 4solo tiene entrada de caracteres.
— Uriel
2

Japt, 7 bytes

Un puerto de la solución Python de Lynn.

*3É%U*4

Intentalo

Alternativa

Esta fue una alternativa divertida a las soluciones de fórmula cerrada que, desafortunadamente, es un byte más largo:

_+3}gN³²

Intentalo

— Lanudo
fuente
2

Código de máquina 65816, 22 bytes

Podría haber hecho este código de máquina 65C02 fácilmente por 3 bytes menos, pero no lo hice, ya que el tamaño del registro en 65C02 es de 8 bits en lugar de 16 bits. Funcionaría, pero es aburrido porque solo puedes usar números realmente bajos ;-)

volcado xxd:

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

Desmontaje / explicación del 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

Probándolo en un emulador compatible con 65816:

pruebas

— 2xsaiko
fuente
1

SHELL , 28 Bytes

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

Pruebas:

F 1
3

F 2
2

F 3
5

F 4
8

F5
11

F 11
29

F 100
296

F 100000
299996

Explicación

La formula es: 

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

Siguiendo la secuencia de 3 pasos "Dos pasos adelante y uno atrás", tendremos la serie 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

Como mínimo, o primera coincidencia:

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

en una fórmula: 

F(n) = 3*n - 4(n>1)     with n>1 is 1 or 0 (if n==1)
— Ali ISSA
fuente
describa de qué capa se trata
— qwr
probado en Cygwin (CYGWIN_NT-10.0 2.3.1 (0.291 / 5/3) 2015-11-14 12:44 x86_64 Cygwin)
— Ali ISSA
¿puedes escribirlo en bc directamente?
— qwr
No estoy familiarizado con bc, pero dado que el argumento de la función ($ 1) se usa varias veces y algunas cosas específicas de shell (expansión aritmética $((…))) , se hace, probablemente no.
— 2xsaiko
1
F(){bc<<<$1*3-$(($1>1))*4}funciona en zsh y elimina 2 bytes
— 2xsaiko
1

Python 3 , 48 bytes

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

¡Pruébelo en línea!

— Nathan Dimmer
fuente
Buen trabajo. Es posible que también desee poner algo de código en la sección "Pie de página". De esa manera puede probar su función sin
— rellenar
@AJFaraday ¿El pie de página de mi publicación o de mi código?
— Nathan Dimmer
En Pruébelo en línea; puede agregar un pie de página que se ejecute con su código pero que no cuente para la longitud del byte. Luego, la salida mostrará su código en el trabajo.
— AJFaraday
— Jo King
@JoKing ¿Conoces una buena guía para las funciones lambda en Python? Realmente no entiendo cómo funciona la sintaxis.
— Nathan Dimmer
1

Brain-Flak , 38 bytes

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

Pruébalo en línea!

La primera respuesta que veo para calcular la respuesta va y viene.

({ 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
fuente
1

W d , 7 bytes

♦óÖ╣░Θ$

Explicación

3*1a<4*-

Evalúa (a*3)-4*(a>1).

Otra alternativa posible

3*1am4*-

Evalúa (a*3)-4*(1%a).

— un'_'
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.