Code-Golf Ascii Art Mini-Golf

13

Introducción

¡Juguemos un poco de minigolf! La pelota de golf está representada por a .y el hoyo por a O. Desea obtener un hoyo en uno en cada hoyo, pero no es bueno para poner. De hecho, te niegas a intentar poner en diagonal. Solo arriba, abajo y a cada lado.

Planeas hacer trampa colocando parachoques adicionales \y /así puedes poner la pelota con un solo tiro. La pelota rebota en los parachoques en ángulo recto, como se muestra en esta imagen.

Golf

¡Recuerda llamar a tu tiro! Dinos en qué dirección estás yendo.

Agujeros

1: El primer hoyo es fácil, ¡un tiro recto! No se necesitan parachoques aquí.

Entrada:

.         O

Salida:

right
.         O

2: Otro básico, un turno corto. La pelota es golpeada desde el parachoques hacia el hoyo.

Entrada:

     .
O

Salida:

left
/    .
O

o

down
     .
O    /

3: ¡ Algunos agujeros ya tienen parachoques!

Entrada:

.   \O

Salida:

right
.   \O
    \/

o

right
   / \
.  /\O

4: ¡ Algunos agujeros son demasiado complejos!

Entrada:

    /  \  \    /
   /  . \  \  /
  /  /\/   /\ \  /
 /  /     /  \ \/
/  /   /\ \  /  \  /
\  \  /  \ \/    \/ 
      \  /          /
  /\   \//\ \      /
 /  \   /  \ \     \/
 \  /\  \  /  \     \
  \/  \  \/    \ O/  \
      /         \/

Salida: (una posible solución, más existe)

down
    /  \  \    /
   /  . \  \  /
  /  /\/   /\ \  /
 /  /     /  \ \/
/  /   /\ \  /  \  /
\  \  /  \ \/    \/ 
/     \  /          /
  /\   \//\ \      /
\/  \   /  \ \     \/
 \  /\  \  /  \  /  \
  \/  \  \/    \ O/  \
      /  \      \/
                \   /

Reglas

  • La entrada es el hoyo de mini golf STDIN.
  • La salida es la dirección en la que golpeas la pelota y el hoyo de mini golf con parachoques recién colocados STDOUT.
  • Los parachoques existentes no se pueden mover.
  • Puede agregar cualquier cantidad de parachoques para resolver un agujero.
  • Suponga que hay ubicaciones válidas para colocar los parachoques que permitirán que el curso se resuelva en un putt.
  • El orificio de salida puede ser más grande que la entrada.
  • La entrada puede rellenarse con espacios en blanco al final, pero especifique en su respuesta si hace esto.
  • El resultado debe verse correcto, pero puede tener espacios en blanco iniciales o finales.
  • Su programa debería funcionar para cualquier hoyo válido. ¡Siéntase libre de publicar sus casos de prueba también!

Puntuación

Este es el código de golf . Su puntaje es el número de caracteres en su programa. ¡La puntuación más baja gana!

code-golf ascii-art hmatt1
fuente
1
Estoy bastante seguro de que las direcciones (arriba, izquierda, derecha, abajo) son incorrectas en los siguientes ejemplos: # 2 ejemplo 2 debería ser right, # 3 ejemplo 1 debería ser down, y # 3 ejemplo 2 debería ser up. ¡Interesante desafío, sin embargo!
Pomo de la puerta
@Doorknob gracias! .es la pelota que estás golpeando y Oes el hoyo. Cometí un error en el # 1 ejemplo 1 pero ahora deberían estar bien.
hmatt1

Respuestas:

6

Javascript (ES6) - 651 bytes

G=s=>{Q='\\';S=[[]];n=L=1;s.split(N='\n').map(t=>{j=S[L++]=[];l=t.length;n=n>l?n:l;k=1;t.split('').map(T=>{j[k++]=T})});S[O=L++]=[];n++;for(r=0;r<L;r++)for(c=0;c<=n;c++){v=S[r][c];if(!v)S[r][c]=' ';if(v=='.'){x=c;y=r}if(v=='o'){X=c;Y=r}}f=M=>{J=M?'.':'o';K=M?'o':'.';R=0;for(D=0;1;D++){R=D&4;D=D&3;c=e=D;g=M?X:x;h=M?Y:y;while(c!=K){c=S[h+=[-1,0,1,0][e]][g+=[0,1,0,-1][e]];e=c=='/'?(B=c,e^1):c==Q?(B=c,3-e):e;E=h*(h-O)?g*(g-n)?0:2:1;if(R&&c==' '){S[h][g]=Q;R=D=0;c=K}if(c==J||E){E&&(S[h][g]=(E+M)%2?Q:'/');H=M?E?H:(e+2)&3:D;return}}}};f(0);f(1);S[0][0]=S[O][n]='/';S[0][n]=S[O][0]=Q;return['up','right','down','left'][H]+N+S.map(t=>t.join('')).join(N)}

Crea una función Gque acepta una cadena (campo de golf) como entrada y devuelve la solución de colocación solicitada. La cadena de entrada puede tener o no líneas iniciales, líneas finales y espacios en blanco finales. La salida no tendrá espacios en blanco iniciales o finales.

El código expandido es:

G = s => {
    Q = '\\';
    S = [[]];
    n = L = 1;
    s.split( N = '\n' ).map( t => {
        j = S[L++] = [];
        l = t.length;
        n = n > l ? n : l;
        k = 1;
        t.split('').map( T => {
            j[k++] = T;
        } );
    } );
    S[O = L++] = [];
    n++;
    for( r = 0; r < L; r++ )
        for( c = 0; c <= n; c++ ) {
            v = S[r][c];
            if( !v )
                S[r][c] = ' ';
            if( v == '.' ) {
                x = c;
                y = r;
            }
            if( v == 'o' ) {
                X = c;
                Y = r;
            }
        }
    f = M => {
        J = M ? '.' : 'o';
        K = M ? 'o' : '.';
        R = 0;
        for( D = 0; 1; D++ ) {
            R = D & 4;
            D = D & 3;
            c = e = D;
            g = M ? X : x;
            h = M ? Y : y;
            while( c != K ) {
                c = S[h += [-1,0,1,0][e]][g += [0,1,0,-1][e]];
                e = c == '/' ? (B=c,e^1) : c == Q ? (B=c,3-e) : e;
                E = h*(h-O) ? g*(g-n) ? 0 : 2 : 1;
                if( R && c == ' ' ) {
                    S[h][g] = B;
                    R = D = 0;
                    c = K;
                }
                if( c == J || E ) {
                    E && (S[h][g] = (E+M)%2 ? Q : '/');
                    H = M ? E ? H : (e+2)&3 : D;
                    return;
                }
            }
        }
    };
    f(0);
    f(1);
    S[0][0] = S[O][n] = '/';
    S[0][n] = S[O][0] = Q;
    return ['up','right','down','left'][H] + N + S.map( t => t.join('') ).join( N );
}

El solucionador opera bajo la premisa de que cualquier camino desde la bola (hoyo)

  1. conducir de nuevo a la pelota (hoyo) nuevamente
  2. conducir al hoyo (bola)
  3. salir del curso

Trazamos el camino de la pelota en las cuatro direcciones. Si encontramos el caso 3, el problema está resuelto. Si encontramos el caso 2, marcamos la ubicación de salida de la pelota. Si las cuatro direcciones resultan en el caso 1, convertimos el primer espacio que no es parachoques a lo largo de cualquier trayectoria en un parachoques (si el problema es solucionable, siempre se garantiza que dicho espacio exista) e intentamos nuevamente. El parachoques al que convertimos tendrá el mismo tipo que el último parachoques que encontró nuestra trayectoria *. Si la pelota todavía está atrapada en un bucle, repetimos el proceso tantas veces como sea necesario. Si el problema tiene solución, se garantiza que este procedimiento conducirá eventualmente al resultado 2 o 3.

(* Tenga en cuenta que si simplemente convertimos a un parachoques fijo [digamos, \], existen casos extremadamente artificiales pero posibles, sin embargo , donde existe una solución, pero no lo encontraremos).

Realizamos una traza similar desde el agujero, que conduce al resultado 2 o al resultado 3.

Si tanto el trazado de la bola como el trazado del hoyo resultan en el resultado 2, colocamos topes en la periferia del recorrido que une los dos puntos de salida (de hecho, estos topes de la periferia se colocan independientemente de los resultados de la traza, para acortar el código). Esto completa la solución.

Casos de prueba y salidas

En

   /   \   / \ /\    
   \\      /    \  \ 
       /     / o   / 
   /   \       /     
   \   .  \  \    \\ 
       /  /     \ \  
       \          /  
           \      /  
 \ /\     /  \/  //\

Fuera

right
/   /               \
   /   \   / \ /\    
   \\      /    \  \ 
       /     / o   / 
   /   \       /     
   \   .  \  \    \\ 
       /  /     \ \  
       \          / /
           \      /  
 \ /\     /  \/  //\ 
\                   /

En

  / \   / /    /  \    / \  /  \\ /
\   \ /  \  // \    \   /   /\   \
/ \   // \  //   \ \   \ /  / \\ \
 \  / \    /   \  \  / / \\ / /  //
/ /   /\ \\ //  / \   /  \ / \\ \ \
\   \  \ \ // \ /  /    \ \  /  / /
/ \ /   /  / \     / \ /\   /  \  /
\ /\  //\   .\  \ \ //\ /  \  / \ /
/ \/ \ /\ //\   /   \   / o// \ / \
/   / \    / \ / \\ / \   / \   \ \
/ /   / \  / \ //   \    / \/  /\/
   / \   / \  /   \\  / \    /\ / \
/ \/   \   /   \/  \   /  \    /\\
/ /\\ //\  / \  /\ /\   /  / \ / \/

Fuera

left
/                                   \
   / \   / /    /  \    / \  /  \\ / 
 \   \ /  \  // \    \   /   /\   \  
 / \   // \  //   \ \   \ /  / \\ \  
  \  / \    /   \  \  / / \\ / /  // 
 / /   /\ \\ //  / \   /  \ / \\ \ \ 
 \   \  \ \ // \ /  /    \ \  /  / / 
 / \ /   /  / \     / \ /\   /  \  / 
 \ /\  //\   .\  \ \ //\ /  \  / \ / 
 / \/ \ /\ //\   /   \   / o// \ / \ 
 /   / \    / \ / \\ / \   / \   \ \ 
 / /   / \  / \ //   \    / \/  /\/  
    / \   / \  /   \\  / \    /\ / \ 
 / \/   \   /   \/  \   /  \    /\\  
 / /\\ //\  / \  /\ /\   /  / \ / \/ 
\         \                         /

En

/\/ \      
\  \ \     
 \ \\ \   o
  \ .\ \   
   \ / /   
    \ /

Fuera

down
/   \      /\
 /\/\\       
 \ \\ \      
  \ \\ \   o 
   \ .\ \    
    \ / /    
     \ /     
\           /
COTO
fuente
Falla en este caso de prueba:"/\\/\\\n\\.//\n// \\\n\\/ \no \\/"
Anders Kaseorg