Cartel de la primera vez al acecho por mucho tiempo aquí.

Escriba un programa que tome 3 entradas: X, Y y Z.

• X = a través (columnas)
• Y = abajo (filas)
• Z = marcador de ubicación

El programa debe imprimir una cuadrícula visual X a través e Y hacia abajo. Esta cuadrícula se puede hacer de cualquier carácter, excepto "+". Cada 'ubicación' recibe un número de índice, contando desde 1 en la coordenada 1, 1 a través y luego hacia abajo hasta el final.

X e Y siempre serán al menos 3, y Z nunca será más grande que X * Y.

Z representará la ubicación que se imprime como "+", en la ubicación, así como 1 carácter a la izquierda, derecha, arriba y abajo. Por ejemplo:

 +
+++
 +

Finalmente, si los caracteres + interceptarían los bordes (más arriba, más a la izquierda, más a la derecha y / o más abajo), entonces el + debería rebotar a lo largo del mismo eje y desbordar el otro lado.

Ejemplos: Entrada = 5, 5, 13

-----
--+--
-+++-
--+--
-----

Entrada = 10, 10, 10

-------+++
---------+
---------+
----------
----------
----------
----------
----------
----------
----------

Entrada = 10, 10, 21

----------
+---------
+++-------
+---------
----------
----------
----------
----------
----------
----------

Editar: ejemplo no cuadrado 16,3,32

---------------+
-------------+++
---------------+

Creo que lo he cubierto todo. No debería haber límite para la entrada, pero si su programa lo requiere, limítelo a 64 * 64.

Punto de bonificación (¿puedo hacer eso?): La entrada Z no debe ser> X * Y, pero si es más grande que Y * Z, entonces envíe el centro + al centro de la cuadrícula. EDITAR: la entrada Z no puede ser mayor que X * Y

Edición 2 :. Hice algunos cambios en X e Y para que sea más claro

Este es el código de golf, el código más corto gana.

Python 2, 172 171 bytes

def f(x,y,z):A=[['-']*x for _ in' '*y];z-=1;X,Y=z%x,z/x;a=[2,-1];A[Y][X]=A[Y+a[Y>0]][X]=A[Y-a[Y<y-1]][X]=A[Y][X+a[X>0]]=A[Y][X-a[X<x-1]]='+';print'\n'.join(map(''.join,A))

Editar: guardado 1 bytes mediante la conversión a la función.

Anterior (más legible):

x,y,z=inputtt
A=[['-']*x for _ in' '*y]
z-=1
X,Y=z%x,z/x
a=[2,-1]
A[Y][X]=A[Y+a[Y>0]][X]=A[Y-a[Y<y-1]][X]=A[Y][X+a[X>0]]=A[Y][X-a[X<x-1]]='+'
print'\n'.join(map(''.join,A))

JavaScript (ES6), 165 bytes

(x,y,z,a=[...Array(y)].map(_=>Array(x).fill`-`))=>a.map(a=>a.join``,a[b=--z/x|0][c=z%x]=a[b?b-1:2][c]=a[b][c?c-1:2]=a[y+~b?b+1:y-3][c]=a[b][++c<x?c:x-3]=`+`).join`\n`

Befunge, 175 bytes

>&:10p60p&:00p&1-:10g%:20p\10g/:30p::1+00g-!-\!+2-50p::1+1v
vg02g01*`\4\`0:-g05\!-g03:g00p01-1<g06+p00-1<p04-2+!\-!-g0<
>-!*\10g40g-:0`\4\`**+!2*"+"+10g:#^_$5500g:#^_$$$>:#,_@

Pruébalo en línea!

La primera línea (y una breve continuación de la segunda línea) es donde se leen los parámetros y se calculan algunas constantes: las coordenadas de la ubicación ( lx , ly ), así como las coordenadas ajustadas que explican el rebote del bordes:

ax = lx - (lx+1==w) + (lx==0) - 2 
ay = ly - (ly+1==h) + (ly==0) - 2

La segunda y tercera líneas contienen los bucles principales sobre la altura y el ancho de la cuadrícula, la ruta de ejecución va de derecha a izquierda inicialmente antes de girar hacia la tercera línea de izquierda a derecha. Para cada coordenada en la cuadrícula ( gx , gy ) calculamos la siguiente condición:

(gx==lx && gy>ay && gy<ay+4) || (gy==ly && gx>ax && gx<ax+4)

Si esa condición es verdadera, empujamos a "+"a la pila, si es falso empujamos a "-". Para evitar ramificaciones aquí, en realidad solo estamos presionando 43 + 2 * !condition(43 es el valor ASCII de más y 45 es menos).

Una vez que los bucles han terminado, el bit final de código es solo una rutina de salida estándar que imprime todo en la pila.

JavaScript (ES6), 170

Todavía golfable

(w,h,z,t=--z%w,u=z/w|0,r='-'.repeat(w),S=(f,j)=>(r+f+r).substr(w-j,w))=>[...Array(h)].map((q=u-!!u-!(u+1-h),y)=>y-u?y>=q&y<q+3?S('+',t):r:S('+++',t-!!t-!(t+1-w))).join`
`

Menos golf

(w, h, z
, t=--z%w
, u=z/w|0
, r='-'.repeat(w)
, S=(f,j)=>(r+f+r).substr(w-j,w)
) => [...Array(h)].map(
    (q = u-!!u-!(u+1-h), 
     y) => y-u?y>=q&y<q+3?S('+',t):r:S('+++',t-!!t-!(t+1-w))
).join`\n`

Prueba

F=
(w,h,z,t=--z%w,u=z/w|0,r='-'.repeat(w),S=(f,j)=>(r+f+r).substr(w-j,w))=>[...Array(h)].map((q=u-!!u-!(u+1-h),y)=>y-u?y>=q&y<q+3?S('+',t):r:S('+++',t-!!t-!(t+1-w))).join`
`

function update() {
  var [x,y,z] = I.value.match(/\d+/g)
  O.textContent = F(+x,+y,+z)
}

update()

<input value='5 6 10' oninput='update()' id=I>
<pre id=O>