この課題の目標は、特定のコースを完了するために必要な最小限のストライクを返すプログラムまたは関数を作成することです。

入力

• コースのレイアウトは、適切な方法で渡すことができ、お好みの形式にできます。（コンソールから読み取られ、入力パラメーターとして渡され、ファイルまたはその他の複数行ストリング、ストリング配列、2次元文字/バイト配列から読み取られます）。
• ボールとホールの開始位置も入力として渡すことができます。入力から解析する必要はありません。テストケースでは、実際の位置について混乱がないことを確認するために、コースに含まれています。
• 入力文字を別の文字（印刷可能なASCII文字など）として認識できる限り、他の文字に再マッピングできます。

出力

• プログラムは、賢明な形式（結果を説明する文字列、整数、浮動小数点数または俳句）で入力として渡されたコースについて、可能な限り低いスコア（ホールに到達するために必要なストライキの最小量）を返す必要があります
• コースを打つことが不可能な場合は、リターンします-1（または、ビート可能なコースでは返されない、選択した他の偽の値）。

例：

この例では、位置は0ベース、X / Y、左から右、トップダウンで表記されていますが、結果は完全にフォーマットに依存しないため、任意のフォーマットを使用できます。

入力：

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

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

出力：

8

ルールとフィールド

コースは次のフィールドで構成できます。

• '@' ボール -コースの開始
• 'o' 穴 -コースの目標
• '#' 壁 -ボールが壁に当たると停止します
• '~' 水 -避ける必要があります
• '.' 砂 -ボールはすぐに砂の上で止まります
• ' ' アイス -ボールは何かに当たるまでスライドし続けます

ゲームの基本的なルールと制限：

• ボールは斜めに動くことができず、左、右、上下のみです。
• ボールは水の前で止まらず、壁の前、砂の上、穴の中だけで止まります。
  • 水へのショットは無効/不可能です
  • ボールは穴にとどまり、氷の上で飛ぶように飛び越えない
• コースは常に長方形です。
• コースは常に水または壁に囲まれています（境界チェックは不要です）。
• 常に正確に1つのボールと1つの穴があります。
• すべてのコースが勝つわけではありません。
• 同じ（最低の）スコアになる複数のパスが存在する場合があります。

抜け穴と勝利条件

• 標準的な抜け穴は禁止されています
• プログラムは終了する必要があります
• 追加のルールを作成することはできません（ボールを強く叩くと、水を飛び越えたり、壁から跳ね返ったり、砂地を飛び越えたり、角を曲がったりします）。
• これはcode-golfであるため、文字数が最も少ないソリューションが優先されます。
• ソリューションは、提供されたすべてのテストケースを処理できる必要があります。使用言語の制限によりこれが不可能な場合は、回答でそれを指定してください。

テストケース

コース＃1（2回のストライキ）

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

コース＃2（不可能）

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

コース＃3（3回のストライキ）

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

コース＃4（2回のストライキ）

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

コース＃5（不可能）

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

その他のテストケース：

https://pastebin.com/Azdyym00

JavaScript（ES6）、174バイト

で入力を受け取りカールカリー化構文を([x, y])(a)ここで、X及びYは、開始位置の0インデックス付き座標であり、[]を用いて、整数の行列である0=氷、1=壁、2=砂、3=ホール及び4=水

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

Python 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

オンラインでお試しください！

-41バイト、ovsのおかげで
-1バイト、Jonathan Frechのおかげで

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;
    }
}

オンラインで試す