Verwenden Sie eine Programmiersprache, die Funktionen unterstützt

is_enough(strArr) 

das take, strArrdas ein Array sein wird, das aus den folgenden Elementen besteht:

• N Dies ist die Anzahl der Tankstellen auf einer Kreisstrecke
• und jedes nachfolgende Element wird die Zeichenfolge sein, g:cin der
  • g ist die Gasmenge in Gallonen an dieser Tankstelle und
  • c wird die Menge an Gallonen Gas sein, die benötigt wird, um zur folgenden Tankstelle zu gelangen.

Zum Beispiel strArrkann sein:

["4","3:1","2:2","1:2","0:1"]. 

Ihr Ziel ist es, den Index der Starttankstelle zurückzugeben, mit dem Sie die gesamte Route einmal umrunden können. Andernfalls geben Sie die Zeichenfolge "unmöglich" zurück .

Für das obige Beispiel gibt es 4 Tankstellen, und Ihr Programm sollte die Zeichenfolge "1" zurückgeben, weil:

• Ab Station 1 erhalten Sie 3 Gallonen Benzin und geben 1 für die nächste Station aus.

• Dann haben Sie 2 Gallonen + 2 mehr an der nächsten Station und Sie geben 2 aus, so dass Sie 2 Gallonen haben, wenn Sie zur 3. Station kommen.

• Sie haben dann 3, aber Sie verbringen 2 damit , zur Endstation zu gelangen.

• An der Endstation erhalten Sie 0 Gallonen und geben Ihre letzte Gallone aus, um zu Ihrem Ausgangspunkt zu gelangen.

Das Starten an einer anderen Tankstelle würde es unmöglich machen, die Route zu umgehen, daher lautet die Antwort "1" .

Wenn es mehrere Tankstellen gibt, an denen begonnen werden kann, geben Sie den kleinsten Index (der Tankstelle) zurück. Nwird sein >= 2.

Richtige Beispielausgaben:

Input: ["4","1:1","2:2","1:2","0:1"]
Output: "impossible"

Input: ["4","0:1","2:2","1:2","3:1"]
Output: "4"

Der Gewinner ist derjenige, der den kürzesten Code verwendet, obwohl er lang sein wird.

APL (70)

{×⍴G←Z/⍨0∧.≤¨+\¨¯1⌽⌽∘K¨Z←⍳⍴K←{⎕ML←3⋄-/⍎¨⍵⊂⍨⍵≠':'}¨1↓⍵:⊃G⋄'impossible'}

Erläuterung:

• 1↓⍵: Lass das erste Element (Länge) fallen, wir brauchen es nicht
• {... }¨: für jede Tankstelle ...
  • ⎕ML←3: ⎕MLinnerhalb der inneren Funktion auf 3 gesetzt (ändert das Verhalten von ⊂)
  • ⍵⊂⍨⍵≠':': Teilen Sie die Zeichenfolge auf :
  • ⍎¨: bewerten Sie jedes Teil
  • -/: subtrahiere die zweite Zahl von der ersten (was einen Nettoeffekt für jede Tankstelle ergibt)
• K←: Speichern Sie sie in K.
• Z←⍳⍴K: Holen Sie sich die Indizes für die Tankstelle ( 1auf Länge von K), speichern Sie inZ
• ⌽∘K¨Z: um Kjeden Wert von drehen Z, wodurch ein Array von Arrays erhalten wird
• ¯1⌽: Drehen Sie dieses Array um 1 nach links (um das unveränderte zuerst statt zuletzt zu setzen).
• +\¨: Machen Sie eine laufende Summe für jedes innere Array
• 0∧.≤¨: Überprüfen Sie für jede laufende Summe, ob negative Werte vorhanden sind
• Z/⍨: Wählen Sie aus Zden Elementen aus, für die die laufende Summe keine negativen Werte hatte
• ×⍴G←: speichern in G. Wenn Girgendwelche Elemente hat:
• :⊃G: gibt das erste Element von zurück G.
• ⋄'impossible': Andernfalls kehren Sie zurück impossible.

Bash 178 170 161 157

Eher geradlinig.

is_enough(){((t=(n=$1-1)<0))&&echo impossible||(x=(n ${@:3} $2);for z in ${@:2};do(((t+=${z%:*}-${z#*:})<0))&&is_enough ${x[*]}&&return;done;echo $[$#-++n])}

Abstand:

is_enough() {
     ((t=(n=$1-1)<0)) && echo impossible || (
         x=(n ${@:3} $2);
         for z in ${@:2};do
             (((t+=${z%:*}-${z#*:})<0)) && is_enough ${x[*]} && return;
         done;
         echo $[$#-++n]
     )
}

Ruby, 111

Hier ist eine Ruby-Lösung mit eval:

is_enough=->a{_,*s=a
"#{(1..s.size).find{|i|g=0;s.rotate(i-1).all?{|x|g+=eval x.tr ?:,?-;g>=0}}||:impossible}"}

Anwendungsbeispiel:

is_enough[%w(4 3:1 2:2 1:2 0:1)] #=> "1"
is_enough[%w(4 1:1 2:2 1:2 0:1)] #=> "impossible"
is_enough[%w(4 0:1 2:2 1:2 3:1)] #=> "4"
is_enough[%w(4 1:2 2:1 4:3 0:1)] #=> "2"
is_enough[%w(4 0:1 2:2 1:2 3:1)] #=> "4"
is_enough[%w(4 0:1 0:1 4:1 0:1)] #=> "3"
is_enough[%w(8 0:1 0:1 4:1 0:1 2:1 3:1 0:0 0:1)] #=> "3"

BEARBEITEN : Funktionsname und Rückgabetyp korrigiert.

Rubin 132

g=->a{n,*a=a.map{|e|e.split(?:).map &:to_i}
(r=(0...n[0]).find{|i|a.rotate(i).inject(0){|m,(j,k)|m&&m>=0&&m+j-k}})?r+1:"impossible"}

Prüfung:

irb(main):003:0> g[["4","1:1","2:2","1:2","0:1"]]
=> "impossible"
irb(main):004:0> g[["4","0:1","2:2","1:2","3:1"]]
=> 4

Python, 131

Ich finde diesen Einzeiler ziemlich befriedigend.

E=lambda s:([`i`for i in range(1,len(s)+1)if reduce(lambda r,t:r+eval(t[0]+'-'+t[-1])*(r>=0),s[i:]+s[1:i],0)>=0]+['impossible'])[0]

GolfScript (72 Zeichen)

{(~\{':'/{~}/-}%[\),1>{;.{1$-1>*+}*-1>\(+\},~"impossible"]1=}:is_enough;

Online-Demo

Dies führt den offensichtlichen Brute-Force-Ansatz durch. Das interessanteste Bit IMO ist die Bestimmung, ob die Teilsummen einer Anordnung von Delta-Kraftstoff jemals unter 0 fallen:

{1$-1>*+}*-1>

Dies spart 1 Zeichen gegenüber dem offensichtlicheren

[{1$+}*]{0<},!

Wenn die Ausgabe bei 0 anstatt bei 1 indiziert wäre, wäre ein alternativer Ansatz zum Drehen des Arrays vorzuziehen:

{(;{':'/{~}/-}%:A[,,{A\{(+}*{1$-1>*+}*-1>},~"impossible"]0=}:is_enough;

Dieser Ansatz lässt sich jedoch nicht leicht auf die Indizierung bei 1 anwenden:

{(;{':'/{~}/-}%:A[,),1>{A\({(+}*{1$-1>*+}*-1>},~"impossible"]0=}:is_enough;

oder

{(;{':'/{~}/-}%:A[,,{A\{(+}*{1$-1>*+}*-1>},{)}%~"impossible"]0=}:is_enough;