Due passi avanti e un passo indietro

15

Diciamo che sono a dieci passi dalla mia destinazione. Cammino lì seguendo il vecchio detto "Due passi avanti e un passo indietro". Faccio due passi avanti, uno indietro, finché non mi trovo esattamente sulla mia destinazione. (Ciò potrebbe comportare il superamento della mia destinazione e il ritorno ad essa). Quanti passi ho fatto?

Certo, potrei non essere a 10 passi di distanza. Potrei essere a 11 passi di distanza, o 100. Potrei misurare dieci passi e continuare a camminare avanti e indietro per risolvere il problema, o ... Potrei scrivere del codice!

  • Scrivi una funzione per capire quanti passaggi sono necessari per ottenere N passi, nella sequenza: due passi avanti, un passo indietro.
  • Supponiamo che tu abbia iniziato al passaggio 0. Conta i "due passi avanti" come due passi, non uno.
  • Supponiamo che tutti i passaggi abbiano una lunghezza uniforme.
  • Dovrebbe restituire il numero di passi effettuati per la prima volta quando si raggiunge quello spazio. (Ad esempio, a 10 passi di distanza bastano 26 passi, ma lo avresti colpito di nuovo al passaggio 30). Siamo interessati al 26.
  • Usa la lingua che preferisci.
  • Dovrebbe accettare qualsiasi numero intero positivo come input. Questo rappresenta il passo target.
  • Vince il minor numero di byte.

Esempio:

Voglio fare 5 passi di distanza:

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

In questo caso, il risultato della funzione sarebbe 11.

Risultati di esempio:

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

Buon divertimento, golfisti!

code-golf  math  arithmetic 
— AJFaraday
fonte
7
Hmm ... sembra molto familiare.
— Shaggy,
3
— Rod
@Rod Hooray! Me ne sono andato! ;)
— AJFaraday,
Sì, sembra quello a cui stavo pensando, @Rod.
— Shaggy,
@Shaggy Rod ha cambiato un po 'il suo commento. Il precedente ha osservato che la domanda lumache / pozzi richiede il numero di iterazioni, ma questo richiede la distanza percorsa.
— AJFaraday,

Risposte:

5

Oasi , 5 4 byte

1 byte salvato grazie a @Adnan

3+23

Da non confondere 23+3

Provalo online!

Come?

      implicitly push a(n-1)
3     push 3
 +    sum and implicitly print
  2   a(2) = 2
   3  a(1) = 3
— Uriel
fonte
1
Puoi tralasciare il b.
— Adnan,
Penso che volevi moltiplicare per 3, non aggiungerlo.
— Erik the Outgolfer,
@EriktheOutgolfer Il programma calcola a (n) come (n-1) +3 .
— Dennis,
9

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

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

Provalo online (Java 8).

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

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

Porto di @Lynn Python 2 , quindi assicurati di votare la sua risposta.

Vecchia risposta:

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

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

Provalo online (Java 8).

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

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

Spiegazione:

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
JavaScript poliglotta, se si utilizza una freccia grassa.
— Shaggy,
@Shaggy Aggiunto, oltre a C # .NET :) Anche se n=>(--n*3||4)-1è possibile anche in JavaScript (anche 14 byte).
— Kevin Cruijssen,
7

R , 20 byte

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

Provalo online!

Non ho notato lo schema fino a quando non ho implementato la mia soluzione meno elegante.

— Giuseppe
fonte
3
Congratulazioni per 10k BTW!
— Luis Mendo,
4
@LuisMendo grazie! Penso che il mio anniversario di un anno sul sito sia stato un paio di giorni fa, quindi è stata una buona settimana per me, per quanto riguarda PPCG.
— Giuseppe,
3
@Giuseppe Conosco la sensazione: 20k la scorsa settimana, così come il 2 ° anniversario. :)
— Kevin Cruijssen,
6

Oasi , 5 byte

¹y4-3

Spiegazione:

    3  defines f(1) = 3
¹y4-   defines f(n) as:
¹      push input
 y     triple
  4-   subtract four

Provalo online!

— Okx
fonte
4

MATL , 7 byte

Usa la 3*n-4*(n>1)formula. Moltiplicare l'input per 3 ( 3*), premere di nuovo input ( G) e diminuirlo ( q). Se il risultato non è zero ( ?), sottrarre 4 dal risultato ( 4-).

3*Gq?4-

Provalo online!

— David
fonte
6 byte porting risposta Delly 'Jelly2-|EG+
— Giuseppe
4

Gelatina , 4 byte

ạ2Ḥ+

Provalo online!

Come funziona

ạ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 su x86_64, 34 32 24 byte

8d47fe9931d029d08d0447c3

Richiede il iflag per l'output intero; l'input viene preso tramite l'aggiunta manuale al codice.

Provalo online!

Ho esaminato queste 4 diverse funzioni C per trovare il programma MachineCode a 24 byte:

  • n+2*abs(n-2)= 8d47fe9931d029d08d0447c3(24 byte)
  • 3*n-4*!!~-n= 8d047f31d2ffcf0f95c2c1e20229d0c3(32 byte)
  • n*3-4*(n>1)= 31d283ff028d047f0f9dc2c1e20229d0c3(34 byte)
  • n<2?3:n*3-4= 83ff01b8030000007e068d047f83e804c3(34 byte)
— MD XF
fonte
quindi che cos'è esattamente questa lingua?
— qwr,
@qwr Dai un'occhiata al README nel repository per una semplice descrizione.
— MD XF,
2

4 , 54 byte

3.6010160303604047002020003100000180010202046000095024

Provalo online!

Se si mette in dubbio il metodo di input, visitare prima l' input numerico e l'output può essere indicato come meta post con codice carattere .

— Uriel
fonte
Perché questo è stato downvoted?
— Uriel,
Perché la risposta sembra essere un quarto, che non è un risultato valido. Per quanto ne so, non risolve il problema.
— AJFaraday,
@AJFaraday utilizza input e output byte, che è valido per meta consenso. vedere la spiegazione all'interno della sezione input
— Uriel
Qualche risorsa su come interpretare il risultato? O l'ingresso?
— AJFaraday,
1
@AJFaraday il codice char del risultato è la risposta. Ho modificato la domanda per includere il meta post pertinente. 4ha solo input char.
— Uriel,
2

Japt, 7 byte

Una porta della soluzione Python di Lynn.

*3É%U*4

Provalo

Alternativa

Questa è stata una divertente alternativa alle soluzioni a formula chiusa che sfortunatamente è un byte più lungo:

_+3}gN³²

Provalo

— Shaggy
fonte
2

65816 machine code, 22 bytes

Avrei potuto rendere questo codice macchina 65C02 facilmente per 3 byte in meno, ma non lo avevo fatto, poiché la dimensione del registro sul 65C02 è di 8 bit anziché 16 bit. Funzionerebbe, ma è noioso perché puoi usare solo numeri molto bassi ;-)

xxd dump:

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

smontaggio / spiegazione del codice:

; 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 su un emulatore compatibile 65816:

testing

— 2xsaiko
fonte
1

SHELL , 28 byte

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

Test:

F 1
3

F 2
2

F 3
5

F 4
8

F5
11

F 11
29

F 100
296

F 100000
299996

Spiegazione :

La formula è: 

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

seguendo la sequenza di 3 passi "Due passi avanti e un passo indietro", avremo la serie aritmetica:

 +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

Come minimo, o prima coincidenza:

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

in una formula: 

F(n) = 3*n - 4(n>1)     with n>1 is 1 or 0 (if n==1)
— Ali ISSA
fonte
please describe which shell this is
— qwr
tested on Cygwin ( CYGWIN_NT-10.0 2.3.1(0.291/5/3) 2015-11-14 12:44 x86_64 Cygwin)
— Ali ISSA
can you write it in bc directly?
— qwr
I'm not familiar with bc, but since the argument of the function ($1) is used several times and some shell-specific stuff (arithmetic expansion, $((…))) is done, probably not.
— 2xsaiko
1
F(){bc<<<$1*3-$(($1>1))*4} works in zsh though and removes 2 bytes
— 2xsaiko
1

Python 3, 48 bytes

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

Try It Online!

— Nathan Dimmer
fonte
Nice work. You might want to put some code in the “Footer” section, too. That way you can test your function without padding out your golf entry...
— AJFaraday
@AJFaraday The footer of my post or of my code?
— Nathan Dimmer
On Try It Online; you can add a footer which runs with your code but doesn’t count towards the byte length. Then the output will show your code at work.
— AJFaraday
— Jo King
@JoKing Do you know of a good guide to lambda functions in Python? I really don't understand how the syntax works.
— Nathan Dimmer
1

Brain-Flak, 38 bytes

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

Try it online!

The first answer I see to calculate the answer by stepping back and forth.

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

♦óÖ╣░Θ$

Explanation

3*1a<4*-

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

Another possible alternative

3*1am4*-

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

— a'_'
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.