Code-Golf Ascii Art Mini-Golf

13

Intro

Jouons au mini-golf! La balle de golf est représentée par un .et le trou par un O. Vous voulez obtenir un trou en un sur chaque trou, mais vous n'êtes pas bon à mettre. En fait, vous refusez de tenter de mettre en diagonale! Seulement en haut, en bas et de chaque côté.

Vous prévoyez de tricher en plaçant des pare \- chocs supplémentaires et /ainsi vous pouvez mettre la balle en un seul coup. La balle rebondit sur les pare-chocs à angle droit, comme indiqué sur cette image.

Le golf

N'oubliez pas d'appeler votre tir! Dites-nous quelle direction vous mettez.

des trous

1: Le premier trou est facile, un coup droit! Aucun pare-chocs nécessaire pour placer ici.

Contribution:

.         O

Production:

right
.         O

2: Un autre élémentaire, un court virage. La balle est frappée du pare-chocs dans le trou.

Contribution:

     .
O

Production:

left
/    .
O

ou

down
     .
O    /

3: Certains trous ont déjà des pare-chocs!

Contribution:

.   \O

Production:

right
.   \O
    \/

ou

right
   / \
.  /\O

4: Certains trous sont trop complexes!

Contribution:

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

Sortie: (une solution possible, il en existe d'autres)

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

Règles

  • L' entrée est le mini-golf sur STDIN.
  • La sortie est la direction dans laquelle vous frappez la balle et le trou de mini-golf avec des pare-chocs nouvellement placés STDOUT.
  • Les pare-chocs existants ne peuvent pas être déplacés.
  • Vous pouvez ajouter un nombre quelconque de pare-chocs pour résoudre un trou.
  • Supposons qu'il existe des emplacements valides pour les pare-chocs à placer qui permettront au parcours d'être résolu en un putt.
  • Le trou en sortie peut être plus grand que l'entrée.
  • L'entrée peut être complétée par un espace blanc à la fin, mais veuillez spécifier dans votre réponse si vous faites cela.
  • La sortie doit être correcte, mais peut comporter un espace blanc de début ou de fin.
  • Votre programme devrait fonctionner pour tout trou valide. N'hésitez pas à poster vos cas de test aussi!

Notation

C'est du code-golf . Votre score est le nombre de caractères de votre programme. Le score le plus bas gagne!

code-golf  ascii-art 
— hmatt1
source
1
Je suis presque sûr que les directions (haut, gauche, droite, bas) sont fausses dans les exemples suivants: # 2, l'exemple 2 devrait être right, # 3, l'exemple 1 devrait être down, et # 3, l'exemple 2 devrait être up. Un défi intéressant, cependant!
— Poignée de porte
@ Doorknob merci! .est la balle que vous frappez et Oc'est le trou. J'ai foiré l'exemple n ° 2, mais ils devraient être bons maintenant.
— hmatt1

Réponses:

6

Javascript (ES6) - 651 octets

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

Crée une fonction G qui accepte une chaîne (parcours de golf) en entrée et renvoie la solution de putting demandée. La chaîne d'entrée peut avoir ou non des lignes de début, des lignes de fin et des espaces de fin. La sortie n'aura pas d'espace blanc de début ou de fin.

Le code développé est:

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

Le solveur part du principe que tout chemin à partir de la balle (trou) sera soit

  1. ramener à nouveau au ballon (trou)
  2. conduire au trou (balle)
  3. quitter le cours

Nous suivons le chemin de la balle dans les quatre directions. Si nous trouvons le cas 3, le problème est résolu. Si nous trouvons le cas 2, nous marquons l'emplacement de sortie de la balle. Si les quatre directions aboutissent au cas 1, nous convertissons le premier espace non pare-chocs le long d'une trajectoire en pare-chocs (si le problème est résoluble, un tel espace est toujours garanti d'exister) et réessayons. Le pare-chocs que nous convertissons aura le même type que le dernier pare-chocs que notre trajectoire a rencontré *. Si la balle est toujours coincée dans une boucle, nous répétons le processus autant de fois que nécessaire. Si le problème est résoluble, cette procédure est garantie de conduire à terme au résultat 2 ou 3.

(* Notez que si nous nous convertissons simplement à un pare-chocs fixe [disons \], il existe des cas extrêmement artificiels mais néanmoins possibles où une solution existe mais nous ne la trouverons pas.)

Nous effectuons une trace similaire à partir du trou, conduisant au résultat 2 ou au résultat 3.

Si à la fois la trace de la balle et la trace du trou aboutissent au résultat 2, nous plaçons des pare-chocs à la périphérie du parcours qui relient les deux points de sortie (en fait, ces pare-chocs de périphérie sont placés indépendamment des résultats de la trace, pour raccourcir le code). Ceci complète la solution.

Cas de test et sorties

Dans

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

En dehors

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

Dans

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

En dehors

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

Dans

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

En dehors

down
/   \      /\
 /\/\\       
 \ \\ \      
  \ \\ \   o 
   \ .\ \    
    \ / /    
     \ /     
\           /
— COTO
source
Échoue sur ce cas de test:"/\\/\\\n\\.//\n// \\\n\\/ \no \\/"
— Anders Kaseorg
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.