Langzeit-Lauerer erstmaliges Poster hier.

Schreiben Sie ein Programm mit 3 Eingaben: X, Y und Z.

• X = quer (Spalten)
• Y = unten (Zeilen)
• Z = Ortsmarkierung

Das Programm sollte dann ein visuelles Raster X quer und Y runter drucken. Dieses Gitter kann aus einem beliebigen Zeichen außer "+" bestehen. Jeder 'Ort' erhält eine Indexnummer, die von 1 an Koordinate 1, 1 quer und dann bis zum Ende nach unten zählt.

X und Y werden immer mindestens 3 sein und Z wird niemals größer sein als X * Y.

Z steht für die Position, die als "+" auf der Position gedruckt wird, sowie für 1 Zeichen links, rechts, oben und unten. Zum Beispiel:

 +
+++
 +

Wenn die + Zeichen die Kanten abfangen würden (ganz oben, ganz links, ganz rechts und / oder ganz unten), sollte das + entlang derselben Achse zurückprallen und die andere Seite überlaufen.

Beispiele: Eingabe = 5, 5, 13

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

Eingabe = 10, 10, 10

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

Eingabe = 10, 10, 21

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

Bearbeiten: nicht quadratisches Beispiel 16,3,32

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

Ich glaube, ich habe alles abgedeckt. Die Eingabe sollte unbegrenzt sein. Wenn Ihr Programm dies erfordert, können Sie sie auf 64 * 64 begrenzen.

Bonuspunkt (kann ich das tun?): Eingabe Z sollte nicht> X * Y sein, aber wenn es größer als Y * Z ist, geben Sie die Mitte + in die Mitte des Gitters aus. BEARBEITEN: Eingang Z darf nicht größer als X * Y sein

Edit 2:. Einige Änderungen an X und Y vorgenommen, um hoffentlich klarer zu werden

Dies ist Code Golf, kürzester Code gewinnt.

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

Bearbeiten: 1 Byte durch Konvertierung in Funktion gespeichert.

Zurück (besser lesbar):

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 Byte

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

Probieren Sie es online aus!

In der ersten Zeile (und einer kurzen Fortsetzung der zweiten Zeile) werden die Parameter eingelesen und einige Konstanten berechnet - die Koordinaten des Ortes ( lx , ly ) sowie angepasste Koordinaten, die für das Abprallen der Position verantwortlich sind Kanten:

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

Die zweite und dritte Zeile enthalten die Hauptschleifen über die Höhe und Breite des Gitters, wobei der Ausführungspfad zunächst von rechts nach links verläuft, bevor auf die dritte Zeile von links nach rechts gedreht wird. Für jede Koordinate im Gitter ( gx , gy ) berechnen wir die folgende Bedingung:

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

Wenn diese Bedingung wahr ist, drücken wir a "+"auf den Stapel, wenn false, drücken wir a "-". Um eine Verzweigung hier zu vermeiden, drücken wir wirklich nur 43 + 2 * !condition(43 ist der ASCII-Wert von plus und 45 ist minus).

Sobald die Schleifen beendet sind, ist das letzte Codebit nur eine Standardausgaberoutine, die alles auf dem Stapel druckt.

JavaScript (ES6), 170

Immer noch golfbar

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

Weniger Golf gespielt

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

Prüfung

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>