Affiche pour la première fois depuis longtemps.

Écrivez un programme qui prend 3 entrées: X, Y et Z.

• X = sur (colonnes)
• Y = bas (lignes)
• Z = marqueur de position

Le programme doit ensuite imprimer une grille visuelle X en travers et Y en bas. Cette grille peut être composée de n'importe quel caractère sauf "+". Chaque «emplacement» reçoit un numéro d'index, en comptant à partir de 1 à la coordonnée 1, 1 à travers puis en descendant jusqu'à la fin.

X et Y seront toujours au moins 3, et Z ne sera jamais plus grand que X * Y.

Z représentera l'emplacement qui est imprimé en "+", sur l'emplacement ainsi que 1 caractère à gauche, à droite, en haut et en bas. Par exemple:

 +
+++
 +

Enfin, si les caractères + interceptent les bords (le plus haut, le plus à gauche, le plus à droite et / ou le plus bas), alors le + devrait rebondir le long du même axe et déborder de l'autre côté.

Exemples: entrée = 5, 5, 13

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

Entrée = 10, 10, 10

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

Entrée = 10, 10, 21

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

Edit: exemple non carré 16,3,32

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

Je pense que j'ai tout couvert. Il ne devrait y avoir aucune limite à l'entrée, mais si votre programme l'exige, limitez-le à 64 * 64.

Point bonus (est-ce que je peux faire ça?): L' entrée Z ne doit pas être> X * Y, mais si elle est plus grande que Y * Z, alors sortez le centre + au milieu de la grille. EDIT: l' entrée Z ne peut pas être supérieure à X * Y

Modifier 2:. Apporté quelques changements à X et Y pour être plus clair, espérons

C'est le golf de code, le code le plus court gagne.

Python 2, 172 171 octets

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

Edit: sauvé 1 octets en le convertissant en fonction.

Précédent (plus lisible):

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 octets

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

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

Essayez-le en ligne!

La première ligne (et une courte continuation sur la deuxième ligne) est l'endroit où les paramètres sont lus et quelques constantes sont calculées - les coordonnées de l'emplacement ( lx , ly ), ainsi que les coordonnées ajustées qui tiennent compte du rebond sur le bords:

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

Les deuxième et troisième lignes contiennent les boucles principales sur la hauteur et la largeur de la grille, le chemin d'exécution allant de droite à gauche au départ avant de tourner sur la troisième ligne de gauche à droite. Pour chaque coordonnée de la grille ( gx , gy ), nous calculons la condition suivante:

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

Si cette condition est vraie, nous poussons a "+"sur la pile, si faux nous poussons a "-". Pour éviter la ramification ici, nous poussons vraiment 43 + 2 * !condition(43 étant la valeur ASCII de plus et 45 étant moins).

Une fois les boucles terminées, le dernier bit de code n'est plus qu'une routine de sortie standard qui imprime tout sur la pile.

JavaScript (ES6), 170

Toujours jouable au 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`
`

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

Tester

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>