Bài tập

Cho một mảng các số nguyên không âm a, xác định số lần nhảy phải tối thiểu cần thiết để nhảy "bên ngoài" mảng, bắt đầu từ vị trí 0 hoặc trả về 0 / null nếu không thể làm như vậy.

Một bước nhảy từ chỉ mục iđược xác định là tăng chỉ số mảng nhiều nhất a[i].

Một bên ngoài nhảy là một bước nhảy mà chỉ số phát sinh từ việc nhảy ilà out-of-bounds cho mảng, vì vậy cho chỉ mục 1-based i>length(a), và cho chỉ mục 0 dựa trên i>=length(a).

ví dụ 1

Hãy xem xét Array = [4,0,2,0,2,0]:

Array[0] = 4 -> You can jump 4 field
Array[1] = 0 -> You can jump 0 field
Array[2] = 2 -> You can jump 2 field
Array[3] = 0 -> You can jump 0 field
Array[4] = 2 -> You can jump 2 field
Array[5] = 0 -> You can jump 0 field

Con đường ngắn nhất bằng cách "nhảy" ra khỏi giới hạn có chiều dài 2:

Chúng tôi có thể nhảy từ 0->2->4->outsideđó có chiều dài 3nhưng 0->4->outsidecó chiều dài 2để chúng tôi quay trở lại 2.

Ví dụ 2

Giả sử Array=[0,1,2,3,2,1]:

Array[0] = 0 -> You can jump 0 fields
Array[1] = 1 -> You can jump 1 field
Array[2] = 2 -> You can jump 2 field
Array[3] = 3 -> You can jump 3 field
Array[4] = 2 -> You can jump 2 field
Array[5] = 1 -> You can jump 1 field

Trong trường hợp này, không thể nhảy ra ngoài mảng, vì vậy chúng ta nên trả về giá trị 0 / null hoặc bất kỳ giá trị không xác định nào như ∞.

Ví dụ 3

Giả sử Array=[4]:

Array[0] = 4 -> You can jump 4 field

Chúng ta có thể nhảy trực tiếp từ chỉ số 0 bên ngoài mảng, chỉ với một lần nhảy, vì vậy chúng ta quay trở lại 1.

Biên tập:

Do nhiều câu hỏi về giá trị trả về: Trả về ∞là hoàn toàn hợp lệ, nếu không có cơ hội thoát ra. Bởi vì, nếu có cơ hội, chúng ta có thể định nghĩa con số đó.

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ thắng!

Husk , 9 byte

Γö→▼Mo₀↓ŀ

Trả về Infkhi không có giải pháp tồn tại. Hãy thử trực tuyến!

Giải trình

Giá trị trả về mặc định của Husk có ích ở đây.

Γö→▼Mo₀↓ŀ  Implicit input: a list, say [2,3,1,1]
Γ          Deconstruct into head H = 2 and tail T = [3,1,1]
 ö         and feed them into this function:
        ŀ   Range from 0 to H-1: [0,1]
    Mo      For each element in range,
       ↓    drop that many element from T: [[3,1,1],[1,1]]
      ₀     and call this function recursively on the result: [1,2]
   ▼        Take minimum of the results: 2
  →         and increment: 3

Nếu danh sách đầu vào trống, thì Γkhông thể giải mã nó, do đó, nó trả về giá trị nguyên mặc định là 0. Nếu phần tử đầu tiên là 0, thì kết quả Mo₀↓ŀlà một danh sách trống, trên đó ▼trả về vô cùng.

Haskell , 70 58 byte

f[]=0
f(0:_)=1/0
f(x:s)=minimum[1+f(drop k$x:s)|k<-[1..x]]

Hãy thử trực tuyến!

EDIT: -12 byte nhờ @Esolanging Fruit và OP đã quyết định cho phép vô hạn!

Trả về Infinitykhi không có giải pháp nào làm cho giải pháp đơn giản hơn nhiều. Vì chúng ta chỉ có thể di chuyển về phía trước fchỉ cần nhìn vào phần đầu của danh sách và bỏ 1<=k<=xcác mục từ danh sách và đệ quy. Sau đó, chúng tôi chỉ cần thêm 1 vào mỗi giải pháp các cuộc gọi đệ quy được tìm thấy và lấy mức tối thiểu. Nếu đầu là 0 thì kết quả sẽ là vô cùng (vì chúng ta không thể di chuyển nên không có giải pháp). Vì 1+Infinity==Infinitykết quả này sẽ được mang lại cho người gọi. Nếu danh sách trống có nghĩa là chúng tôi đã rời khỏi mảng để chúng tôi trả lại chi phí là 0.

Python 2 , 124 byte

def f(a):
 i={0};l=len(a)
 for j in range(l):
	for q in{0}|i:
	 if q<l:i|=set(range(q-a[q],q-~a[q]))
	 if max(i)/l:return-~j

Hãy thử trực tuyến!

-11 byte nhờ có ông Xcoder
-12 byte nhờ ông Xcoder và Rod

APL (Dyalog Classic) ngn / apl , 18 byte

EDIT: chuyển sang triển khai APL của riêng tôi vì Dyalog không hỗ trợ vô số và tác giả thách thức không cho phép các số hữu hạn hoạt động như "null"

⊃⊃{⍵,⍨1+⌊/⍺↑⍵}/⎕,0

Hãy thử trực tuyến! dùng thử tại trang demo của ngn / apl

trả về không có giải pháp⌊/⍬ ∞

Haskell , 45 byte

(1%)
0%_=1/0
a%(h:t)=min(1+h%t)$(a-1)%t
_%_=0

Hãy thử trực tuyến!

Đầu ra Infinitykhi không thể. Đối số bên trái phụ trợ để %theo dõi có bao nhiêu không gian chúng ta có thể di chuyển trong bước nhảy hiện tại của chúng ta.

Perl 5 , 56 53 byte

Bao gồm +1choa

perl -aE '1until-@F~~%v?say$n:$n++>map\@v{$_-$F[-$_]..$_},%v,0'  <<< "4 0 2 0 2 0"; echo

Chỉ cần mã:

#!/usr/bin/perl -a
1until-@F~~%v?say$n:$n++>map\@v{$_-$F[-$_]..$_},%v,0

Hãy thử trực tuyến!

Perl 5 , 80 byte

sub f{$_[0]>=@_||1+((sort{$a?$b?$a-$b:-1:1}map f(@_[$_..$#_]),1..$_[0])[0]||-1)}

Hãy thử trực tuyến!

Thạch , 32 byte

ṛ/ṆȧJ’Ṛ
Rḟ"ÇƤZ$$Tị$Œp+\€Ṁ<Li0ȧ@Ḣ

Hãy thử trực tuyến!

Cái này quá dài ...

Thạch , 19 18 byte

<LḢ
ḊßÐƤṁḢḟ0‘Ṃµ1Ç?

Hãy thử trực tuyến!

Giải trình

<LḢ  Helper link. Input: array
<    Less than
 L   Length
  Ḣ  Head - Returns 0 if its possible to jump out, else 1

ḊßÐƤṁḢḟ0‘Ṃµ1Ç?  Main link. Input: array
            Ç   Call helper link
             ?  If 0
           1      Return 1
                Else
          µ       Monadic chain
Ḋ                   Dequeue
 ßÐƤ                Recurse on each suffix
     Ḣ              Head of input
    ṁ               Mold, take only that many values
      ḟ0            Filter 0
        ‘           Increment
         Ṃ          Minimum

JavaScript ES6 , 118 byte

(x,g=[[0,0]])=>{while(g.length){if((s=(t=g.shift())[0])>=x.length)return t[1];for(i=0;i++<x[s];)g.push([s+i,t[1]+1])}}

Hãy thử trực tuyến!

Thực hiện tìm kiếm đầu tiên của mảng để tìm đường đi ngắn nhất.

C (gcc) , 80 byte

f(A,l,M,j,r)int*A;{M=~0;for(j=0;l>0&&j++<*A;)if(M<1|M>(r=f(A+j,l-j)))M=r;A=-~M;}

Hãy thử trực tuyến!

Julia 0,6 , 79 byte

Trả về số lần nhảy hoặc Infnếu bạn không thể thoát. Xem xét đệ quy phần tử đầu tiên và trả về Infhoặc 1tùy thuộc vào việc bạn có thể thoát hay không, nếu không, hãy thêm 1vào giải pháp ngắn nhất cho các mảng bị cắt ngắn đại diện cho mỗi bước nhảy hợp lệ. Luồng điều khiển được thực hiện với hai câu lệnh ternary như thế nào test1 ? ontrue1 : test2 ? ontrue2 : onfalse2.

f(a,n=endof(a))=a[1]<1?Inf:a[1]>=n?1:1+minimum(f(a[z:min(z+a[1],n)]) for z=2:n)

Hãy thử trực tuyến!

C # (.NET Core) , 97 byte

f=l=>{for(int c=l.Count,s=0,j=l[0];j>0;s=f(l.GetRange(j,c-j--)))if(s>0|j>=c)return s+1;return 0;}

Hãy thử trực tuyến!

Trả về 0 nếu không tìm thấy đường dẫn.

Giải trình

f = 
    l =>                                      //The list of integers
    {
        for (
            int c = l.Count,                  //The length of the list
                s = 0,                        //Helper to keep track of the steps of the recursion
                j = l[0];                     //The length of the jump, initialize with the first element of the list
                j > 0;                        //Loop while the jump length is not 0
                s = f(l.GetRange(j, c - j--)) //Recursive call of the function with a sub-list stating at the current jump length. 
                                              //Then decrement the jumplength. 
                                              //Returns the number of steps needed to jump out of the sup-list or 0 if no path was found. 
                                              //This is only executed after the first run of the loop body.
            )
        {
            if (j >= c |                      //Check if the current jump lengt gets you out of the list. 
                                              //If true return 1 (s is currently 0). OR
                s > 0 )                       //If the recursive call found a solution (s not 0) 
                                              //return the number of steps from the recursive call + 1
                return s + 1;
        }
        return 0;                             //If the jump length was 0 return 0 
                                              //to indicate that no path was found from the current sub-list.
    }

Python 2 , 83 73 72 byte

^{-10 cảm ơn @ user202729
-1 nhờ @JonathanFrech}

lambda a:a and(a[0]and-~min(f(a[k+1:])for k in range(a[0]))or 1e999)or 0

Hãy thử trực tuyến! Trả về vô hạn cho một giá trị null.