Usando cualquier lenguaje de programación que admita funciones, tenga la función

is_enough(strArr) 

esa toma, strArrque será una matriz que consta de los siguientes elementos:

• N que será el número de estaciones de servicio en una ruta circular
• y cada elemento posterior será la cadena g:cdonde
  • g es la cantidad de gas en galones en esa estación de servicio y
  • c será la cantidad de galones de gasolina necesarios para llegar a la siguiente estación de servicio.

Por ejemplo strArrpuede ser:

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

Su objetivo es devolver el índice de la estación de servicio de partida que le permitirá recorrer la ruta completa una vez; de lo contrario, devolverá la cadena "imposible" .

Para el ejemplo anterior hay 4 estaciones de servicio, y su programa debería devolver la cadena "1" porque:

• Comenzando en la estación 1 , recibe 3 galones de gasolina y gasta 1 para llegar a la siguiente estación.

• Luego tiene 2 galones + 2 más en la próxima estación y gasta 2 para tener 2 galones cuando llegue a la tercera estación.

• Entonces tienes 3 pero pasas 2 para llegar a la estación final,

• En la estación final recibe 0 galones y gasta su galón final para llegar a su punto de partida.

Comenzar en cualquier otra estación de servicio haría imposible moverse por la ruta, por lo que la respuesta es "1" .

Si hay varias estaciones de servicio en las que es posible comenzar, devuelva el índice más pequeño (de la estación de servicio). Nserá >= 2.

Resultados de muestra correctos:

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

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

El ganador será el que use el código más corto, aunque será largo.

APL (70)

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

Explicación:

• 1↓⍵: suelte el primer elemento (longitud), no lo necesitamos
• {... }¨: para cada una de las estaciones de servicio ...
  • ⎕ML←3: establecido ⎕MLen 3 dentro de la función interna (cambia el comportamiento de ⊂)
  • ⍵⊂⍨⍵≠':': dividir la cadena en :
  • ⍎¨: evaluar cada parte
  • -/: resta el segundo número del primero (dando un efecto neto para cada estación de servicio)
• K←: almacenarlos en K
• Z←⍳⍴K: obtener los índices de la estación de servicio ( 1a la longitud de K), almacenar enZ
• ⌽∘K¨Z: rotar Kpor cada valor de Z, dando una matriz de matrices
• ¯1⌽: gire esta matriz a la izquierda por 1 (para poner la que no ha cambiado primero en lugar de la última)
• +\¨: hacer una suma acumulada para cada matriz interna
• 0∧.≤¨: para cada suma acumulada, vea si hay valores negativos
• Z/⍨: seleccione de Zaquellos elementos para los que la suma acumulada no tenía valores negativos
• ×⍴G←: almacenar en G. Si Gtiene algún elemento:
• :⊃G: devuelve el primer elemento de G.
• ⋄'impossible': de lo contrario, volver impossible.

Bash 178 170 161 157

Más bien sencillo.

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])}

Espaciado:

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

Aquí hay una solución Ruby usando 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}"}

Ejemplo de uso:

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"

EDITAR : Nombre de función corregido y tipo de retorno.

Rubí 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"}

Prueba:

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

Encuentro esta frase bastante satisfactoria.

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

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

Demostración en línea

Esto realiza el enfoque de fuerza bruta obvio. El bit más interesante de la OMI es la determinación de si las sumas parciales de una matriz de combustible delta alguna vez cae por debajo de 0:

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

Esto ahorra 1 char sobre el más obvio

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

Si la salida se indexara en 0 en lugar de en 1, sería preferible un enfoque alternativo para rotar la matriz:

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

Pero este enfoque no se adopta fácilmente para indexar en 1:

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

o

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