Các thách thức

Cho một chuỗi (có thể có dòng mới) hoặc mảng hai chiều và số nguyên dương n, xuất vị trí của các nền tảng lần nlượt sau vị trí ban đầu.

U, D, R, L là những nền tảng.

^, v, >, < là những mũi tên thay đổi hướng của các nền tảng.

U, D, R, Ldi chuyển lên, xuống, phải và trái, tương ứng. Khi một mũi tên ở phía trước một nền tảng, nó sẽ thay đổi hướng.

Ảnh hưởng đến nền tảng:

R<

D
^

v
U

>L

>L
 <

(mũi tên trên cùng sẽ ảnh hưởng đến đầu L, nhưng mũi tên dưới sẽ không ảnh hưởng đến đầu L)

Sẽ không ảnh hưởng:

 <
R

>
 L

v
 U

D
 ^

<R

( Rđang đi đúng, vì vậy <sẽ không ảnh hưởng đến R)

Ví dụ: nếu đây là chuỗi:

>R   <

Nền tảng Rsẽ di chuyển đúng cho đến khi nó gần chạm vào mũi tên:

>   R<

Sau đó, nó sẽ thay đổi hướng và bắt đầu đi sang trái:

>  R <

(mặc dù bây giờ nó sẽ rời đi, lá thư sẽ không thay đổi.)

Có một số trường hợp khi nền tảng sẽ không di chuyển, chẳng hạn như

>R<

hoặc là

v
U
^

Ví dụ cuối cùng:

v   >
D    Rv
   ^U
^    <

Sau một lượt,

v   >
    U v
D  ^ R
^    <

Sau một lượt,

v   >
D    Uv
   ^R
^    <

Và một lượt nữa:

v   >
    R v
D  ^ U
^    <

Bạn có thể giả định rằng các nền tảng, sau các nlượt, sẽ không trùng lặp, rằng các nền tảng sẽ không vượt quá giới hạn và nền tảng sẽ không chạm vào một mũi tên chỉ cùng hướng với nền tảng.

Các trường hợp thử nghiệm

Input:
">R   <", 4
Output:
">  R <"

Input:
">R   <", 6
Output:
">R   <"

Input:
">R<", 29
Output:
">R<"

Input:
"v
 U
 ^", 5
Output:
"v
 U
 ^"

Input:
"v

 D
 ^", 1
Output:
"v
 D

 ^"

Input:
"v

 D
 ^", 4
Output:
"v

 D
 ^"

Input:
"v   >
 D    Rv
    ^U
 ^    < ", 2
Output:
"v   >
 D    Uv
    ^R
 ^    <

Input:
">RL<", 3
Output:
">LR<"

Input:
">L  R<", 4
Output:
"> RL <"

Input:
"> RR<
 >L  R <", 6
Ouput:
">RR <
 > RL  <"

Input:
"R   <", 4
Output:
"  R <"

Input:
"R   <", 6
Ouput:
"R   <"

Quy tắc

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng!
• Sơ hở tiêu chuẩn là không được phép.

C #, 1245 byte

(i,n)=>{string q="RlherLHEfquDFQUd",D="><v^",H="Rlhe",E="LrHE",X="Dufq",Y="UdFQ",S="#v<>";Func<string,char,int>I=(v,L)=>v.IndexOf(L);Func<char,int,char>z=(y,m)=>q[I(q,y)+m*4];Func<string,char,bool>_=(s,F)=>s.Contains(F);var g=((i as char[][])??((string)i).Split('\n').Select(f=>f.ToCharArray())).ToList();int w=g[0].Length,h=g.Count,u;g=g.Select((r,o)=>r.Select((t,p)=>'R'==t&&w>p+1&&0<=(u=I(D,r[p+1]))?z(t,u):'L'==t&&0<=p-1&&0<=(u=I(D,r[p-1]))?z(t,-1+u):'D'==t&&h>o+1&&0<=(u=I(D,g[o+1][p]))?z(t,-2+u):'U'==t&&0<=o-1&&0<=(u=I(S,g[o-1][p]))?z(t,-u):t).ToArray()).ToList();for(var j=0;j<n;j++){bool L,R,T,B;g=g.Select((r,o)=>r.Select((t,p)=>_(D,t)?t:(R=0<=p-1)&&_(H,r[p-1])?w>p+1&&0<=(u=I(D,r[p+1]))?z(r[p-1],u):r[p-1]:(L=w>p+1)&&_(E,r[p+1])?0<=p-1&&0<=(u=I(D,r[p-1]))?z(r[p+1],-1+u):r[p+1]:(B=0<=o-1)&&_(X,g[o-1][p])?h>o+1&&0<=(u=I(D,g[o+1][p]))?z(g[o-1][p],-2+u):g[o-1][p]:(T=h>o+1)&&_(Y,g[o+1][p])?0<=o-1&&0<=(u=I(S,g[o-1][p]))?z(g[o+1][p],-u):g[o+1][p]:(L&&_(H,t)&&!_(D,r[p+1]))||(R&&_(E,t)&&!_(D,r[p-1]))||(B&&_(Y,t)&&!_(D,g[o-1][p]))||(T&&_(X,t)&&!_(D,g[o+1][p]))?' ':t).ToArray()).ToList();}return string.Join("\n",g.Select(s=>new string(s))).ToUpper().Replace("H","U").Replace("E","D").Replace("F","R").Replace("Q","L").Replace("V","v");};

Ban đầu có vẻ đơn giản hơn, nhưng sau đó tôi cứ viết thêm mã. : D

LINQ để liệt kê và cập nhật bảng, thay đổi ký tự để cho biết hướng di chuyển của nó. Các nhân vật được hoàn nguyên trở lại trước khi trở lại. Cũng giả sử rằng bảng là hình vuông (vì vậy phải sửa đổi một số trường hợp kiểm tra nhiều dòng để phù hợp với hạn chế này).

Mở rộng:

// Casts to Func<object, int, string> so as to accept both string and char[][] input
(i, n) =>{
    // Shorten constants/functions
    string q = "RlherLHEfquDFQUd", D = "><v^", H = "Rlhe", E = "LrHE", X = "Dufq", Y = "UdFQ",S="#v<>";
    Func<string, char, int> I = (v, L) => v.IndexOf(L);
    Func<char, int, char> z = (y, m) => q[I(q,y) + m * 4]; // Updates the direction of the platform
    Func<string, char, bool> _ = (s, F) => s.Contains(F);

    // Convert either string or char[][] input into common format
    var g = ((i as char[][]) ?? ((string)i).Split('\n').Select(f => f.ToCharArray())).ToList();

    // Get board dimensions
    int w = g[0].Length,h = g.Count,u;

    // Update platforms to reflect the direction they're initially moving
    g = g.Select((r, o) => r.Select((t, p) =>
        'R' == t &&w>p+1&&0<=(u=I(D,r[p+1]))?z(t,u):
        'L' == t &&0<=p-1&&0<=(u= I(D, r[p-1]))?z(t,-1+u):
        'D' == t &&h>o+1&&0<=(u= I(D, g[o+1][p]))?z(t,-2+u):
        'U' == t &&0<=o-1&&0<=(u= I(S,g[o-1][p]))?z(t,-u):t
    ).ToArray()).ToList();

    // Go through each timestep
    for (var j=0;j<n;j++)
    {
        bool L,R,T,B;
        g = g.Select((r, o) => r.Select((t, p) => 
            // Don't change <>^v characters
            _(D,t) ? t :

            // Move platforms going right
            (R=0 <= p - 1) && _(H,r[p-1]) ? w > p+1 && 0<=(u= I(D, r[p+1])) ? z(r[p-1],u) : r[p - 1] :

            // Move platforms going left
            (L=w > p + 1) && _(E,r[p+1]) ? 0 <= p-1 && 0<=(u= I(D, r[p-1])) ? z(r[p+1],-1+u) : r[p + 1] :

            // Move platforms going down
            (B=0 <= o - 1) && _(X,g[o-1][p]) ? h > o+1 && 0<=(u= I(D, g[o+1][p])) ? z(g[o - 1][p],-2+u) : g[o-1][p] :

            // Move platforms going up
            (T=h > o + 1) && _(Y,g[o+1][p]) ? 0<=o-1&&0<=(u= I(S, g[o-1][p]))?z(g[o + 1][p],-u) :g[o+1][p]:

            // Erase platforms that moved
            (L&&_(H,t)&&!_(D,r[p+1]))||
            (R&&_(E,t)&&!_(D,r[p-1]))||
            (B&&_(Y,t)&&!_(D,g[o-1][p]))||
            (T&&_(X,t)&&!_(D,g[o+1][p]))
            ? ' ':

            // Maintain whatever character this was
            t
            ).ToArray()).ToList();
    }

    // Replace direction characters with platform label and join into string return value.
    return string.Join("\n",g.Select(s=>new string(s))).ToUpper().Replace("H", "U").Replace("E", "D").Replace("F", "R").Replace("Q", "L").Replace("V", "v");
};