Deux pas en avant et un pas en arrière

15

Disons que je suis à dix pas de ma destination. J'y marche en suivant le vieil adage "deux pas en avant et un pas en arrière". Je fais deux pas en avant, un en arrière, jusqu'à ce que je me tienne exactement sur ma destination. (Cela peut impliquer de dépasser ma destination et d'y revenir). Combien de pas ai-je parcourus?

Bien sûr, je ne serais peut-être pas à 10 pas. Je pourrais être à 11 pas ou 100. Je pourrais mesurer dix pas et continuer à marcher d'avant en arrière pour résoudre le problème, ou ... je pourrais écrire du code!

  • Écrivez une fonction pour déterminer le nombre d'étapes nécessaires pour obtenir N étapes, dans l'ordre: deux pas en avant, un pas en arrière.
  • Supposons que vous avez commencé à l'étape 0. Comptez les «deux pas en avant» comme deux pas, pas un.
  • Supposons que toutes les étapes ont une longueur uniforme.
  • Il doit renvoyer le nombre de pas effectués en premier lorsque vous atteignez cet espace. (Par exemple, à 10 pas, cela prend 26 pas, mais vous le frapperiez à nouveau à l'étape 30). Nous nous intéressons au 26.
  • Utilisez n'importe quelle langue que vous aimez.
  • Il doit accepter tout entier positif en entrée. Cela représente l'étape cible.
  • Le plus petit nombre d'octets gagne.

Exemple:

Je veux m'éloigner de 5 pas:

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

Dans ce cas, le résultat de la fonction serait 11.

Exemples de résultats:

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

Amusez-vous, golfeurs!

code-golf  math  arithmetic 
— AJFaraday
source
7
Hmm ... cela semble très familier.
— Shaggy
3
— Rod
@Rod Hourra! Je m'en suis sorti! ;)
— AJFaraday
Oui, cela ressemble à celui auquel je pensais, @Rod.
— Shaggy
@Shaggy Rod a un peu changé son commentaire. Le précédent a noté que la question des escargots / puits demande le nombre d'itérations, mais cela demande la distance parcourue.
— AJFaraday

Réponses:

5

Oasis , 5 4 octets

1 octet enregistré grâce à @Adnan

3+23

À ne pas confondre avec 23+3

Essayez-le en ligne!

Comment?

      implicitly push a(n-1)
3     push 3
 +    sum and implicitly print
  2   a(2) = 2
   3  a(1) = 3
— Uriel
source
1
Vous pouvez laisser de côté b.
— Adnan
Je pense que vous vouliez multiplier par 3, pas l'ajouter.
— Erik the Outgolfer
@EriktheOutgolfer Le programme calcule un (n) comme un (n-1) +3 .
— Dennis
9

Polyglotte: Java 8 / JavaScript / C # .NET, 16 14 12 octets

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

Essayez-le en ligne (Java 8).

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

Essayez-le en ligne (JavaScript).
Essayez-le en ligne (C # .NET) .

Port de la réponse Python 2 de @Lynn , alors assurez-vous de voter pour sa réponse.

Ancienne réponse:

Polyglotte: Java 8 / JavaScript / C # .NET, 16 14 octets

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

Essayez-le en ligne (Java 8).

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

Essayez-le en ligne (JavaScript).
Essayez-le en ligne (C # .NET) .

Explication:

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
source
Polyglotte JavaScript, si vous utilisez une grosse flèche.
— Shaggy
@Shaggy Added, ainsi que C # .NET :) Bien qu'il n=>(--n*3||4)-1soit également possible en JavaScript (également 14 octets).
— Kevin Cruijssen
7

R , 20 octets

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

Essayez-le en ligne!

Je n'ai remarqué le modèle qu'après avoir mis en œuvre ma solution moins élégante.

— Giuseppe
source
3
Félicitations pour 10k BTW!
— Luis Mendo
4
@LuisMendo merci! Je pense que mon anniversaire d'un an sur le site était il y a quelques jours, donc ça a été une bonne semaine pour moi, en ce qui concerne PPCG.
— Giuseppe
3
@Giuseppe Je connais le sentiment: 20k la semaine dernière, ainsi que le 2e anniversaire. :)
— Kevin Cruijssen
4

MATL , 7 octets

Utilise la 3*n-4*(n>1)formule. Multipliez l'entrée par 3 ( 3*), appuyez à nouveau sur l'entrée ( G) et décrémentez-la ( q). Si le résultat n'est pas nul ( ?), soustrayez 4 du résultat ( 4-).

3*Gq?4-

Essayez-le en ligne!

— David
source
6 octets portant la réponse Jelly de Dennis2-|EG+
— Giuseppe
4

Gelée , 4 octets

ạ2Ḥ+

Essayez-le en ligne!

Comment ça fonctionne

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

MachineCode sur x86_64, 34 32 24 octets

8d47fe9931d029d08d0447c3

Nécessite l' iindicateur pour la sortie entière; l'entrée est prise via l'ajout manuel au code.

Essayez-le en ligne!

J'ai parcouru ces 4 fonctions C différentes pour trouver le programme MachineCode de 24 octets:

  • n+2*abs(n-2)= 8d47fe9931d029d08d0447c3(24 octets)
  • 3*n-4*!!~-n= 8d047f31d2ffcf0f95c2c1e20229d0c3(32 octets)
  • n*3-4*(n>1)= 31d283ff028d047f0f9dc2c1e20229d0c3(34 octets)
  • n<2?3:n*3-4= 83ff01b8030000007e068d047f83e804c3(34 octets)
— MD XF
source
alors quelle est exactement cette langue?
— qwr
@qwr Consultez le fichier README dans le référentiel pour une description simple.
— MD XF
2

4 , 54 octets

3.6010160303604047002020003100000180010202046000095024

Essayez-le en ligne!

Si vous remettez en question la méthode de saisie, veuillez d'abord visiter l' entrée numérique et la sortie peuvent être données sous forme de méta-message de code de caractère .

— Uriel
source
Pourquoi cela a-t-il été rejeté?
— Uriel
Parce que la réponse semble être un quart, ce qui n'est pas un résultat valide. Pour autant que je sache, cela ne résout pas le problème.
— AJFaraday
@AJFaraday, il utilise l'entrée et la sortie d'octets, ce qui est valide par méta consensus. voir l'explication dans la section d'entrée
— Uriel
Des ressources sur la façon d'interpréter le résultat? Ou l'entrée?
— AJFaraday
1
@AJFaraday le code de caractère du résultat est la réponse. J'ai modifié la question pour inclure le méta-post pertinent. 4n'a qu'une entrée char.
— Uriel
2

Japt, 7 octets

Un port de la solution Python de Lynn.

*3É%U*4

Essayez-le

Alternative

C'était une alternative amusante aux solutions de formule fermée qui est, malheureusement, un octet plus long:

_+3}gN³²

Essayez-le

— Hirsute
source
2

65816 code machine, 22 octets

J'aurais pu faire ce code machine 65C02 facilement pour 3 octets de moins, mais je ne l'ai pas fait, car la taille du registre sur le 65C02 est de 8 bits au lieu de 16 bits. Cela fonctionnerait, mais c'est ennuyeux car vous ne pouvez utiliser que des chiffres très bas ;-)

vidage xxd:

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

démontage / explication du code:

; 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

Test sur un émulateur compatible 65816:

testing

— 2xsaiko
source
1

SHELL , 28 octets

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

Tests:

F 1
3

F 2
2

F 3
5

F 4
8

F5
11

F 11
29

F 100
296

F 100000
299996

Explication:

La formule est: 

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

suivant la séquence de 3 étapes "Deux pas en avant et un pas en arrière", nous aurons la série arithmétique:

 +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

Au minimum, ou première coïncidence:

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

en une seule formule: 

F(n) = 3*n - 4(n>1)     with n>1 is 1 or 0 (if n==1)
— Ali ISSA
source
veuillez décrire de quel obus il s'agit
— qwr
testé sur Cygwin (CYGWIN_NT-10.0 2.3.1 (0.291 / 5/3) 2015-11-14 12:44 x86_64 Cygwin)
— Ali ISSA
pouvez-vous l'écrire directement en bc?
— qwr
Je ne suis pas familier avec bc, mais comme l'argument de la fonction ($ 1) est utilisé plusieurs fois et que certaines choses spécifiques au shell (expansion arithmétique $((…))) sont effectuées, probablement pas.
— 2xsaiko
1
F(){bc<<<$1*3-$(($1>1))*4}fonctionne bien en zsh et supprime 2 octets
— 2xsaiko
1

Python 3 , 48 octets

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

Essayez-le en ligne!

— Nathan Dimmer
source
Bon travail. Vous voudrez peut-être aussi mettre du code dans la section «Pied de page». De cette façon, vous pouvez tester votre fonction sans rembourrer votre entrée de golf ...
— AJFaraday
@AJFaraday Le pied de page de mon message ou de mon code?
— Nathan Dimmer
Sur Try It Online; vous pouvez ajouter un pied de page qui s'exécute avec votre code mais ne compte pas pour la longueur d'octet. Ensuite, la sortie affichera votre code au travail.
— AJFaraday
— Jo King
@JoKing Connaissez-vous un bon guide des fonctions lambda en Python? Je ne comprends vraiment pas comment fonctionne la syntaxe.
— Nathan Dimmer
1

Brain-Flak , 38 octets

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

Essayez-le en ligne!

La première réponse que je vois pour calculer la réponse en marchant d'avant en arrière.

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

W d , 7 octets

♦óÖ╣░Θ$

Explication

3*1a<4*-

Évalue (a*3)-4*(a>1).

Une autre alternative possible

3*1am4*-

Évalue (a*3)-4*(1%a).

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.