이 도전의 목표 는 주어진 과정을 완료하는 데 필요한 최소의 파업을 반환 하는 프로그램이나 기능 을 작성 하는 것 입니다.

입력

• 코스의 레이아웃은 원하는 방식과 형식으로 전달할 수 있습니다. (콘솔에서 읽기, 입력 매개 변수로 전달, 파일 또는 기타 여러 줄 문자열, 문자열 배열, 2 차원 문자 / 바이트 배열에서 읽음)
• 공의 시작 위치와 구멍도 입력으로 전달할 수 있으며 입력에서 파싱 할 필요가 없습니다. 테스트 사례에서는 실제 위치와 혼동되지 않도록 코스에 포함되어 있습니다.
• 입력 문자가 여전히 고유 문자 (예 : 인쇄 가능한 ASCII 문자)로 인식되는 한 입력 문자를 다른 것으로 다시 맵핑 할 수 있습니다.

산출

• 프로그램은 현명한 형식 (결과를 설명하는 문자열, 정수, 부동 또는 하이쿠)으로 입력으로 전달 된 코스에 대해 최저 점수 (홀에 도달하는 데 필요한 최소 스트라이크)를 반환해야합니다.
• 강좌를 이길 수없는 경우 귀국 -1(또는 선택 가능한 다른 강박 한 가치는 이길 수없는 강좌에 대해서는 반환되지 않음).

예:

이 예제에서 위치는 0 기반, X / Y, 왼쪽에서 오른쪽으로, 위에서 아래로 표기되지만 결과는 형식에 독립적이므로 원하는 형식을 사용할 수 있습니다.

입력:

###########
#     ....# 
#      ...# 
#  ~    . # 
# ~~~   . # 
# ~~~~    # 
# ~~~~    # 
# ~~~~  o # 
# ~~~~    # 
#@~~~~    # 
###########

Ball (Start-Position): 1/9
Hole (End-Position):   8/7

산출:

8

규칙과 필드

이 과정은 다음과 같은 필드로 구성 될 수 있습니다.

• '@' 공 -코스 시작
• 'o' 구멍 -코스의 목표
• '#' 벽 -벽에 닿으면 공이 멈 춥니 다
• '~' 물 -피해야합니다
• '.' 모래 -공이 모래 위에서 즉시 멈 춥니 다
• ' ' 얼음 -공이 무언가에 닿을 때까지 계속 미끄러집니다.

게임의 기본 규칙 및 제한 사항 :

• 공은 대각선으로, 왼쪽, 오른쪽, 위아래로 움직일 수 없습니다.
• 공은 물 앞에서, 벽 앞에서, 모래 위에서 그리고 구멍에서 멈추지 않습니다.
  • 물 속으로의 샷이 유효하지 않거나 불가능합니다
  • 공은 얼음 위에있는 것처럼 건너 뛰지 않고 구멍에 남아있게됩니다.
• 코스는 항상 직사각형입니다.
• 이 코스는 항상 물이나 벽으로 둘러싸여 있습니다 (경계 확인 필요 없음).
• 항상 정확히 하나의 공과 하나의 구멍이 있습니다.
• 모든 코스가 이길 수있는 것은 아닙니다.
• 동일한 (가장 낮은) 점수를 얻는 여러 경로가있을 수 있습니다.

허점과 승리 조건

• 표준 허점 은 금지되어 있습니다
• 프로그램은 종료되어야합니다
• 추가 규칙을 구성 할 수 없습니다 (공을 너무 세게 치면 물 위로 건너 뛰거나 벽에서 튀어 나오거나 모래밭 위로 뛰어 오름, 모서리 주위의 곡선 등)
• 이것은 code-golf 이므로 문자 수가 가장 적은 솔루션이 승리합니다.
• 솔루션은 제공된 모든 테스트 사례를 처리 할 수 ​​있어야합니다. 사용 된 언어의 제한으로 인해 이것이 불가능한 경우 답변에이를 지정하십시오.

테스트 사례

코스 # 1 (2 파업)

####
# @#
#o~#
####

코스 # 2 (불가능)

#####
#@  #
# o #
#   #
#####

코스 # 3 (3 회)

~~~
~@~
~.~
~ ~
~ ~
~ ~
~ ~
~.~
~o~
~~~

코스 # 4 (2 파업)

#########
#~~~~~~~#
#~~~@~~~#
##  .  ##
#~ ~ ~ ~#
#~. o .~#
#~~~ ~~~#
#~~~~~~~#
#########

코스 # 5 (불가능)

~~~~~~~
~...  ~
~.@.~.~
~...  ~
~ ~ ~.~
~ . .o~
~~~~~~~

더 많은 테스트 사례 :

https://pastebin.com/Azdyym00

자바 스크립트 (ES6), 174 바이트

curling currying syntax 에서 입력을 받습니다 ([x, y])(a). 여기서 x 와 y 는 시작 위치의 0- 인덱스 좌표이고 a [] 는 0= ice, 1= wall, 2= sand, 3= hole 및 4= water를 갖는 정수의 행렬입니다.

0솔루션이없는 경우 반환 합니다.

p=>a=>(r=F=([x,y],n,R=a[y],c=R[x])=>R[c&(R[x]=4)|n>=r||[-1,0,1,2].map(d=>(g=_=>(k=a[v=Y,Y+=d%2][h=X,X+=~-d%2])||g())(X=x,Y=y)>3?0:k>2?r=-~n:F(k>1?[X,Y]:[h,v],-~n)),x]=c)(p)|r

온라인으로 사용해보십시오!

댓글

p => a => (                       // given the starting position p[] and the matrix a[]
  r =                             // r = best result, initialized to a non-numeric value
  F = (                           // F = recursive function taking:
    [x, y],                       //   (x, y) = current position
    n,                            //   n = number of shots, initially undefined
    R = a[y],                     //   R = current row in the matrix
    c = R[x]                      //   c = value of the current cell
  ) =>                            //
    R[                            // this will update R[x] once the inner code is executed
      c & (R[x] = 4) |            //   set the current cell to 4 (water); abort if it was
      n >= r ||                   //   already set to 4 or n is greater than or equal to r
      [-1, 0, 1, 2].map(d =>      //   otherwise, for each direction d:
        (g = _ => (               //     g = recursive function performing the shot by
          k = a[                  //         saving a backup (h, v) of (X, Y)
            v = Y, Y += d % 2][   //         and updating (X, Y) until we reach a cell
            h = X, X += ~-d % 2]) //         whose value k is not 0 (ice)
          || g()                  //   
        )(X = x, Y = y)           //     initial call to g() with (X, Y) = (x, y)
        > 3 ?                     //     if k = 4 (water -> fail):
          0                       //       abort immediately
        :                         //     else:
          k > 2 ?                 //       if k = 3 (hole -> success):
            r = -~n               //         set r to n + 1
          :                       //       else:
            F(                    //         do a recursive call to F():
              k > 1 ?             //           if k = 2 (sand):
                [X, Y]            //             start the next shots from the last cell
              :                   //           else (wall):
                [h, v],           //             start from the last ice cell
              -~n                 //           increment the number of shots
            )                     //         end of recursive call
      ), x                        //   end of map(); x = actual index used to access R[]
    ] = c                         // restore the value of the current cell to c
)(p) | r                          // initial call to F() at the starting position; return r

파이썬 3 , 273 바이트

def p(g,c,d,k=0):
	while 1>k:c+=d;k=g.get(c,9)
	return-(k==2)or c-d*(k==3)
def f(g):
	c={q for q in g if g.get(q,9)>4};I=0;s=[c]
	while all(g.get(q,9)-4for q in c):
		c={k for k in{p(g,k,1j**q)for k in c for q in range(4)}if-~k}
		if c in s:return-1
		s+=[c];I+=1
	return I

온라인으로 사용해보십시오!

ovs 덕분에 -41 바이트-Jonathan
Frech 덕분에 -1 바이트

C #, 461 418 바이트

이것은이 도전을 (희망적으로) 부활시키기위한 비 경쟁적 참조 구현입니다.

케빈 크루이 센 골프

int P(string[]C){int w=C[0].Length,i=0,l=c.Length;var c=string.Join("",C);var h=new int[l];for(var n=new List<int>();i<l;n.Add(i++))h[i]=c[i]!='@'?int.MaxValue:0;for(i=1;;i++){var t=n;n=new List<int>();foreach(int x in t){foreach(int d in new[]{-1,1,-w,w}){for(int j=x+d;c[j]==' ';j+=d);if(c[j]=='#'&h[j-d]>s){h[j-d]=s;n.Add(j-d);}if(c[j]=='.'&h[j]>s){h[j]=s;n.Add(j);}if(c[j]=='o')return s;}}if(n.Count<1)return -1;}}

언 골프

int IceGolf(string[] course)
{
    // Width of the course
    int w = course[0].Length;

    // Course as single string
    var c = string.Join("", course);

    // Array of hits per field
    var hits = new int[c.Length];

    // Fields to continue from
    var nextRound = new List<int>();

    // Initialize hits
    for (int i = 0; i < hits.Length; i++)
    {
        if (c[i] != '@')
            // All fields start with a high value
            hits[i] = Int32.MaxValue;
        else
        {
            // Puck field starts with 0
            hits[i] = 0;
            nextRound.Add(i);
        }
    }

    for (int s = 1; ; s++)
    {
        // clear the fields that will be used in the next iteration
        var thisRound = nextRound;
        nextRound = new List<int>();

        foreach (int i in thisRound)
        {
            // test all 4 directions
            foreach (int d in new[] { -1, 1, -w, w })
            {
                int j = i+d;

                // ICE - slide along
                while (c[j] == ' ')
                    j += d;

                // WALL - stop on previous field
                if (c[j] == '#' && hits[j-d] > s)
                {
                    hits[j-d] = s;
                    nextRound.Add(j-d);
                }

                // SAND - stop
                if (c[j] == '.' && hits[j] > s)
                {
                    hits[j] = s;
                    nextRound.Add(j);
                }

                // HOLE return strikes
                if (c[j] == 'o')
                    return s;
            }
        }

        // No possible path found
        if (nextRound.Count == 0)
            return -1;
    }
}

온라인으로 사용해보십시오