Poster de primeira vez de muito tempo de lurker aqui.

Escreva um programa com três entradas: X, Y e Z.

• X = do outro lado (colunas)
• Y = para baixo (linhas)
• Z = Marcador de Localização

O programa deve imprimir uma grade visual X transversalmente e Y horizontalmente. Essa grade pode ser composta de qualquer caractere, exceto "+". Cada 'local' recebe um número de índice, contando de 1 na coordenada 1, 1 e depois até o final.

X e Y sempre serão pelo menos 3 e Z nunca será maior que X * Y.

Z representará o local impresso como "+" no local e 1 caractere à esquerda, direita, para cima e para baixo. Por exemplo:

 +
+++
 +

Por fim, se os caracteres + interceptarem as arestas (mais acima, mais à esquerda, mais à direita e / ou mais abaixo), então o + deve saltar ao longo do mesmo eixo e ultrapassar o outro lado.

Exemplos: Entrada = 5, 5, 13

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

Entrada = 10, 10, 10

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

Entrada = 10, 10, 21

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

Edit: exemplo não quadrado 16,3,32

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

Eu acho que cobri tudo. Não deve haver limite para a entrada, mas se o seu programa exigir, limpe-o em 64 * 64.

Ponto de bônus (posso fazer isso?): A entrada Z não deve ser> X * Y, mas se for maior que Y * Z, emita o centro + no meio da grade. EDIT: A entrada Z não pode ser maior que X * Y

Edição 2 :. Fiz algumas alterações em X e Y para, esperamos, ser mais claras

Este é o código de golfe, o código mais curto vence.

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: salvou 1 bytes convertendo para função.

Anterior (mais legível):

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`

Anterior, 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:#^_$$$>:#,_@

Experimente online!

A primeira linha (e uma curta continuação para a segunda linha) é onde os parâmetros são lidos e algumas constantes são calculadas - as coordenadas da localização ( lx , ly ), bem como as coordenadas ajustadas que explicam o retorno da arestas:

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

A segunda e a terceira linhas contêm os loops principais sobre a altura e largura da grade, o caminho da execução indo da direita para a esquerda inicialmente antes de virar para a terceira linha indo da esquerda para a direita. Para cada coordenada na grade ( gx , gy ), calculamos a seguinte condição:

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

Se essa condição for verdadeira, colocamos a "+"na pilha; se falsa, colocamos a "-". Para evitar ramificações aqui, estamos apenas pressionando 43 + 2 * !condition(43 sendo o valor ASCII de mais e 45 sendo menos).

Depois que os loops terminam, o bit final de código é apenas uma rotina de saída padrão que imprime tudo na pilha.

JavaScript (ES6), 170

Ainda jogável

(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 golfe

(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`

Teste

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>