RoboZZle 통역사

10

당신의 임무는 RoboZZle 통역사를 작성하는 것입니다. 게임에 익숙하지 않은 경우 robozzle.com 의 비디오를 보거나 아래 설명을 읽으십시오.

로봇은 빨간색, 녹색, 파란색 또는 검은 색의 사각형 사각형 격자에 있습니다. 검은 색 사각형에 액세스 할 수 없습니다. 다른 사람들은 접근 할 수 있고 그들 중 일부는 별을 포함합니다. 목표는 검은 사각형을 밟거나지도에서 떨어지지 않고 모든 별을 모으는 것입니다. 로봇은 하나의 사각형을 차지하고 왼쪽, 오른쪽, 위 또는 아래로 특정 방향을 향합니다. 서브 루틴 F1, F2, ..., F5로 그룹화 된 어셈블리와 같은 명령어를 따릅니다. 명령은 한 쌍의 술어 ( "없음", "적색 인 경우", "녹색 인 경우", "파란색 인 경우")와 조치 ( "앞으로 이동", "왼쪽으로 돌림", "오른쪽으로 돌리기", "현재 사각 빨간색 페인트", "녹색 페인트", "파란색 페인트", "아무것도하지 않음", "call F1", ..., "call F5"). 서브 루틴 호출은 스택을 사용하며 재귀적일 수 있습니다. 기존 프로그래밍과 마찬가지로 서브 루틴의 마지막 명령이 완료된 후 서브 루틴이 호출 된 지점부터 실행이 계속됩니다. 실행은 F1의 첫 번째 명령에서 시작하여 로봇이 별이있는 모든 사각형을 방문하거나 로봇이 검은 사각형 또는지도 외부에 닿을 때까지 또는 1000 개의 명령이 실행될 때 (조건 자 실패 및 "아무것도하지 않음"동작)까지 계속됩니다. 계산하지 않거나) 실행할 명령이 더 이상 없습니다 (스택 언더 플로).

입력 :

  • a-지도를 인코딩하는 12x16 문자 매트릭스 (일반적으로 언어로 표시되는 문자열 배열)- '#'액세스 할 수없는 (검은 색) 사각형, '*'별이있는 사각형, '.'나머지

  • c-액세스 가능한 사각형의 색상을 설명하는 12x16 문자 매트릭스- 'R'(빨간색), 'G'(녹색) 또는 'B'(파란색). 액세스 할 수없는 사각형은 3 개의 임의의 문자로 표시됩니다.

  • y그리고 x-로봇의 0 기반 행과 열; a[y][x]~로 보장된다'.'

  • d- 방향이 로봇이 직면 : 0 1 2 3권리, 아래로, 즉쪽으로, 위, 왼쪽 (y,x+1), (y+1,x), (y,x-1),(y-1,x)

  • f-단일 문자열, 연결된 F1 ... F5 구현. 각 구현은 술어 조치 쌍 (서브 루틴 당 최대 10 쌍)의 시퀀스 (비어있을 수 있음) '|'입니다.

    • 술어 : '_'없음, 'r'빨강, 'g'초록, 'b'파랑

    • 행동 : 'F'앞으로 이동, 'L'좌회전, 'R'우회전, 'r'빨간색 'g'페인트, 녹색 'b'페인트, 파란색 페인트, '1'F1 호출, ..., '5'F5 호출, '_'아무것도하지 마십시오

위와 같이 입력 이름을 지정할 필요는 없지만 해당 값은 지정해야합니다.

출력 : 1(또는 true) 로봇이 규칙에 따라 모든 별을 수집하는 경우 0( false) 그렇지 않은 경우

예 :

a=["################","################","##*....*...*#.##","##.####.#####.##","##.####.#####.##","##.####*...*#.##","##.########.####","##*........*#.##","################","################","################","################"]
c=["RRRRRRRRRRRRRRRR","RRRRRRRRRRRRRRRR","RRRBBBBRGGGGRRRR","RRBRRRRGRRRRRRRR","RRBRRRRGRRRRRRRR","RRBRRRRRGGGBRRRR","RRBRRRRRRRRGRRRR","RRRBBBBGGGGBRBRR","RRRRRRRRRRRRRRRR","RRRRRRRRRRRRRRRR","RRRRRRRRRRRRRRRR","RRRRRRRRRRRRRRRR"]
y=2; x=6; d=2

// and then depending on "f":
f="_FrLg2_1|_FbLrR_2||||" // result:1
f="_FrRg2_1|_FbLrR_2||||" // result:0 (stepped on a black square)
f="_FrLrL_1|_FbLrR_2||||" // result:0 (1000-step limit exceeded)
f="_FrLg2__|________||||" // result:0 (stack underflow)

"페인트"명령과 관련된 또 다른 예 :

a=["#***************","#*###*###*###*##","#*###*###*###*##","***#***#***#***#","***#***#***#***#","*###*###*###*###","***#***#***#***#","***#***#***#***#","***#***#***#***#","*###*###*###*###","*.*#***#***#***#","***#***#***#***#"]
c=["RGGGGGGGGGGGGGGG","RBRRRGRRRGRRRGRR","RBRRRGRRRGRRRGRR","RBRRGGGRGGGRGGGR","BRRRGGGRGGGRGGGR","BRRRGRRRGRRRGRRR","BRRRGGGRGGGRGGGR","RBRRGGGRGGGRGGGR","BRRRGGGRGGGRGGGR","BRRRGRRRGRRRGRRR","BGRRGGGRGGGRGGGR","RBRRGGGRGGGRGGGR"]
y=10; x=1; d=0
f="_2_R_R_1|_FgRgFgFg3rRr4b2_Fgb|_F_F_R|_2_L_r||"
// result:1

자체 테스트를 생성하려면 robozzle.com의 목록에서 퍼즐로 이동하여 문제를 해결하거나 시도하지 마십시오. 브라우저에서 F12를 누르고 JS 콘솔에 입력하십시오.

r=robozzle;s=JSON.stringify;with(r.level)console.log('a='+s(Items)+'\nc='+s(Colors)+'\ny='+RobotRow+'\nx='+RobotCol+'\nd='+RobotDir+'\nf='+s(r.encodeSolution()))

언어의 결과를 다시 포맷하십시오.

최단 승리. 허점이 없습니다.

code-golf  grid  interpreter 
— ngn
소스
1
제공된 문자 대신 고유 한 문자를 사용하여 데이터를 나타낼 수 있습니까?
— HyperNeutrino
1
"Loop it"문제에 대한 APL 답변의 경우 복잡한 크기를 줄임으로써 마지막 각도 값을 정렬 할 수 있습니다.
— user202729
1
@ user202729 어, 나는 그 도전 에 대한 의견을 기대하지 않았다 :) 당신의 아이디어는 고맙습니다! 캐릭터 수를 너무 수치스럽게 만들지 않고 구현하려고합니다.
— ngn
1
문자 행렬을 위치와 문자 쌍의 목록으로 사용할 수 있습니까?
— 0 '
1
@ 0 '내가 여기에서 따랐던 원칙 (HyperNeutrino의 의견도 참조)은 robozzle.com에서 실제로 사용되는 입력 형식에 최대한 가깝게 유지하는 것이므로 쌍 목록이되어서는 안됩니다.
— ngn

답변:

5

프롤로그 (SWI) 574 바이트

Z*A:-findall(X^Y-D,(nth0(Y,Z,O),nth0(X,O,C),plus(32,C,D)),L),list_to_assoc(L,A).
N^C^G^[P,I|R]^F^X^Y^D:-map_assoc(\=(74),G);N<1e3,get_assoc(X^Y,G,J),J>67,put_assoc(X^Y,G,78,H),T=N+1,((I\=95,(P=95;get_assoc(X^Y,C,P)))->(between(49,53,I),plus(48,M,I),nth1(M,F,Q),append(Q,R,S),T^C^H^S^F^X^Y^D;member(I,`RL`),E is(D-I//3)mod 4,T^C^H^R^F^X^Y^E;I=70,(D=0,U is X+1;D=1,V is Y+1;D=2,U is X-1;D=3,V is Y-1),(U=X;V=Y),T^C^H^R^F^U^V^D;I>97,put_assoc(X^Y,C,I,W),T^W^H^R^F^X^Y^D);N^C^H^R^F^X^Y^D).
A+C+F+L:-A*G,C*B,split_string(F,"|","",P),maplist(string_codes,P,[M|N]),0^B^G^M^[M|N]^L.

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

이것은 모든 별들이 성공적으로 수집되고 그렇지 않으면 실패하면 호출 될 때 성공하는 술어를 정의합니다. 술어는 다음과 같은 인수를 취합니다 a+c+f+x^y^d.. a과 c동시에, 역 따옴표 인용 문자열의 목록이어야 f이중 인용 문자열이어야합니다.

설명

이 프로그램은 세 가지 술어를 포함, */2, ^/2,와 +/2. */2첫 줄에 정의 된 조건 입력 처리의 일부분에 대응한다. ^/2술어는 재귀 적 로봇 이동 단계별로 어떻게 계산하고 로봇이 법적으로 모든 별을 수집하고, 그렇지 않으면 실패 할 경우 성공합니다. +/2술어는 프로그램의 기본 조건이며, 대한 입력을 준비 ^/2로부터 약간의 도움으로 술어 */2술어. 이 술어 각각은 기술적으로 두 개의 인수 만 취하지 만 연산자와 패턴 일치를 사용하면 더 많은 인수가있는 것처럼 동작 할 수 있습니다 (여기서이 현상에 대해 자세히 설명 합니다 ).

*/2

Z*A:-findall(X^Y-D,(nth0(Y,Z,O),nth0(X,O,C),plus(32,C,D)),L),list_to_assoc(L,A).

이 술어는 두 가지 주장을 취합니다. 첫 번째는 문자 코드 목록의 목록입니다 (이는 Prolog가 백틱 인용 문자열을 구문 분석하는 방법입니다). 두 번째는 12x16 맵 (으로 표시 X^Y)의 포인트에서 32까지의 문자 맵 과 해당 포인트에 저장된 문자 코드 목록의 연관 코드입니다. 32는 각 문자 코드에 추가되어 색상 매트릭스의 경우 대문자 문자를 소문자 문자로 바꿉니다.

이를 수행하는 방법은을 사용하여 점 쌍과 해당 지점의 문자 코드 목록을 생성하는 것 findall/3입니다. 그런 다음 list_to_assoc/2점에서 해당 지점의 문자 코드까지 해당 연관 맵을 작성하는 데 사용 됩니다.

findall/3술어는 기본적 으로 "템플릿"을 첫 번째 인수로, 목표를 두 번째 인수로, 목록을 세 번째 인수로 취합니다. 술어는 목표가 성공하게하는 가능한 모든 템플리트 값으로 목록을 채 웁니다. 연산자 우선 순위에 전달되는 템플릿으로 인해 findall/3에 */2로 분석된다 (X^Y)-D. -템플릿 점의 위치 (대표되도록 오퍼레이터 프롤로그 두 값의 쌍을 나타내고, X^Y(32)를 더한 지점의 문자 코드와 쌍을 () D). (가) 있습니다 ^지점을 나타내는에서 사용이에 연결된 방식에 ^/2술어.

findall/3술어에 전달되는 목표를 고려해 봅시다 .

nth0(Y,Z,O),nth0(X,O,C),plus(32,C,D) % Note that the O (oh) is not a 0 (zero)

목표에는 목표를 달성하기 위해 각각 성공해야하는 세 가지 술어가 포함됩니다. nth0/3두 번 사용하는 술어 목록의 특정 인덱스에서 값을 가져 오는 데 사용합니다 (이 0이름에 인덱싱 제로 표시). 첫 번째 호출 Y은 문자 행렬 의 세 번째 행을 O저장하고 두 번째 호출은 X해당 행 의 세 번째 문자를에 저장합니다 C. plus/3첫 번째 두 인수가 세 번째 인수와 합치면 최종 술어 가 성공합니다. 이것은 쌍의 문자 코드가 문자 행렬의 문자 코드보다 32 더 크게 만드는 데 사용되며 위에서 언급 한 것처럼 모든 대문자를 소문자로 바꿉니다.

마지막으로 연관 맵이 작성된 목록에 목표가 성공하도록하는 findall/3모든 X^Y-D조합을 저장합니다 L.

더 곧 올 ...

— 0 '
소스
4

자바 스크립트 (ES6), 298 276 264 바이트

@ngn 덕분에 8 바이트 절약

입력을로 (a,c,x,y,d,f), 위치 a및 c문자 배열 로 취 합니다. 반환 0또는 1.

(a,c,x,y,d,f,k=1e3)=>(g=(F,p=0,s=f.split`|`[F],r=a[y])=>!k|!r|x&16||r[x]<'$'?2:/\*/.test(a)?(r[x]=o=0,(I=s[p+1],P=s[p])&&(P<'b'|P==c[y][x].toLowerCase()&&I!='_'&&k--?+I?o=g(I-1):I=='L'?d--:I=='R'?d++:I<'b'?y+=(d&=3,x-=~-d%2,2-d)%2:c[y][x]=I:0,o||g(F,p+2))):1)(0)&1

테스트 사례

코드 스 니펫 표시

댓글

(                                           // main function taking:
  a, c, x, y, d, f,                         //   - input variables
  k = 1e3                                   //   - k = instruction counter
) => (                                      //
  g = (                                     // g = recursive execution function, taking:
    F,                                      //   - F = subroutine id
    p = 0,                                  //   - p = instruction pointer
    s = f.split`|`[F],                      //   - s = instruction string
    r = a[y]                                //   - r = current row in a[]
  ) =>                                      //
    !k |                                    // if we've executed 1000 instructions
    !r | x & 16 ||                          // or we've felt out of the map
    r[x] < '$' ?                            // or we've reached a black square:
      2                                     //   exit with error code 2
    :                                       // else:
      /\*/.test(a) ? (                      //   if there are still some stars:
        r[x] = o = 0,                       //     mark the current cell as visited
        (I = s[p + 1], P = s[p]) &&         //     I = instruction, P = predicate
        (                                   //     if P is defined:
          P < 'b' |                         //       if the predicate is '_'
          P == c[y][x].toLowerCase()        //       or it matches the color of the cell
          && I != '_'                       //       and the instruction is not '_',
          && k-- ?                          //       then decrement k and:
            +I ?                            //         if I is '1' ... '5':
              o = g(I - 1)                  //           process call to subroutine
            :                               //         else:
              I == 'L' ?                    //           if I is 'L':
                d--                         //             turn left
              :                             //           else:
                I == 'R' ?                  //             if I is 'R':
                  d++                       //               turn right
                :                           //             else:
                  I < 'b' ? (               //               if I is not a color:
                    y += (                  //                 I must be 'F',
                      d &= 3,               //                 so make the bot advance
                      x -= ~-d % 2,         //                 by updating x
                      2 - d                 //                 and y
                    ) % 2                   //
                  ) :                       //               else:
                    c[y][x] = I             //                 paint the current cell
          :                                 //       else:
            0,                              //         do nothing
          o ||                              //       provided that o is equal to 0,
          g(F, p + 2)                       //       go on with the next instruction
        )                                   //     end of instruction execution
      ) :                                   //   else:
        1                                   //     success: return 1
  )(0) & 1                                  // initial call to the subroutine F1
— 아르나 울드
소스
x+='2101'[d&3]-1,y+='1210'[d&3]-1->d&=3,x+=(1-d)%2,y+=(2-d)%2
— ngn
1
x난 당신이 바꿀 수 있다고 생각 있도록 한 가장에 의해 변경 x&~15으로x&16
— NGN
1

APL (Dyalog 기본) , 236 (233) 바이트

Outgolfer Erik 덕분에 -3

이제 보너스를 주었으므로 샘플 솔루션을 내 도전에 게시하고 있습니다. 여기에는 개선의 여지가 있습니다-더 자유롭게 복사하고 골프를 즐기십시오.

a c r d f←⎕⋄c←819⌶c⋄F←0,('|'=¯1⌽f)/⍳≢f⋄t←n←0
{~(⊂r)∊⍳⍴a:0⋄'#'=r⌷a:0⋄p q←2↑f↓⍨⊃⌽t⋄(_←p≡'|')∧×≢t:0⋄_:∇t↓←¯1⋄(⊃⌽t)+←2⋄~p∊'_',r⌷c:∇0⋄n+←1⋄n>999:0⋄(r⌷a)←'.'⋄~'*'∊a:1⋄r+←(q≡'F')×11 9○0j1*d⋄d+←4|'.R.L'⍳q⋄q∊'rgb':∇(r⌷c)←q⋄q∊⎕d:∇t,←F[⍎q]⋄∇0}0

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

위와 동일하며 주석으로 확장되었습니다.

⎕io←0                   ⍝ 0-based indices (not counted in the score)
a c r d f←⎕             ⍝ decompose eval'ed input (⎕) into variables
c←819⌶c                 ⍝ make c lowercase
F←0,('|'=¯1⌽f)/⍳≢f      ⍝ split f at the '|'-s
t←n←0                   ⍝ t:stack, n:step counter
{                       ⍝ lambda
  ~(⊂r)∊⍳⍴a:0           ⍝ if the robot is off the map, return 0
  '#'=r⌷a:0             ⍝ if the robot is on a wall, return 0
  p q←2↑f↓⍨⊃⌽t          ⍝ current instruction - p:predicate, q:action
  (_←p≡'|')∧1≥≢t:0      ⍝ if at end of func and stack is empty, return 0
  _:∇t↓←¯1              ⍝ if at end of func, pop from stack and recurse
  (⊃⌽t)+←2              ⍝ increment program counter (top of stack)
  ~p∊'_',r⌷c:∇0         ⍝ if predicate doesn't match cell colour, recurse
  n+←1⋄n>999:0          ⍝ if too meany steps, return 0
  (r⌷a)←'.'             ⍝ consume star
  ~'*'∊a:1              ⍝ if no more stars left, return 1
  r+←(q≡'F')×11 9○0j1*d ⍝ if action is F, move forward
  d+←4|'.R.L'⍳q         ⍝ if action is L or R, turn left or right
  q∊'rgb':∇(r⌷c)←q      ⍝ if action is paint (r,g,b), do it
  q∊⎕d:∇t,←F[⍎q]        ⍝ if action is F1...F5, push on stack and recurse
  ∇0                    ⍝ action is nop (_), recurse
}0                      ⍝ call the lambda (argument will be ignored)
— ngn
소스
— Outgolfer 에릭
@EriktheOutgolfer 변경 적용, 감사
— ngn
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.