sfondo

C'è un indovinello comune che va in questo modo:

Una lumaca si trova sul fondo di un pozzo di 30 piedi. Ogni giorno la lumaca è in grado di arrampicarsi su 3 piedi. Di notte quando dormono, scivolano indietro di 2 piedi. Quanti giorni ci vogliono perché la lumaca esca dal pozzo?

La risposta intuitiva è

30 giorni, perché la lumaca si arrampica a 1 piede al giorno per 30 giorni per raggiungere la cima,

ma in realtà la risposta è

28 giorni, perché una volta che la lumaca è 27 piedi in aria (dopo 27 giorni), saliranno semplicemente i restanti 3 piedi verso l'alto il 28 ° giorno.

Sfida

Questa sfida generalizza questo indovinello. Dati tre numeri positivi positivi come input, che rappresentano l'altezza totale, l'altezza di salita e l'altezza di caduta, restituiscono il numero di giorni che ci vorranno per uscire dal pozzo.

Se la lumaca non può uscire dal pozzo, è possibile restituire 0, restituire un valore falso o lanciare un'eccezione. Puoi anche scrivere codice che si interromperà se e solo se esiste una soluzione.

Se lo desideri, puoi prendere l'altezza di caduta come numero intero negativo.

Casi test

(30, 3, 2) -> 28
(84, 17, 15) -> 35
(79, 15, 9) -> 12
(29, 17, 4) -> 2
(13, 18, 8) -> 1
(5, 5, 10) -> 1
(7, 7, 7) -> 1
(69, 3, 8) -> Nessuna
(81, 14, 14) -> Nessuna

punteggio

Questo è code-golf , quindi vince la risposta più breve in ogni lingua.

Lumaca grigia , 1206 byte per l'I / O numerico, 149 byte per l'I / O unario

Per divertimento. Composizione del primo programma:

• 451 byte, convertendo il numero in punti
• 121 byte, funzione principale (una versione separata è scritta di seguito)
• 634 byte, convertendo i punti in numero

Accetta input e output numerici. L'ingresso è A, B, Crispettivamente. Rispetto ad altre (quasi) O(1)risposte, il codice ha una complessità di O(n). Ma per un gran numero, potrebbe prima consumare la memoria.

Appendere se non viene trovata alcuna soluzione.

INPUT p
POP Z r .!
f
POP Z o .
q
POP Z p [p]
GOTO [Z]
0
POP Z n .
GOTO w
1
POP Z n ..
GOTO w
2
POP Z n ...
GOTO w
3
POP Z n ....
GOTO w
4
POP Z n .....
GOTO w
5
POP Z n ......
GOTO w
6
POP Z n .......
GOTO w
7
POP Z n ........
GOTO w
8
POP Z n .........
GOTO w
9
POP Z n ..........
GOTO w
w
POP Z o .[o][o][o][o][o][o][o][o][o][o][n]
GOTO [r] [p] 
GOTO q
!
POP Z A .[o]
INPUT p
POP Z r .@
GOTO f
@
POP Z B .[o]
INPUT p
POP Z r .#
GOTO f
#
POP Z C .[o]
POP H N .[B]
U
POP Z A [A]
POP Z B [B]
GOTO D [A] 
GOTO $ [B] 
GOTO U
$
POP Z A .[A][C]
POP Z H ..[H]
POP Z B .[N]
GOTO U
D
POP Z r .
POP Z M .
POP Z N ...........
POP Z z .[N]
POP Z V .[H]
+
GOTO l[V] [H] 
POP Z H [H]
POP Z z [z]
GOTO ( [z] 
GOTO +
(
GOTO ) [H] 
POP Z z .[N]
POP Z M ..[M]
POP Z V .[H]
GOTO +
)
POP Z r .0[r]
POP Z M ..[M]
POP Z H .[M]
POP Z M .
POP Z V .[H]
POP Z z .[N]
GOTO +
l
POP Z r .0[r]
GOTO -
l.
POP Z r .1[r]
GOTO -
l..
POP Z r .2[r]
GOTO -
l...
POP Z r .3[r]
GOTO -
l....
POP Z r .4[r]
GOTO -
l.....
POP Z r .5[r]
GOTO -
l......
POP Z r .6[r]
GOTO -
l.......
POP Z r .7[r]
GOTO -
l........
POP Z r .8[r]
GOTO -
l.........
POP Z r .9[r]
GOTO -
-
GOTO / [M] 
POP Z H .[M]
POP Z M .
POP Z V .[H]
POP Z z .[N]
GOTO +
/
OUTPUT [r]

fè una funzione (forse) ricorsiva per convertire numeri interi in punti. L'argomento viene salvato [p]e riprodotto in [o].

Uè un test funzionale S1>=S2, che memorizza i parametri B, Adurante il salvataggio A-Bin A.

Il codice che inizia da Dè uno stub che converte i punti in numeri.

Il principio alla base è lo stesso con la mia risposta in C (strappando l'output falso per soluzioni impossibili).

Versione standalone, 149 156 157 167 170 230 byte, supporta solo I / O unario

L'input deve essere punti, ad es . ..........Per 10.

INPUT A
INPUT B
INPUT C
POP N H .
GOTO U
$
POP N A .[A][C]
POP Z H ..[H]
U
POP Z A [A]
POP Z N ..[N]
GOTO D [A] 
GOTO $ .[B] [N]
GOTO U
D
OUTPUT .[H]

Ucalcola A=A-Be passa a Dquando A<=0. In caso contrario, $assegna A+Ca Ae call U.

Appendere se non viene trovata alcuna soluzione.

Trucchi: abusare della capacità del "compilatore" di interpretare una stringa vuota. È possibile fregare le condizioni in GOTOdichiarazione per fare salti incondizionati e lo stesso trucco funziona per POP.

Nota: posso giocare a golf più di 3 byte, ma facendo così, la mia e la risposta di WheatWizard avrebbero la stessa identica logica. Il risultato è probabilmente la soluzione GraySnail più corta e sto provando a dimostrarlo.

Nota: il conteggio dei byte viene messo in discussione da Martin Ender nei commenti. Sembra che non ci sia un chiaro consenso su cosa fare con le espressioni lambda ricorsive nominate nelle risposte C #. Quindi ho fatto una domanda su Meta al riguardo.

C # (.NET Core) , 32 31 byte

f=(a,b,c)=>a>b?1+f(a-b+c,b,c):1

Provalo online!

Un approccio ricorsivo. Se la lumaca non può scappare, termina con il seguente messaggio:Process is terminating due to StackOverflowException.

• 1 byte salvato grazie a LiefdeWen!

LUMACA GRIGIA, 219 206 169 167 159 156 146 byte (IO unario)

INPUT a
INPUT u
INPUT d
POP U c 
GOTO 1
3
POP f a [a][d]
POP U c ..[c]
1
GOTO 2 [a] 
GOTO 3 [U] [u]
POP f U ..[U]
POP f a [a]
GOTO 1
2
OUTPUT [c].

Penso di poter giocare a golf un po '.

JavaScript (ES6), 31 28 27 byte

Risparmio di pochi byte grazie a @Arnauld

Non mi ero reso conto che avremmo potuto fallire con un'eccezione. Abbastanza sicuro che questo sia ottimale:

u=>d=>g=h=>h>u?1+g(h-u+d):1

Assegna a una variabile con es. f=, Quindi chiama come f(climb)(fall)(height). Lancia InternalError: too much recursionse la salita è impossibile.

JavaScript (ES6), 38 byte

f=(h,u,d=0)=>h>u?u>0?1+f(h-u,u-d):+f:1

Una funzione ricorsiva che restituisce il numero di giorni o NaNper mai.

Casi test

let f=(h,u,d=0)=>h>u?u>0?1+f(h-u,u-d):+f:1;

[
  [30,  3,  2],
  [84, 17, 15],
  [79, 15,  9],
  [29, 17,  4],
  [13, 18,  8],
  [ 5,  5, 10],
  [ 7,  7,  7],
  [69,  3,  8],
  [81, 14, 14]
].map(x => console.log(x + '', '->', f.apply(null, x)))

Excel, 51 46 byte

-1 byte grazie a @ Scarabee .

-4 perché INT (x) = PAVIMENTO (x, 1)

=IF(B1<A1,IF(C1<B1,-INT((B1-A1)/(B1-C1)-1)),1)

Input prelevato rispettivamente dalle celle A1, B1 e C1. Restituisce FALSEper scenari non validi.

C (gcc), 39 43 44 46 47 58 60 byte

Solo su GCC a 32 bit e tutte le ottimizzazioni disattivate.

f(a,b,c){a=a>b?b>c?1+f(a-b+c,b,c):0:1;}

Restituisce 0 quando la soluzione è impossibile. Una versione modificata della soluzione ricorsiva originale.

Ispirato alla soluzione @Jonah J e alla soluzione @CarlosAlejo C #.

Aggiornerò la versione estesa in seguito (dopo aver terminato la mia risposta alla lumaca grigia).

Java (OpenJDK 8) , 35 byte

(a,b,c)->b<a?c<b?(a+~c)/(b-c)+1:0:1

Provalo online!

La matematica vince!

Crediti

• -1 byte grazie a Kevin Cruijssen

Python 2 , 37 byte

f=lambda x,y,z:x-y<1or 1+f(x-y+z,y,z)

Provalo online!

Alla fine ho ottenuto la mia versione ricorsiva al di sotto del mio calcolo standard (stavo passando un conteggio alla mia funzione invece di aggiungerne uno prima di chiamarlo).

Python 2 , 4346 byte

#43 bytes
lambda x,y,z:y/x>0 or[1-(x-y)/(z-y),0][z/y]
#46 bytes
lambda x,y,z:y/x and 1or[1-(x-y)/(z-y),0][z/y]

Provalo online!

Rasato 3 byte scambiando "__ e 1" per "__> 0".

Usando l'inganno booleano, esegue essenzialmente:

if floor(y/x) > 0:
    return True # == 1
elif floor(z/y) == 1:
    return 0
elif floor(z/y) == 0:
    return 1-floor((x-y)/(z-y))
    # Python 2 implicitly treats integer division as floor division
    # equivalent: 1 + math.ceil((y-x)/(z-y))
    # because: -floor(-x) == ceil(x)

R, 43 byte

Prendendo in prestito da altre risposte:

g=function(a,b,c)`if`(b<a,1+g(a-b+c,b,c),1)

Dà errore se nessuna soluzione.

J, 25 byte

Innanzitutto una buona soluzione, che è un imbroglione, dato che presuppone che "qualsiasi cosa diversa da un risultato intero positivo" sia uguale a "Nessuno":

>.>:%/2-/\

spiegazione

• 2-/\usa finestre di lunghezza 2 attraverso il nostro input di 3 elementi, posizionando un segno meno tra ciascuno, che per l'input 30 3 2, ad esempio, ritorna27 1
• %/ inserisci un simbolo di divisione tra ciascun elemento dell'elenco, nel nostro caso l'elenco ha solo due elementi, quindi significa "dividi 27 per 1"
• >: incrementare di 1
• >. prendere il soffitto

soluzione ufficiale

Ecco la soluzione ufficiale che converte i negativi e l'infinito in 0, da cui non sono riuscito a trovare una soluzione soddisfacente per:

0:`[@.(>&0*<&_)>.>:%/2-/\

TIO

Perl 5 , 37 byte

35 byte codice +2 per -pa.

$i-=$F[2]while++$\,($i+=$F[1])<$_}{

Provalo online!

PHP> = 7.1, 60 byte

stampa 0 per non scappare

[,$h,$u,$d]=$argv;echo$h>$u?$u>$d?ceil(($h-$d)/($u-$d)):0:1;

PHP Sandbox online

PHP> = 7,1, 67 byte

non stampa nulla per non scappare

for([,$h,$u,$d]=$argv;($u>$d?:$h<=$u)&&0<$h+$t*$d-$u*++$t;);echo$t;

PHP Sandbox online

Mathematica, 47 40 39 byte

If[#==#2,1,⌈(#-#3)/(#2-#3)⌉~Max~0]&

-7 byte da @KeyuGan

Rubino , 49 47 byte

->h,a,b{h-a<1?1:(1.0*(h-a)/[a-b,0].max+1).ceil}

Fa eccezione se la lumaca non riesce a uscire

Provalo online!

Lotto, 66 byte

@set/an=%4+1,a=%1-%2+%3
@if %1 gtr %2 %0 %a% %2 %3 %n%
@echo %n%

Il secondo ultimo test case non ha stampato nulla e l'ultimo test case si è effettivamente bloccato CMD.EXE...

05AB1E , 19 byte

0[¼²+D¹<›i¾q}³-D1‹#

Spiegazione:

0                   Initialise stack with 0
 [                  while(true)
  ¼                   increment the counter variable
   ²+                 add the second input to the top of the stack
     D¹<›i            if it is greater than or equal to the first input
          ¾             push the counter variable
           q            terminate the program
             }        end if
              ³-      subtract the third input from the top of the stack
                D     duplicate top of stack
                 1‹   if it is less than 1
                   #  break the loop

Per valori non validi, questo può restituire qualsiasi valore inferiore a 1. Tuttavia, in 05AB1E, solo 1 è veritiero, quindi soddisfa il requisito secondo cui l'output per un valore non valido deve essere errato.

Provalo online!

PHP, 60 byte

[,$h,$v,$d]=$argv;echo$h>$v?$v>$d?ceil(($h-$d)/($v-$d)):N:1;

stampe Nper None. Corri con -r.

05AB1E , 12 byte

.×ηO<²›1k2÷>

Provalo online!

Stampa 0se impossibile.

Formato di input:

[climb, -fall]
height

Japt , 12 byte

@UµV-W §W}aÄ

Provalo online!

Produce undefinedper sempre, dopo aver eventualmente bloccato il browser per un po ', quindi fai attenzione.

Non sono convinto che sia ottimale. oWV-W lfunziona su tutti tranne gli ultimi tre casi ...

Haskell , 30 29 byte

(b!c)a=1+sum[(b!c)$a+c-b|a>b]

Provalo online!

Più breve della risposta Haskell esistente. Forse qualcun altro può battermi.

Questo utilizza un approccio ricorsivo per risolvere il problema. Ogni ricorsione è essenzialmente un giorno di movimento per la lumaca. Se la distanza lasciata alla fine è inferiore alla distanza ancora necessaria, terminiamo la nostra ricorsione.

QBIC , 31 23 byte

Ho appena notato che i requisiti sono cambiati. Questa versione non controlla se la lumaca raggiungerà mai la cima del pozzo.

≈:-:>0|q=q+1┘a=a-b+:]?q

La spiegazione seguente, per la versione originale che verifica se esiste una soluzione, copre anche tutte le parti rilevanti di questo codice.

Risposta originale a 31 byte:

~:>:|≈:-a>0|q=q+1┘c=c-a+b]?q\?0

Spiegazione

~           IF
 :          cmd line arg 'a'  (the increment of our snail)
  >         is greater than
   :        cmd line arg 'b'  (the decrement, or daily drop)
    |       THEN
≈           WHILE
 :          cmd line arg 'c'  (the height of the well)
  -a        minus the increment (we count down the hieght-to-go)
    >0|     is greater than 0 (ie while we haven't reached the top yet)
q=q+1       Add a day to q (day counter, starts at 1)
┘           (syntactic linebreak)
c=c-a+b     Do the raise-and-drop on the height-to-go
]           WEND
?q          PRINT q (the number of days)
\?0         ELSE (incrementer <= decrementer) print 0 (no solution)

Provalo online! (OK, non proprio: questa è una traduzione di QBIC in codice QBasic eseguito nell'ambiente QBasic di repl.it (un po 'carente)

Excel VBA, 47 byte

Funzione di finestra immediata VBE anonima che accetta l'input dall'intervallo [A1:C1]dagli ActiveSheetoutput dell'oggetto alla finestra immediata VBE

Questa soluzione basata principalmente su formule Excel sembra essere più piccola di qualsiasi soluzione puramente VBA che posso trovare :(

?[If(B1>C1,-Int((B1-A1)/(B1-C1)-1),Int(A1=B1))]

Haskell, 47 55 byte (48 se necessaria la tupla)

f d c s|d<=c=1|c<s= -1|d>c||c<s=1+(f(d-c+s)c s)

variazione di tupla

f(d,c,s)|d<=c=1|c<s= -1|d>c||c<s=1+(f(d-c+s)c s)

Spiegazione

f d c s       function that does all the heavy lifting =)
              d - depth
              c - climb per day
              s - slide per night

 |d<=c=1             recursion terminator. 1 day of climbing 
 |c<s= -1            possibility check. top can't be reached
 |otherwise=1+(f(d-c+s)c s)  1 day plus the rest of the distance

Python 3, 41 byte

f=lambda a,b,c:int(b>=a)or 1+f(a-b+c,b,c)

Errore per mai

Outgolf @veganaiZe

APL (Dyalog) , 13 byte

(⌈+÷⊢)/0⌈2-/⊢

Provalo online!

Errori nella divisione per zero se la lumaca non riesce a uscire dal pozzo.

C # (.NET Core) , 37 byte

(h,c,f)=>h>c?f<c?1+(h-f-1)/(c-f):0:1;

Lambda non ricorsivo. Usa la formula trovata qui . Potrebbe essere ridotto di 6 byte se "qualsiasi risultato negativo" è un modo valido per restituire un errore; attualmente restituisce 0 invece.

Python v2 e v3, 44 byte

f=lambda x,y,z:1+f(x-(y-z),y,z)if x>y else 1

^ Ricorsione infinita (errore) per il caso Nessuno.

Calcolatrice programmabile HP-15C, 26 byte

I tre numeri vengono caricati nello stack in ordine prima di eseguire il programma. L'altezza di caduta viene inserita come numero negativo. Se la lumaca non riesce a uscire dal pozzo, il risultato è un numero negativo o errore # 0 (errore di divisione zero).

Codici operativi in ​​esadecimale:

C5 C1 B4 C5 FB 74 1A C4 FA B4 C5 FD C1 C1 A3 70 C6 F0 B4 FA EB F1 FA B2 0A F1

Significato dell'istruzione:

x↔y 
ENTER
g R⬆
x↔y 
− 
g TEST x≤0 
GTO A
R⬇
+ 
g R⬆
x↔y 
÷ 
ENTER
ENTER
f FRAC
TEST x≠0 
EEX 
0 
g R⬆
+ 
g INT 
1 
+ 
g RTN 
f LBL A
1

Puoi provare il programma con questo simulatore HP-15C .

Lisp comune, 49 byte

(defun f(a b c)(if(> a b)(1+(f(+(- a b)c)b c))1))

Provalo online!

Funzione ricorsiva, overflow dello stack se non viene trovata alcuna soluzione.

PowerShell , 95 94 byte

$g=$args[0]
$c=$args[1]
$f=$args[2]
$p=0
$d=0
1..$g|%{$d+=1;$p+=$c;if($p-ge$g){$d;exit}$p-=$f}

Provalo online!