Contexte

Il y a une énigme commune qui ressemble à ceci:

Un escargot est au fond d'un puits de 30 pieds. Chaque jour, l'escargot est capable de grimper jusqu'à 3 pieds. La nuit, quand ils dorment, ils redescendent de deux pieds. Combien de jours faut-il pour que l'escargot sorte du puits?

La réponse intuitive est

30 jours, parce que l'escargot grimpe à 1 pied par jour pendant 30 jours pour atteindre le sommet,

mais en réalité la réponse est

28 jours, car une fois que l'escargot aura atteint 27 pieds de hauteur (après 27 jours), il ne lui restera plus qu'à gravir les 3 pieds restants jusqu'au sommet le 28e jour.

Défi

Ce défi généralise cette énigme. Avec trois nombres entiers positifs en entrée, représentant la hauteur totale, la hauteur de montée et la hauteur de chute, donne le nombre de jours nécessaires à la sortie du puits.

Si l'escargot ne peut pas sortir du puits, vous pouvez renvoyer 0, renvoyer une valeur de fausseté ou renvoyer une exception. Vous pouvez également écrire du code qui s’arrêtera si et seulement si une solution existe.

Si vous le souhaitez, vous pouvez prendre la hauteur de chute comme un entier négatif.

Cas de 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) -> Aucun
(81, 14, 14) -> Aucun

Notation

C'est du code-golf , donc la réponse la plus courte dans chaque langue est gagnante.

Escargot gris , 1206 octets pour les E / S numériques, 149 octets pour les E / S unaires

Pour s'amuser. Composition du premier programme:

• 451 octets, conversion du nombre en points
• 121 octets, fonction principale (une version séparée est écrite ci-dessous)
• 634 octets, convertissant les points en nombre

Prendre une entrée et une sortie numériques. Est entrée A, B, Crespectivement. Comparé à une autre O(1)réponse (proche) , le code a une complexité de O(n). Mais pour un grand nombre de personnes, il se peut qu’il dévorera d’abord votre mémoire.

Suspendez si aucune solution n'est trouvée.

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]

fest une fonction (peut-être) récursive pour convertir des entiers en points. L'argument est enregistré dans [p]et sorti dans [o].

Uest un test de fonction S1>=S2, stockant un paramètre lors de la B, Asauvegarde A-Bdans A.

Le code à partir de Dest une souche convertissant des points en nombres.

Le principe sous-jacent est le même avec ma réponse en C (extraire la fausseté pour obtenir des solutions impossibles).

Version autonome, 149 156 157 167 170 230 octets, supporte uniquement les entrées / sorties unaires

Les entrées doivent être des points, par exemple ..........pour 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]

Ucalcule A=A-Bet saute à Dquand A<=0. Sinon, $attribue A+Cà Aet appelle U.

Suspendez si aucune solution n'est trouvée.

Astuces: abusez de la capacité du "compilateur" à interpréter une chaîne vide. Vous pouvez extraire des conditions dans une GOTOinstruction pour effectuer des sauts inconditionnés et le même truc fonctionne pour POP.

Remarque: je peux jouer plus de 3 octets, mais ce faisant, ma réponse et celle de WheatWizard auraient exactement la même logique. Le résultat est probablement la solution GraySnail la plus courte et j'essaie de le prouver.

Remarque: le nombre d'octets est remis en question par Martin Ender dans les commentaires. Il semble qu'il n'y ait pas de consensus clair sur l'utilisation des expressions lambda récursives nommées dans les réponses C #. J'ai donc posé une question à Meta à ce sujet.

C # (.NET Core) , 32 31 octets

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

Essayez-le en ligne!

Une approche récursive. Si l'escargot ne peut pas s'échapper, il se termine par le message suivant:Process is terminating due to StackOverflowException.

• 1 octet économisé grâce à LiefdeWen!

GREY SNAIL, 219 206 169 167 159 159 156 146 octets (IO unaire)

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

Je pense que je peux jouer au golf un peu.

JavaScript (ES6), 31 28 27 octets

Enregistré quelques octets grâce à @Arnauld

Je n'avais pas réalisé que nous pouvions échouer avec une exception. Je suis sûr que c'est optimal:

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

Affecter à une variable avec par exemple f=, puis appeler comme f(climb)(fall)(height). Lance InternalError: too much recursionsi la montée est impossible.

JavaScript (ES6), 38 octets

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

Une fonction récursive qui renvoie le nombre de jours, ou NaNpour jamais.

Cas de 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 octets

-1 octet grâce à @ Scarabee .

-4 parce que INT (x) = FLOOR (x, 1)

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

Entrée prise des cellules A1, B1 et C1 respectivement. Renvoie FALSEles scénarios non valides.

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

Seulement sur GCC 32 bits et toutes les optimisations sont désactivées.

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

Renvoie 0 lorsque la solution est impossible. Une version modifiée de la solution récursive originale.

Inspiré par les solutions @Jonah J et @CarlosAlejo C #.

Je mettrai à jour la version développée plus tard (après avoir terminé ma réponse à Grey Snail).

Java (OpenJDK 8) , 35 octets

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

Essayez-le en ligne!

Math gagne!

Crédits

• -1 octet grâce à Kevin Cruijssen

Python 2 , 37 octets

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

Essayez-le en ligne!

Enfin, ma version récursive est en dessous de mon calcul standard (je passais un compte à ma fonction au lieu d’en ajouter un avant de l’appeler).

Python 2 , 4346 octets

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

Essayez-le en ligne!

Rasé 3 octets en échangeant "__ et 1" pour "__> 0".

En utilisant la supercherie booléenne, exécute essentiellement:

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 octets

Emprunter d'autres réponses:

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

Donne une erreur s'il n'y a pas de solution.

J, 25 octets

Premièrement, une bonne solution, qui est un tricheur, car elle suppose que "tout autre résultat qu'un résultat entier positif" est égal à "Aucun":

>.>:%/2-/\

explication

• 2-/\utilisez des fenêtres de longueur 2 sur notre entrée de 3 éléments, en plaçant un signe moins entre chaque élément, qui 30 3 2, par exemple, renvoie27 1
• %/ mettez un symbole de division entre chaque élément de la liste, dans notre cas, la liste ne contient que deux éléments, cela signifie donc "divise 27 par 1"
• >: incrémenter de 1
• >. prendre le plafond

solution officielle

Voici la solution officielle qui convertit les négatifs et l'infini en 0, partie pour laquelle je n'ai pas pu trouver de solution satisfaisante pour:

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

TIO

Perl 5 , 37 octets

35 octets code +2 pour -pa.

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

Essayez-le en ligne!

PHP> = 7.1, 60 octets

imprime 0 sans issue

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

PHP Sandbox en ligne

PHP> = 7.1, 67 octets

n'imprime rien sans issue

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

PHP Sandbox en ligne

Mathematica, 47 40 39 octets

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

-7 octets de @KeyuGan

Ruby , 49 47 octets

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

Lance une exception si l'escargot ne peut pas sortir

Essayez-le en ligne!

Lot, 66 octets

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

L'avant-dernier cas de test n'imprimait rien, et le dernier cas de test s'est réellement écrasé CMD.EXE...

05AB1E , 19 octets

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

Explication:

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

Pour les valeurs non valides, cela peut renvoyer toute valeur inférieure à 1. Toutefois, dans 05AB1E, seul 1 est la vérité, ce qui répond à l'exigence voulant que la sortie d'une valeur non valide soit faussée.

Essayez-le en ligne!

PHP, 60 octets

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

impressions Npour None. Courez avec -r.

05AB1E , 12 octets

.×ηO<²›1k2÷>

Essayez-le en ligne!

Imprime 0si impossible.

Format d'entrée:

[climb, -fall]
height

Japt , 12 octets

@UµV-W §W}aÄ

Testez-le en ligne!

Sorties undefinedpour jamais, après avoir éventuellement geler votre navigateur pendant un moment, alors soyez prudent.

Je ne suis pas convaincu que c'est optimal. oWV-W lfonctionne sur tous les cas sauf les trois derniers ...

Haskell , 30 29 octets

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

Essayez-le en ligne!

Plus courte que la réponse Haskell existante. Peut-être que quelqu'un d'autre peut me battre.

Ceci utilise une approche récursive pour résoudre le problème. Chaque récursion est essentiellement un jour de mouvement pour l'escargot. Si la distance laissée à la fin est inférieure à la distance requise, nous terminons notre récursion.

QBIC , 31 23 octets

Je viens de remarquer que les exigences ont changé. Cette version ne vérifie pas si l'escargot atteindra jamais le sommet du puits.

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

L'explication ci-dessous, pour la version originale qui vérifie si une solution existe, couvre également toutes les parties pertinentes de ce code.

Réponse d'origine, 31 octets:

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

Explication

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

Essayez-le en ligne! (OK, pas vraiment: il s’agit d’une traduction de QBIC en code QBasic exécuté dans l’environnement QBasic de repl.it (quelque peu manquant))

Excel VBA, 47 octets

Fonction de fenêtre immédiate VBE anonyme qui prend une entrée dans la plage [A1:C1]allant des ActiveSheetsorties d'objet à la fenêtre VBE immédiate

Cette solution, basée principalement sur une formule Excel, semble être plus petite que n’importe quelle solution purement VBA que je peux trouver :(

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

Haskell, 47 à 55 octets (48 si un tuple est requis)

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

variation du tuple

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

Explication

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 octets

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

Erreur pour Jamais

Outgolf @veganaiZe

APL (Dyalog) , 13 octets

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

Essayez-le en ligne!

Erreurs de division par zéro si l'escargot ne peut pas sortir du puits.

C # (.NET Core) , 37 octets

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

Lambda non récursif. Utilise la formule trouvée ici . Peut être raccourci de 6 octets si "tout résultat négatif" est un moyen valide de renvoyer un échec. renvoie actuellement 0 à la place.

Python v2 et v3, 44 octets

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

^ Récursion infinie (erreur) pour le cas Aucun.

Calculatrice programmable HP-15C, 26 octets

Les trois numéros sont chargés dans la pile dans l'ordre avant d'exécuter le programme. La hauteur de chute est entrée sous forme de nombre négatif. Si l'escargot ne peut pas sortir du puits, le résultat est un nombre négatif ou une erreur n ° 0 (erreur de division du zéro).

Codes Op en hex:

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

Signification des instructions:

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

Vous pouvez essayer le programme avec ce simulateur HP-15C .

Common Lisp, 49 octets

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

Essayez-le en ligne!

Fonction récursive, débordement de pile si aucune solution trouvée.

PowerShell , 95 à 94 octets

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

Essayez-le en ligne!