Sử dụng bất kỳ ngôn ngữ lập trình nào hỗ trợ các chức năng, có chức năng

is_enough(strArr) 

mà mất strArrmà sẽ là một một mảng gồm các yếu tố sau:

• N đó sẽ là số lượng trạm xăng trong một tuyến đường tròn
• và mỗi phần tử tiếp theo sẽ là chuỗi g:ctrong đó
  • g là lượng khí tính bằng gallon tại trạm xăng đó và
  • c sẽ là lượng gallon khí cần thiết để đến trạm xăng sau.

Ví dụ strArrcó thể là:

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

Mục tiêu của bạn là trả về chỉ số của trạm xăng bắt đầu cho phép bạn đi vòng quanh toàn bộ tuyến đường một lần, nếu không sẽ trả lại chuỗi "không thể" .

Đối với ví dụ trên có 4 trạm xăng và chương trình của bạn sẽ trả về chuỗi "1" vì:

• Bắt đầu từ trạm 1, bạn nhận được 3 gallon xăng và dành 1 để đến trạm tiếp theo.

• Sau đó, bạn có thêm 2 gallon + 2 thêm ở trạm tiếp theo và bạn dành 2 để bạn có 2 gallon khi bạn đến trạm thứ 3.

• Sau đó, bạn có 3 nhưng bạn dành 2 để đến trạm cuối cùng,

• Tại trạm cuối cùng, bạn nhận được 0 gallon và bạn dành gallon cuối cùng để đến điểm xuất phát.

Bắt đầu tại bất kỳ trạm xăng nào khác sẽ khiến việc đi lại quanh tuyến không thể thực hiện được, vì vậy câu trả lời là "1" .

Nếu có nhiều trạm xăng có thể bắt đầu tại, hãy trả về chỉ số nhỏ nhất (của trạm xăng). Nsẽ >= 2.

Kết quả đầu ra mẫu chính xác:

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

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

Người chiến thắng sẽ là người sử dụng mã ngắn nhất mặc dù nó sẽ dài.

APL (70)

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

Giải trình:

• 1↓⍵: thả phần tử đầu tiên (độ dài), chúng tôi không cần nó
• {... }¨: cho mỗi trạm xăng ...
  • ⎕ML←3: đặt ⎕MLthành 3 trong hàm bên trong (thay đổi hành vi của ⊂)
  • ⍵⊂⍨⍵≠':': tách chuỗi trên :
  • ⍎¨: đánh giá từng phần
  • -/: trừ số thứ hai từ số thứ nhất (tạo hiệu ứng ròng cho mỗi trạm xăng)
• K←: lưu trữ chúng trong K
• Z←⍳⍴K: lấy các chỉ số cho trạm xăng ( 1theo chiều dài K), lưu trữ trongZ
• ⌽∘K¨Z: xoay Ktheo từng giá trị của Z, đưa ra một mảng các mảng
• ¯1⌽: xoay mảng này sang trái 1 (để đặt mảng không thay đổi trước thay vì cuối cùng)
• +\¨: tạo tổng chạy cho từng mảng bên trong
• 0∧.≤¨: cho mỗi tổng chạy, xem có giá trị âm không
• Z/⍨: chọn từ Zcác phần tử mà tổng chạy không có giá trị âm
• ×⍴G←: cửa hàng trong G. Nếu Gcó bất kỳ yếu tố nào:
• :⊃G: trả về phần tử đầu tiên của G.
• ⋄'impossible': nếu không, trở lại impossible.

Bash 178 170 161 157

Khá thẳng về phía trước.

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

Cách nhau ra:

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

Đây là một giải pháp Ruby sử dụng 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}"}

Ví dụ sử dụng:

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"

EDIT : Sửa tên hàm và kiểu trả về.

Ruby 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"}

Kiểm tra:

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

Con trăn

Tôi thấy điều này một lót khá thỏa mãn.

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 ký tự)

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

Bản demo trực tuyến

Điều này thực hiện các phương pháp vũ phu rõ ràng. IMO bit thú vị nhất là xác định xem tổng một phần của một mảng nhiên liệu delta có giảm xuống dưới 0 hay không:

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

Điều này tiết kiệm 1 char hơn rõ ràng hơn

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

Nếu đầu ra được lập chỉ mục ở mức 0 thay vì 1, cách tiếp cận khác để xoay mảng sẽ thích hợp hơn:

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

Nhưng cách tiếp cận này không dễ dàng được chấp nhận để lập chỉ mục ở 1:

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

hoặc là

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