14

Cuando a los estudiantes se les enseña por primera vez sobre la técnica de prueba de inducción matemática , un ejemplo común es el problema de colocar una rejilla de 2 ^N × 2 ^N con trominos en forma de L , dejando un espacio de rejilla predeterminado vacío. (N es un número entero no negativo).

Te dejaré que revises la prueba si aún no lo sabes. Hay muchos recursos que lo discuten.

Su tarea aquí es escribir un programa que tome un valor para N, así como las coordenadas del espacio de la cuadrícula para dejarlas vacías, e imprima una representación ASCII de la cuadrícula de mosaicos de tromino resultante.

El personaje Ollenará el espacio vacío, y las 4 rotaciones de nuestro tromino se verán así:

|
+-

 |
-+

-+
 |

+-
|

^{(Sí, puede ser ambiguo cuál +va con qué -y |para ciertos arreglos, pero está bien).}

Su programa debe funcionar para N = 0 (para una cuadrícula de 1 × 1) hasta al menos N = 8 (para una cuadrícula de 256 × 256). Se le darán valores x e y que son las coordenadas para O:

x es el eje horizontal. x = 1 es el borde izquierdo de la cuadrícula, x = 2 ^N es el borde derecho de la cuadrícula.
y es el eje vertical. y = 1 es el borde superior de la cuadrícula, y = 2 ^N es el borde inferior de la cuadrícula.

Tanto x como y siempre están en el rango [1, 2 ^N ].

Entonces, para un determinado N, x e y, su programa debe imprimir una cuadrícula de 2 ^N × 2 ^N , completamente en mosaico con trominoes en forma de L, excepto por la coordenada de la cuadrícula x, y que será un O.

Ejemplos

Si N = 0, entonces x e y deben ser ambos 1. La salida es simplemente

Si N = 1, x = 1 ey = 2, la salida sería

-+
O|

N = 2, x = 3, y = 2:

+--+
||O|
|+-|
+--+

N = 2, x = 4, y = 1:

+-|O
||+-
|+-|
+--+

N = 3, x = 3, y = 6 (por ejemplo, la imagen en esta página ):

+--++--+
|+-||-+|
||+--+||
+-|-+|-+
+--+||-+
||O|-+||
|+-||-+|
+--++--+

Detalles

Puede escribir una función que tome los 3 enteros en lugar de escribir un programa completo. Debe imprimir o devolver la cadena de la cuadrícula.
Tome la entrada de stdin, línea de comando, (o args de función si escribe función).
La salida puede contener opcionalmente una línea de entrenamiento única.
No es necesario que utilice el método de mosaico que normalmente sugiere la prueba. Solo importa que la cuadrícula esté llena de trominoes en forma de L además del O. (Los trominos no se pueden cortar ni salir de los límites de la cuadrícula).

El código más corto en bytes gana. Tiebreaker es una publicación anterior. ( Práctico contador de bytes ) .

code-golf ascii-art geometry grid tiling Pasatiempos de Calvin
fuente

2

Haskell, 250 240 236 bytes

c=cycle
z o(#)(x,y)=zipWith o(1#x)(2#y)
f n x y=unlines$(z(+)(\m w->[c[0,m]!!div(w-1)(2^(n-k))|k<-[1..n]])(x,y),"O")%n
(_,x)%0=[x]
((p:o),x)%k=z(++)(\_ q->((o,x):c[(c[3-q],[" |-+| +--+ |+-|"!!(4*p+q)])])!!abs(p-q)%(k-1))=<<[(0,1),(2,3)]

Esto sigue de cerca la solución inductiva del problema. El punto a marcar está representado por una secuencia de números del 0 al 3 que indican qué cuadrante contiene el punto en cada nivel de zoom; esto se calcula inicialmente por la expresión que comienza con z (+). El operador (%) combina imágenes para los cuatro cuadrantes en una sola imagen. Las imágenes de los cuadrantes sin marcar se generan dibujando cuadrantes marcados con la marca en algún lugar cerca del centro, dibujados con una marca de "+ - |" según corresponda para construir el mosaico central L.

Negocio divertido: por razones de golf, la subexpresión

\m w->[c[0,m]!!div(w-1)(2^(n-k))|k<-[1..n]]

(que calcula más o menos la secuencia de bits para un número) es hilarantemente ineficiente: determina si w / 2 ^ p es impar o incluso buscando el elemento (w / 2 ^ p) de una lista.

Editar: ahorró 10 bytes al incorporar el cálculo de bits y reemplazar un if / then / else con una operación de indexación.

Edit2: guardó cuatro bytes más volviendo a cambiar una función a un operador. @randomra, ¡la carrera está en marcha!

Manifestación:

λ> putStr $ f 4 5 6
+--++--++--++--+
|+-||-+||+-||-+|
||+--+||||+--+||
+-|+-|-++-|-+|-+
+-||-+-++--+||-+
||+-O||||-+|-+||
|+-||-+|-+|||-+|
+--++--+||-++--+
+--++-|-+|-++--+
|+-|||+--+|||-+|
||+-|+-||-+|-+||
+-||+--++--+||-+
+-|+-|-++-|-+|-+
||+--+||||+--+||
|+-||-+||+-||-+|
+--++--++--++--+

Matt Noonan
fuente

8

C, 399 bytes

char*T=" |-+ | +-| ",*B;w;f(N,x,y,m,n,F,h,k,i,j){w=B?F=0,w:1<<N|1;char b[N?w*w:6];for(k=w;k--;)b[k*w-1]=10;B=!B?F=1,m=0,n=0,x--,y--,b:B;if(N>1){h=1<<N-1;i=x>--h,j=y>h;while(++k<4)if(k%2-i||k/2-j)f(N-1,!(k%2)*h,!(k/2)*h,m+k%2*(h+1),n+k/2*(h+1));f(1,h&i,h&j,m+h,n+h);h++;f(N-1,x-h*i,y-h*j,m+h*i,n+h*j);}else while(++k<4)B[w*(n+k/2)+m+k%2]=T[5*x+2*y+k];if(F)B[y*w+x]=79,B[w*w-w-1]=0,puts(N?B:"O"),B=0;}

Nadie ha presentado nada todavía, así que ofreceré una solución exigua. Marque mis palabras, este no es el final. Esto se acortará.

Definimos una función fque toma 10 argumentos, pero solo necesita llamarla con f(N, X, Y). La salida va a stdout.

Aquí hay una versión legible:

char*T=" |-+ | +-| ",*B;
w;
f(N,x,y,m,n,F,h,k,i,j){
    w=B?F=0,w:1<<N|1;
    char b[N?w*w:6];
    for(k=w;k--;)
        b[k*w-1]=10;
    B=!B?F=1,m=0,n=0,x--,y--,b:B;
    if(N>1){
        h=1<<N-1;
        i=x>--h,j=y>h;
        while(++k<4)
            if(k%2-i||k/2-j)
                f(N-1,!(k%2)*h,!(k/2)*h,m+k%2*(h+1),n+k/2*(h+1));
        f(1,h&i,h&j,m+h,n+h);
        h++;
        f(N-1,x-h*i,y-h*j,m+h*i,n+h*j);
    }
    else
        while(++k<4)
            B[w*(n+k/2)+m+k%2]=T[5*x+2*y+k];
    if(F)B[y*w+x]=79,B[w*w-w-1]=0,puts(N?B:"O"),B=0;
}

Una muestra de salida para f(3, 2, 7):

+--++--+
|+-||-+|
||+--+||
+-|-+|-+
+--+||-+
|-+|-+||
|O|||-+|
+--++--+

Es un algoritmo recursivo bastante simple para llenar la cuadrícula. Puedo subir una animación del algoritmo dibujando trominoes ya que creo que está bastante bien. Como de costumbre, siéntase libre de hacer preguntas y gritarme si mi código se rompe.

Pruébalo en línea !

BrainSteel
fuente

8

Python 3, 276 265 237 bytes

Mi primer Python golf, así que estoy seguro de que hay mucho margen de mejora.

def f(n,x,y,c='O'):
 if n<1:return c
 *t,l,a='x|-+-|',2**~-n;p=(a<x)+(a<y)*2
 for i in 0,1,2,3:t+=(p-i and f(n-1,1+~i%2*~-a,1+~-a*(1-i//2),l[p+i])or f(n-1,1+~-x%a,1+~-y%a,c)).split(),
 u,v,w,z=t;return'\n'.join(map(''.join,zip(u+w,v+z)))

10 bytes guardados gracias a @xnor y 6 bytes más gracias a @ Sp3000.

La función devuelve una cadena. Ejemplo de uso:

>>>print(f(3,3,6))    
+--++--+
|+-||-+|
||+--+||
+-|-+|-+
+--+||-+
||O|-+||
|+-||-+|
+--++--+

randomra
fuente

1

¡Una impresionante primera carrera en el golf de Python! Algunos charsaves rápidos. Puedes cortar el espacio antes if p!=i; la lista dentro .join()no necesita []; (1-i%2)se puede hacer como ~i%2; puede usar el desempaquetado iterable para escribir t,l,a=[],...como *t,l,a=...; if n==0puede verificarse como if n<1porque nno puede ser negativo; la final "\n".joinprobablemente se puede hacer imprimiendo cada elemento, ya que las reglas generales permiten imprimir en lugar de regresar; if p!=ipuede ser if p-iporque los valores distintos de cero son Verdad.

xnor

@xnor Gracias por los consejos! El desempaquetado para obtener una lista vacía implícita es muy bueno. Uso return en lugar de print, ya que fes una función recursiva. De hecho, tengo que revertir el formato de salida con split()cada auto llamada.

randomra

Unos cuantos más: la última línea se puede escribir como A,B,C,D=t;return'\n'.join(map("".join,zip(A+C,B+D))), t+=[...]en la penúltima línea se puede escribir como t+=...,(agregando una tupla en lugar de una lista) y no estoy seguro de si funciona, pero A if B else Cse puede escribir como B and A or C(también en el penúltima línea), pero solo si A nunca es falso (¿qué no creo que sea?)

Sp3000

4

JavaScript (ES6) 317 414

Mucho trabajo para jugar al golf, pero aún bastante largo.

T=(b,x,y)=>
  (F=(d,x,y,f,t=[],q=y<=(d>>=1)|0,
      b=d?x>d
       ?q
         ?F(d,x-d,y,0,F(d,1,1,2))
         :F(d,1,d,2,F(d,x-d,y-d))
       :F(d,1,d,1-q,F(d,1,1,q)):0,
      r=d?(x>d
         ?F(d,d,d,1-q,F(d,d,1,q))
         :q
           ?F(d,x,y,1,F(d,d,1,2))
           :F(d,d,d,2,F(d,x,y-d))
      ).map((x,i)=>x.concat(b[i])):[[]]
    )=>(r[y-1][x-1]='|+-O'[f],r.concat(t))
  )(1<<b,x,y,3).join('\n').replace(/,/g,'')

Ejecute el fragmento para probar (mejor aspecto usando caracteres de bloque Unicode, pero incluso un poco más)

Mostrar fragmento de código

T=(b,x,y)=>
  (F=(d,x,y,f,t=[],q=y<=(d>>=1)|0,
      b=d?x>d
       ?q
         ?F(d,x-d,y,0,F(d,1,1,6))
         :F(d,1,d,6,F(d,x-d,y-d))
       :F(d,1,d,q,F(d,1,1,q+1)):0,
      r=d?(x>d
         ?F(d,d,d,q+3,F(d,d,1,q+4))
         :q
           ?F(d,x,y,1,F(d,d,1,6))
           :F(d,d,d,6,F(d,x,y-d))
      ).map((x,i)=>x.concat(b[i])):[[]]
    )=>(
    r[y-1][x-1]='┐│┘┌│└─O'[f],r.concat(t)
  ))(1<<b,x,y,7).join('\n').replace(/,/g,'')

loop=_=>{
  var x=X.value|0, y=Y.value|0, n=N.value|0;
  
  var b=1<<n, cur=1<<(n+n);
  (L=_=>{
    --cur;
    O.innerHTML=T(n,(cur&(b-1))+1,(cur>>n)+1);
    cur&&setTimeout(L,100);
  })()
}

tile=_=>{
  var x=X.value|0, y=Y.value|0, n=N.value|0;
  O.innerHTML=T(n,x,y);
}

tile()

input { width: 3em }
pre { font-size: 10px; line-height: 10px }

N: <input id=N value=4> X: <input id=X value=5> Y: <input id=Y value=3>
<button onclick="tile()">Tile</button>
<button onclick="loop()">Loop</button>
<pre id=O></pre>

Expandir fragmento

edc65
fuente

1

IDL 8.3+, 293 bytes

Esto es demasiado largo, estoy tratando de reducirlo, pero aún no he llegado allí.

function t,n,x,y
m=2^n
c=['|','+','-']
b=replicate('0',m,m)
if m eq 1 then return,b
h=m/2
g=h-1
k=[1:h]
o=x gt h
p=y gt h
q=o+2*p
if m gt 2then for i=0,1 do for j=0,1 do b[i*h:i*h+g,j*h:j*h+g]=t(n-1,i+2*j eq q?x-i*h:k[i-1],i+2*j eq q?y-j*h:k[j-1])
b[g+[1-o,1-o,o],g+[p,1-p,1-p]]=c
return,b
end

Salidas:

IDL> print,t(1,1,2)
- +
0 |
IDL> print,t(2,3,2)
+ - - +
| | 0 |
| + - |
+ - - +
IDL> print,t(2,4,1)
+ - | 0
| | + -
| + - |
+ - - +
IDL> print,t(3,3,6)
+ - - + + - - +
| + - | | - + |
| | + - - + | |
+ - | - + | - +
+ - - + | | - +
| | 0 | - + | |
| + - | | - + |
+ - - + + - - +

Y, eh ... solo por diversión ...

IDL> print,t(6,8,9)
+ - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - +
| + - | | - + | | + - | | - + | | + - | | - + | | + - | | - + | | + - | | - + | | + - | | - + | | + - | | - + | | + - | | - + |
| | + - - + | | | | + - - + | | | | + - - + | | | | + - - + | | | | + - - + | | | | + - - + | | | | + - - + | | | | + - - + | |
+ - | + - | - + + - | - + | - + + - | + - | - + + - | - + | - + + - | + - | - + + - | - + | - + + - | + - | - + + - | - + | - +
+ - | | + - - + + - - + | | - + + - | | + - - + + - - + | | - + + - | | + - - + + - - + | | - + + - | | + - - + + - - + | | - +
| | + - | + - | | - + | - + | | | | + - | + - | | - + | - + | | | | + - | + - | | - + | - + | | | | + - | + - | | - + | - + | |
| + - | | | + - - + | | | - + | | + - | | | + - - + | | | - + | | + - | | | + - - + | | | - + | | + - | | | + - - + | | | - + |
+ - - + + - | - + | - + + - - + + - - + + - | - + | - + + - - + + - - + + - | + - | - + + - - + + - - + + - | - + | - + + - - +
+ - - + + - | 0 | | - + + - - + + - - + + - - + | | - + + - - + + - - + + - | | + - - + + - - + + - - + + - - + | | - + + - - +
| + - | | | + - - + | | | - + | | + - | | - + | - + | | | - + | | + - | | | + - | + - | | - + | | + - | | - + | - + | | | - + |
| | + - | + - | | - + | - + | | | | + - - + | | | - + | - + | | | | + - | + - | | | + - - + | | | | + - - + | | | - + | - + | |
+ - | | + - - + + - - + | | - + + - | - + | - + + - - + | | - + + - | | + - - + + - | + - | - + + - | - + | - + + - - + | | - +
+ - | + - | - + + - | - + | - + + - - + | | - + + - | - + | - + + - | + - | - + + - | | + - - + + - - + | | - + + - | - + | - +
| | + - - + | | | | + - - + | | | - + | - + | | | | + - - + | | | | + - - + | | | | + - | + - | | - + | - + | | | | + - - + | |
| + - | | - + | | + - | | - + | - + | | | - + | | + - | | - + | | + - | | - + | | + - | | | + - - + | | | - + | | + - | | - + |
+ - - + + - - + + - - + + - - + | | - + + - - + + - - + + - - + + - - + + - - + + - - + + - | - + | - + + - - + + - - + + - - +
+ - - + + - - + + - - + + - | - + | - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + | | - + + - - + + - - + + - - +
| + - | | - + | | + - | | | + - - + | | | - + | | + - | | - + | | + - | | - + | | + - | | - + | - + | | | - + | | + - | | - + |
| | + - - + | | | | + - | + - | | - + | - + | | | | + - - + | | | | + - - + | | | | + - - + | | | - + | - + | | | | + - - + | |
+ - | + - | - + + - | | + - - + + - - + | | - + + - | - + | - + + - | + - | - + + - | - + | - + + - - + | | - + + - | - + | - +
+ - | | + - - + + - | + - | - + + - | - + | - + + - - + | | - + + - | | + - - + + - - + | | - + + - | - + | - + + - - + | | - +
| | + - | + - | | | + - - + | | | | + - - + | | | - + | - + | | | | + - | + - | | - + | - + | | | | + - - + | | | - + | - + | |
| + - | | | + - | + - | | - + | | + - | | - + | - + | | | - + | | + - | | | + - - + | | | - + | | + - | | - + | - + | | | - + |
+ - - + + - | | + - - + + - - + + - - + + - - + | | - + + - - + + - - + + - | - + | - + + - - + + - - + + - - + | | - + + - - +
+ - - + + - | + - | - + + - - + + - - + + - | - + | - + + - - + + - - + + - - + | | - + + - - + + - - + + - | - + | - + + - - +
| + - | | | + - - + | | | - + | | + - | | | + - - + | | | - + | | + - | | - + | - + | | | - + | | + - | | | + - - + | | | - + |
| | + - | + - | | - + | - + | | | | + - | + - | | - + | - + | | | | + - - + | | | - + | - + | | | | + - | + - | | - + | - + | |
+ - | | + - - + + - - + | | - + + - | | + - - + + - - + | | - + + - | - + | - + + - - + | | - + + - | | + - - + + - - + | | - +
+ - | + - | - + + - | - + | - + + - | + - | - + + - | - + | - + + - - + | | - + + - | - + | - + + - | + - | - + + - | - + | - +
| | + - - + | | | | + - - + | | | | + - - + | | | | + - - + | | | - + | - + | | | | + - - + | | | | + - - + | | | | + - - + | |
| + - | | - + | | + - | | - + | | + - | | - + | | + - | | - + | - + | | | - + | | + - | | - + | | + - | | - + | | + - | | - + |
+ - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + | | - + + - - + + - - + + - - + + - - + + - - + + - - + + - - +
+ - - + + - - + + - - + + - - + + - - + + - - + + - - + + - | - + | - + + - - + + - - + + - - + + - - + + - - + + - - + + - - +
| + - | | - + | | + - | | - + | | + - | | - + | | + - | | | + - - + | | | - + | | + - | | - + | | + - | | - + | | + - | | - + |
| | + - - + | | | | + - - + | | | | + - - + | | | | + - | + - | | - + | - + | | | | + - - + | | | | + - - + | | | | + - - + | |
+ - | + - | - + + - | - + | - + + - | + - | - + + - | | + - - + + - - + | | - + + - | - + | - + + - | + - | - + + - | - + | - +
+ - | | + - - + + - - + | | - + + - | | + - - + + - | + - | - + + - | - + | - + + - - + | | - + + - | | + - - + + - - + | | - +
| | + - | + - | | - + | - + | | | | + - | + - | | | + - - + | | | | + - - + | | | - + | - + | | | | + - | + - | | - + | - + | |
| + - | | | + - - + | | | - + | | + - | | | + - | + - | | - + | | + - | | - + | - + | | | - + | | + - | | | + - - + | | | - + |
+ - - + + - | + - | - + + - - + + - - + + - | | + - - + + - - + + - - + + - - + | | - + + - - + + - - + + - | - + | - + + - - +
+ - - + + - | | + - - + + - - + + - - + + - | + - | - + + - - + + - - + + - | - + | - + + - - + + - - + + - - + | | - + + - - +
| + - | | | + - | + - | | - + | | + - | | | + - - + | | | - + | | + - | | | + - - + | | | - + | | + - | | - + | - + | | | - + |
| | + - | + - | | | + - - + | | | | + - | + - | | - + | - + | | | | + - | + - | | - + | - + | | | | + - - + | | | - + | - + | |
+ - | | + - - + + - | + - | - + + - | | + - - + + - - + | | - + + - | | + - - + + - - + | | - + + - | - + | - + + - - + | | - +
+ - | + - | - + + - | | + - - + + - | + - | - + + - | - + | - + + - | + - | - + + - | - + | - + + - - + | | - + + - | - + | - +
| | + - - + | | | | + - | + - | | | + - - + | | | | + - - + | | | | + - - + | | | | + - - + | | | - + | - + | | | | + - - + | |
| + - | | - + | | + - | | | + - | + - | | - + | | + - | | - + | | + - | | - + | | + - | | - + | - + | | | - + | | + - | | - + |
+ - - + + - - + + - - + + - | | + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + | | - + + - - + + - - + + - - +
+ - - + + - - + + - - + + - | + - | - + + - - + + - - + + - - + + - - + + - - + + - - + + - | - + | - + + - - + + - - + + - - +
| + - | | - + | | + - | | | + - - + | | | - + | | + - | | - + | | + - | | - + | | + - | | | + - - + | | | - + | | + - | | - + |
| | + - - + | | | | + - | + - | | - + | - + | | | | + - - + | | | | + - - + | | | | + - | + - | | - + | - + | | | | + - - + | |
+ - | + - | - + + - | | + - - + + - - + | | - + + - | - + | - + + - | + - | - + + - | | + - - + + - - + | | - + + - | - + | - +
+ - | | + - - + + - | + - | - + + - | - + | - + + - - + | | - + + - | | + - - + + - | + - | - + + - | - + | - + + - - + | | - +
| | + - | + - | | | + - - + | | | | + - - + | | | - + | - + | | | | + - | + - | | | + - - + | | | | + - - + | | | - + | - + | |
| + - | | | + - | + - | | - + | | + - | | - + | - + | | | - + | | + - | | | + - | + - | | - + | | + - | | - + | - + | | | - + |
+ - - + + - | | + - - + + - - + + - - + + - - + | | - + + - - + + - - + + - | | + - - + + - - + + - - + + - - + | | - + + - - +
+ - - + + - | + - | - + + - - + + - - + + - | - + | - + + - - + + - - + + - | + - | - + + - - + + - - + + - | - + | - + + - - +
| + - | | | + - - + | | | - + | | + - | | | + - - + | | | - + | | + - | | | + - - + | | | - + | | + - | | | + - - + | | | - + |
| | + - | + - | | - + | - + | | | | + - | + - | | - + | - + | | | | + - | + - | | - + | - + | | | | + - | + - | | - + | - + | |
+ - | | + - - + + - - + | | - + + - | | + - - + + - - + | | - + + - | | + - - + + - - + | | - + + - | | + - - + + - - + | | - +
+ - | + - | - + + - | - + | - + + - | + - | - + + - | - + | - + + - | + - | - + + - | - + | - + + - | + - | - + + - | - + | - +
| | + - - + | | | | + - - + | | | | + - - + | | | | + - - + | | | | + - - + | | | | + - - + | | | | + - - + | | | | + - - + | |
| + - | | - + | | + - | | - + | | + - | | - + | | + - | | - + | | + - | | - + | | + - | | - + | | + - | | - + | | + - | | - + |
+ - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - +

Sirpercival
fuente

0

Ruby Rev 1, 288

Como un literal lambda anónimo. Se muestra en el programa de prueba (el literal lambda es ->(n,a,b){...})

g=
->(n,a,b){
$x=a-1
$y=b-1
$a=Array.new(m=2**n){"|"*m}
def t(u,v,m,r,f)
(m/=2)==1?$a[v+1-r/2%2][u,2]='-+-'[r%2,2]:0
if m>1 
4.times{|i|i==r ?t(u+m/2,v+m/2,m,r,0):t(u+i%2*m,v+i/2*m,m,3-i,0)}
f>0?t(u+r%2*m,v+r/2*m,m,2*$x/m&1|$y*4/m&2,1):0
end
end
t(0,0,m,2*$x/m|$y*4/m,1) 
$a[$y][$x]='O'
$a
}

n=gets.to_i
a=gets.to_i
b=gets.to_i
puts(g.call(n,a,b))

Ruby Rev 0, 330 sin golf

Actualmente, el único juego de golf que reclamo es la eliminación de comentarios, nuevas líneas innecesarias y sangrías.

Este es mi primer algoritmo apropiado codificado en Ruby y ha sido un trabajo duro. Estoy seguro de que hay al menos 50 caracteres que pueden eliminarse, pero he hecho lo suficiente por ahora. Hay algunos horrores reales, por ejemplo, la entrada. Eso probablemente se puede solucionar mediante una función o lambda en lugar de un programa, pero la función internat que dibuja los trominoes aún necesita acceso a las variables globales. Tendré que averiguar la sintaxis para eso.

Una característica de mi respuesta que no está presente en los demás es que inicializo una serie de cadenas con |caracteres. Eso significa que solo tengo que dibujar el +-o -+, que están uno al lado del otro en la misma línea.

m=2**gets.to_i                                         #get n and store 2**n in m
$x=gets.to_i-1                                         #get x and y, and...
$y=gets.to_i-1                                         #convert from 1-indexed to 0-indexed
$a=Array.new(m){"|"*m}                                 #array of m strings length m, initialized with "|"

def t(u,v,m,r,f)                                       #u,v=top left of current field. r=0..3= quadrant containing O. f=flag to continue surrounding O
  m/=2
  if m==1 then $a[v+1-r/2%2][u,2] ='-+-'[r%2,2];end    #if we are at char level, insert -+ or +- (array already initialized with |'s)
  if m>1 then                                          #at higher level, 4 recursive calls to draw trominoes of next size down 
    4.times{|i| i==r ? t(u+m/2,v+m/2,m,r,0):t(u+i%2*m,v+i/2*m,m,3-i,0)}
    f>0?t(u+r%2*m,v+r/2*m,m,2*$x/m&1|$y*4/m&2,1):0     #then one more call to fill in the empty quadrant (this time f=1)
  end
end

$a[$y][$x]='O'                                         #fill in O
t(0,0,m,2*$x/m&1|$y*4/m&2,1)                           #start call. 2*x/m gives 0/1 for left/right quadrant, similarly 4*y/m gives 0/2 for top/bottom 

puts $a                                                #dump array to stdout, elements separated by newlines.

Level River St
fuente

0

Haskell, 170 bytes

r=reverse
g n s x y|n<1=[s]|x>k=r<$>g n s(2^n+1-x)y|y>k=r$g n s x$2^n+1-y|0<1=zipWith(++)(h s x y++h"-"k 1)$h"|"1 k++h"+"1 1 where m=n-1;k=2^m;h=g m
f n x=unlines.g n"O"x

Corre en línea en Ideone

Ejemplo de ejecución:

*Main> putStr(f 3 3 6)
+--++--+
|+-||-+|
||+--+||
+-|-+|-+
+--+||-+
||O|-+||
|+-||-+|
+--++--+

Anders Kaseorg
fuente

Mosaico de una cuadrícula de 2 ^ N por 2 ^ N con trominos en forma de L