Hintergrund

Es gibt ein allgemeines Rätsel, das ungefähr so ​​lautet:

Eine Schnecke ist am Boden eines 30-Fuß-Brunnens. Jeden Tag kann die Schnecke 3 Fuß hoch klettern. Nachts, wenn sie schlafen, rutschen sie 2 Fuß zurück. Wie viele Tage braucht die Schnecke, um aus dem Brunnen zu kommen?

Die intuitive Antwort ist

30 Tage, da die Schnecke 30 Tage lang mit 1 Fuß pro Tag klettert, um den Gipfel zu erreichen,

aber eigentlich ist die antwort

28 Tage, da die Schnecke, sobald sie sich 27 Fuß in der Luft befindet (nach 27 Tagen), am 28. Tag einfach die restlichen 3 Fuß nach oben klettert.

Herausforderung

Diese Herausforderung verallgemeinert dieses Rätsel. Bei drei positiven Ganzzahlen als Eingabe, die die Gesamthöhe, die Aufstiegshöhe und die Fallhöhe darstellen, wird die Anzahl der Tage zurückgegeben, die zum Aufstieg aus dem Bohrloch benötigt werden.

Wenn die Schnecke nicht aus dem Brunnen klettern kann, können Sie 0 zurückgeben, einen falschen Wert zurückgeben oder eine Ausnahme auslösen. Sie können auch Code schreiben, der genau dann anhält, wenn eine Lösung vorhanden ist.

Wenn Sie möchten, können Sie die Fallhöhe als negative Ganzzahl verwenden.

Testfälle

(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) -> Keine
(81, 14, 14) -> Keine

Wertung

Das ist Code-Golf , also gewinnt die kürzeste Antwort in jeder Sprache.

Graue Schnecke , 1206 Bytes für numerische E / A, 149 Bytes für unäre E / A

Zum Spass. Zusammensetzung des ersten Programms:

• 451 Bytes, die Zahl in Punkte umwandeln
• 121 Bytes, Kernfunktion (eine separate Version ist unten geschrieben)
• 634 Bytes, Punkte in Zahlen umwandeln

Numerische Eingabe und Ausgabe übernehmen. Eingegeben wird A, B, Cbzw.. Im Vergleich zu anderen (nahen) O(1)Antworten hat der Code eine Komplexität von O(n). Aber für eine große Anzahl kann es Ihr Gedächtnis zuerst verbrauchen.

Hängen Sie, wenn keine Lösung gefunden wird.

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]

fist eine (vielleicht) rekursive Funktion, um ganze Zahlen in Punkte umzuwandeln. Argument wird in gespeichert [p]und in ausgegeben [o].

Uist ein Funktionstest S1>=S2, bei dem Parameter B, Abeim Speichern A-Bin gespeichert werden A.

Code ab Dist ein Stub, der Punkte in Zahlen umwandelt.

Das zugrunde liegende Prinzip ist das gleiche wie bei meiner C-Antwort (Abzocke der falschen Ausgabe für unmögliche Lösungen).

Standalone-Version, 149 156 157 167 170 230 Bytes, unterstützen nur unäre I / O

Eingangs Bedürfnisse zu Punkten, zB ..........für 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]

Uberechnet A=A-Bund springt zu Dwann A<=0. Ansonsten $ordnet A+Czu Aund ruft an U.

Hängen Sie, wenn keine Lösung gefunden wird.

Tricks: Missbrauch der Fähigkeit des "Compilers", leere Zeichenketten zu interpretieren. Sie können Bedingungen in GOTOAnweisung abreißen , um bedingungslose Sprünge zu machen, und der gleiche Trick funktioniert für POP.

Bemerkung: Ich spiele vielleicht mehr Golf mit 3 Bytes, aber wenn ich das tue, hätten meine und WheatWizard's Antwort genau dieselbe Logik. Das Ergebnis ist wahrscheinlich die kürzeste GraySnail-Lösung, und ich versuche, es zu beweisen.

Hinweis: Die Anzahl der Bytes wird von Martin Ender in den Kommentaren abgefragt. Es scheint keinen klaren Konsens darüber zu geben, was mit benannten, rekursiven Lambda-Ausdrücken in C # -Antworten zu tun ist. Also habe ich in Meta eine Frage dazu gestellt.

C # (.NET Core) , 32 - 31 Byte

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

Probieren Sie es online!

Ein rekursiver Ansatz. Wenn die Schnecke nicht entkommen kann, endet sie mit der folgenden Meldung:Process is terminating due to StackOverflowException.

• Dank LiefdeWen 1 Byte gespart!

GREY SNAIL, 219 206 169 167 159 156 146 Byte (unäre E / A)

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

Ich denke, ich kann das ein bisschen runter spielen.

JavaScript (ES6), 31 28 27 Byte

Ein paar Bytes gespart dank @Arnauld

Ich hatte nicht bemerkt, dass wir mit einer Ausnahme scheitern könnten. Ziemlich sicher, dass dies optimal ist:

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

Mit zB einer Variablen zuweisen f=, dann like aufrufen f(climb)(fall)(height). Wirft, InternalError: too much recursionwenn der Aufstieg unmöglich ist.

JavaScript (ES6), 38 Byte

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

Eine rekursive Funktion, die die Anzahl der Tage oder NaNfür nie zurückgibt .

Testfälle

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 Bytes

-1 Byte danke an @ Scarabee .

-4 weil INT (x) = FLOOR (x, 1)

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

Eingabe von den Zellen A1, B1 bzw. C1. Gibt FALSEfür ungültige Szenarien zurück.

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

Nur auf 32-Bit-GCC und alle Optimierungen deaktiviert.

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

Geben Sie 0 zurück, wenn die Lösung nicht möglich ist. Eine modifizierte Version der ursprünglichen rekursiven Lösung.

Inspiriert von der @Jonah J-Lösung und der @CarlosAlejo C # -Lösung.

Ich werde die erweiterte Version später aktualisieren (nachdem ich meine Gray Snail-Antwort beendet habe).

Java (OpenJDK 8) , 35 Byte

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

Probieren Sie es online!

Mathe gewinnt!

Credits

• -1 Byte dank Kevin Cruijssen

Python 2 , 37 Bytes

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

Probieren Sie es online!

Endlich meine rekursive Version unter meiner Standardberechnung (ich habe meiner Funktion eine Zählung übergeben, anstatt eine vor dem Aufruf hinzuzufügen).

Python 2 , 4346 Bytes

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

Probieren Sie es online!

Rasiert 3 Bytes durch Tauschen von "__ und 1" gegen "__> 0".

Mit Boolescher Trickserei wird im Wesentlichen Folgendes ausgeführt:

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 Bytes

Aus anderen Antworten entlehnt:

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

Gibt Fehler wenn keine Lösung.

J, 25 Bytes

Zuerst eine nette Lösung, die ein Betrüger ist, da davon ausgegangen wird, dass "etwas anderes als ein positives ganzzahliges Ergebnis" gleich "Keine" ist:

>.>:%/2-/\

Erläuterung

• 2-/\Verwenden Sie Fenster der Länge 2 für die Eingabe von 3 Elementen und setzen Sie zwischen jedes ein Minuszeichen, das für die Eingabe 30 3 2z. B. zurückgegeben wird27 1
• %/ Setzen Sie ein Trennsymbol zwischen jedes Element der Liste. In unserem Fall hat die Liste nur zwei Elemente. Das bedeutet also "27 durch 1 teilen".
• >: Inkrement um 1
• >. Nimm die Decke

offizielle Lösung

Hier ist die offizielle Lösung, die Negative und Unendlich in 0 umwandelt. Für diesen Teil konnte ich keine zufriedenstellend knappe Lösung finden:

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

TIO

Perl 5 , 37 Bytes

35 Byte Code +2 für -pa.

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

Probieren Sie es online!

PHP> = 7.1, 60 Bytes

Gibt 0 für kein Entrinnen aus

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

PHP Sandbox Online

PHP> = 7.1, 67 Bytes

druckt nichts für kein Entrinnen

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

PHP Sandbox Online

Mathematica, 47 40 39 Bytes

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

-7 Bytes von @KeyuGan

Ruby , 49 47 Bytes

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

Wirft eine Ausnahme, wenn die Schnecke nicht herausklettern kann

Probieren Sie es online!

Batch, 66 Bytes

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

Der vorletzte Testfall hat nichts gedruckt und der letzte Testfall ist tatsächlich abgestürzt CMD.EXE...

05AB1E , 19 Bytes

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

Erläuterung:

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

Für ungültige Werte kann dies einen Wert kleiner als 1 zurückgeben. In 05AB1E ist jedoch nur 1 wahr, sodass die Anforderung erfüllt ist, dass die Ausgabe für einen ungültigen Wert falsch sein muss.

Probieren Sie es online!

PHP, 60 Bytes

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

druckt Nfür None. Laufen Sie mit -r.

05AB1E , 12 Bytes

.×ηO<²›1k2÷>

Probieren Sie es online!

Druckt, 0falls nicht möglich.

Eingabeformat:

[climb, -fall]
height

Japt , 12 Bytes

@UµV-W §W}aÄ

Online testen!

Ausgaben undefinedfür nie, nachdem Sie Ihren Browser möglicherweise für eine Weile eingefroren haben, seien Sie also vorsichtig.

Ich bin nicht überzeugt, dass dies optimal ist. oWV-W lfunktioniert in allen bis auf die letzten drei Fälle ...

Haskell , 30 29 Bytes

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

Probieren Sie es online!

Kürzer als die bisherige Haskell-Antwort. Vielleicht kann mich jemand anderes schlagen.

Dies verwendet einen rekursiven Ansatz zur Lösung des Problems. Jede Rekursion ist im Wesentlichen ein Bewegungstag für die Schnecke. Wenn der verbleibende Abstand zum Ende geringer ist als der noch erforderliche Abstand, beenden wir unsere Rekursion.

QBIC , 31 23 Bytes

Ich habe gerade bemerkt, dass sich die Anforderungen geändert haben. Diese Version überprüft nicht, ob die Schnecke jemals die Spitze des Brunnens erreicht.

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

Die nachstehende Erklärung für die Originalversion, die prüft, ob eine Lösung vorhanden ist, deckt auch alle relevanten Teile dieses Codes ab.

Original, 31-Byte-Antwort:

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

Erläuterung

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

Probieren Sie es online! (OK, nicht wirklich: Dies ist eine Übersetzung von QBIC in QBasic-Code, der in der QBasic-Umgebung von repl.it ausgeführt wird.)

Excel VBA, 47 Bytes

Anonyme VBE-Direktfensterfunktion, die Eingaben aus dem Bereich [A1:C1]der ActiveSheetObjektausgaben in das VBE-Direktfenster aufnimmt

Diese hauptsächlich auf Excel-Formeln basierende Lösung scheint kleiner zu sein als jede reine VBA-Lösung, die ich mir vorstellen kann :(

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

Haskell, 47 55 Bytes (48, wenn Tupel erforderlich)

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

Tupelvariation

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

Erläuterung

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 Bytes

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

Fehler für Niemals

Outgolf @veganaiZe

APL (Dyalog) , 13 Bytes

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

Probieren Sie es online!

Fehler bei der Division durch Null, wenn die Schnecke nicht aus dem Brunnen klettern kann.

C # (.NET Core) , 37 Byte

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

Nicht rekursives Lambda. Verwendet die hier gefundene Formel . Könnte um 6 Byte verkürzt werden, wenn "ein negatives Ergebnis" ein gültiger Weg ist, um einen Fehler zurückzugeben. Derzeit wird stattdessen 0 zurückgegeben.

Python v2 & v3, 44 Bytes

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

^ Unendliche Rekursion (Fehler) für den Fall None.

HP-15C Programmierbarer Rechner, 26 Bytes

Die drei Zahlen werden der Reihe nach in den Stapel geladen, bevor das Programm ausgeführt wird. Die Fallhöhe wird als negative Zahl eingegeben. Wenn die Schnecke nicht aus dem Brunnen klettern kann, ist das Ergebnis entweder eine negative Zahl oder ein Fehler # 0 (Nullteilungsfehler).

Op-Codes in 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

Anweisungsbedeutungen:

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

Sie können das Programm mit diesem HP-15C-Simulator testen .

Common Lisp, 49 Bytes

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

Probieren Sie es online!

Rekursive Funktion, Stapelüberlauf, wenn keine Lösung gefunden wurde.

PowerShell , 95 bis 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}

Probieren Sie es online!