In questa sfida posizionerai le lettere dell'alfabeto su un piano cartesiano e otterrai il risultato come testo.

Il tuo input consisterà in un elenco di elenco con 3 parametri:

• Coordinata X.
• Coordinata Y.
• Corda

Come?

Sappiamo che un piano cartesiano contiene 2 assi $(X, Y)$ e 4 quadranti in cui i segni delle coordinate $(X,Y)$ sono $(+,+)$ , $(−,+)$ , $(−,−)$ e $(+,−)$ . Per esempio

Considera la seguente matrice 3 per 3 come un piano cartesiano

$$\begin{matrix} (-1,1) & (0,1) & (1,1) \\ (-1,0) & (0,0) & (1,0) \\ (-1,-1) & (0,-1) & (1,-1) \end{matrix}$$

Se ci viene fornito nell'input qualcosa di simile alla [[-1,1,L],[0,1,F]]nostra matrice sarà simile a qualcosa di simile

$$\begin{matrix} L & F & (1,1) \\ (-1,0) & (0,0) & (1,0) \\ (-1,-1) & (0,-1) & (1,-1) \end{matrix}$$

E l'output finale LF

Inoltre ci sono alcuni punti che dobbiamo seguire per ottenere l'output corretto:

• Quando una X, Y coord viene ripetuta, dovrai concatenare le stringhe. Esempio: supponiamo che (-1,1) la stringa Fsia posizionata e che sia necessario posizionare la stringa anello stesso punto. Concatenate entrambe le stringhe risultanti Fae questo è il valore che andrà a (-1,1).
• L'output deve essere coerente con la matrice. Esempio immagina questo come risultato finale:

$$\begin{matrix} Ma & r & ie \\ i & s & (1,0) \\ cute & (0,-1) & (1,-1) \end{matrix}$$

Devi produrre

Ma  rie 
i   s       
cute

Perché?

Puoi vederlo come una tabella in cui le colonne sono i valori dell'asse xe le righe dell'asse y.

        Column 1    |   Column 2    |   Column 3
        ----------------------------------------
Row 1   |  "Ma"     |      "r"      |     "ie" 
Row 2   |  "i"      |      "s"      |
Row 3   |  "cute"   |               |

Tutti i valori delle colonne devono avere la stessa lunghezza

        Column 1    |   Column 2    |   Column 3
        ----------------------------------------
Row 1   |  "Ma  "   |      "r"      |     "ie" 
Row 2   |  "i   "   |      "s"      |
Row 3   |  "cute"   |               |

Finalmente abbiamo prodotto il risultato

Ma  rie
i   s
cute

---

Casi test

Input
------------
[[3, 3, "c"]
[4, 1, "un"]
[5, 3, "e"]
[4, 3, "od"]
[4, 2, "lf"]
[1, 2, "go"]
[2, 1, "i"]
[2, 1, "s f"]]

Output
--------------
      code
go     lf 
  is f un

---

Input
--------------
[[0, 0, 's'],
[-1,1, 'M'],
[0, 1, 'r'],
[-1,1, 'a'],
[1, 1, 'i'],
[-1, 0, 'i'],
[1, 1, 'e'],
[-1,- 1, 'c'],
[-1,- 1, 'u'],
[-1, -1, 'te']]

Output.
----------------
Ma  rie
i   s
cute

---

Appunti

• Questo dovrebbe essere un codice-golf
• Puoi racchiudere le coordinate in un unico elenco, ad es [[3, 3], "c"]
• Puoi prendere l'input in qualsiasi formato ragionevole
• Puoi presumere che non ci saranno numeri o spazi vuoti solo nell'input. es. Ci può essere qualcosa di simile a ama mai 1o " "o 1ao1 1

JavaScript (ES8),  186 180  179 byte

Salvato 1 byte grazie a @Shaggy

a=>(g=d=>a.some(([x,y,s])=>(w[x+=d]>(l=((r=o[y=d-y]=o[y]||[])[x]=[r[x]]+s).length)||(w[x]=l),x|y)<0,w=[o=[]])?g(-~d):o.map(r=>w.map((w,x)=>(r[x]||'').padEnd(w)).join``).join`
`)``

Provalo online!

Indici negativi in ​​JS (o la loro mancanza)

Dato un array A[], in JS è perfettamente legale fare qualcosa del genere A[-1] = 5. Tuttavia, ciò non salverà il valore nell'array stesso. Sarà invece implicitamente costringere questo indice negativo di una stringa ( "-1") e impostare la corrispondente struttura in oggetto circostante della matrice.

La cattiva notizia è che le proprietà non sono iterabili con metodi come map():

a = [];
a[1] = 3;
a[-1] = 5;
a.map((v, i) => console.log(v + ' is stored at index ' + i))

Provalo online!

Il codice sopra verrà visualizzato solo 3 is stored at index 1.

Una possibile soluzione alternativa sarebbe:

a = [];
a[1] = 3;
a[-1] = 5;
Object.keys(a).map(k => console.log(a[k] + ' is stored with key ' + k))

Provalo online!

Ma:

• Questo non è molto adatto per il golf.
• Le chiavi non sono ordinate in ordine numerico.

Cosa facciamo qui

$x$$y$

$x$$y$

Ecco cosa facciamo invece:

• $d=0$
• $x$$x+d$$y$$d-y$
• $x<0$$y<0$$d+1$

Python 2 , 188 185 181 181 byte

s=sorted;d={};k={}
for x,y,c in input():d[x]=d.get(x,{});k[~y]=d[x][y]=d[x].get(y,'')+c
for y in s(k):print''.join('%*s'%(-max(map(len,d[x].values())),d[x].get(~y,''))for x in s(d))

Provalo online!

APL (Dyalog Unicode) , ^{SBCS da} 39 byte

Anonimo infisso lambda prendendo * elenchi di coordinate e stringhe come argomenti sinistro e destro.

{⊃,/↑¨↓⌽m⊣m[c],←⍵⊣m←(⊃⌈/c←1+⍺-⌊/⍺)⍴⊂''}

Provalo online!

{... } "dfn"; Gli argomenti left (coordinate) e right (stringhe) sono ⍺e ⍵:

 ⊂'' stringa vuota inclusa, quindi utilizzare come riempimento per un array

 (... )⍴ ciclicamente r eshape in un array delle seguenti dimensioni:

  ⌊/⍺ il valore più basso lungo ciascun asse delle coordinate

  ⍺- sottrarlo da tutte le coordinate

  1+ aggiungilo a uno (poiché vogliamo l'intervallo inclusivo)

  c← negozio a c(per c oordinates)

  ⌈/ il valore più alto lungo ciascun asse di quelli

  ⊃ decomprimere per utilizzarlo come dimensioni

 m← conservare in m(per m atrix)

 ⍵⊣ scartalo a favore delle stringhe

 m[c],← aggiungere quelli a malle coordinatec

 m⊣ scartare quelli a favore degli emendati m

 ⌽ specchio

 ↓ diviso in un elenco di elenchi di stringhe

 ↑¨ mescola ogni elenco di stringhe in una matrice di caratteri, riempiendo gli spazi

 ,/ ridurre per concatenazione orizzontale

 ⊃ scompattare (poiché la riduzione riduce il grado da 1 a 0)

---

^{* Se è necessario prendere un singolo argomento di coordinate e stringhe intrecciate, sarà più lungo di 5 byte.}

05AB1E , 45 44 byte

WsàŸãεUõIvyнXQiyθ«]IZsß->ôεíDéθgjí}øRJʒðKĀ}»

Prende le coordinate di input come un elenco interno.

Provalo online o verifica tutti i casi di test .

Spiegazione:

Wsà           # Get the minimum and maximum of the (implicit) input-list
   Ÿ          # Create a list in the range [min, max]
    ã         # Create each possible pair by taking the cartesian product with itself
ε             # Map each coordinate to:
 U            #  Pop and store the coordinate in variable `X`
 õ            #  Push an empty string ""
  Iv          #  Loop `y` over the input-items:
    yн        #   Get the coordinates of item `y`
      XQi     #   If it's equal to variable `X`:
         yθ   #    Get the string of item `y`
           «  #    Concat it to the (non-)empty string
]             # Close the if-statement, loop, and map
 IZsß         # Get the maximum and minimum of the input-list
     -        # Subtract them from each other
      >       # And increase it by 1
       ô      # Split the list into parts of this size
ε             # Map each part to:
 í            #  Reverse each inner string
  Déθg        #  Get the length of the longest inner string
      j       #  Prepend spaces to each item up to that length
       í      #  And reverse every item back again
              #  (so the spaces are trailing instead of leading)
}ø            # After the map: zip/transpose; swapping rows/columns
  R           # Reverse the entire list
   J          # Join each inner list together to a single string
ʒðKĀ}         # Remove all strings consisting only of spaces
     »        # Join the strings by newlines (and output implicitly)

Carbone , 60 byte

≔Ｅθ§ι¹η≔Ｅθ§ι⁰ζＦ…·⌊ζ⌈ζ«≔Ｅ…·⌊η⌈η⭆θ⎇∧⁼ι§μ⁰⁼κ§μ¹§μ²ωε⮌εＭ⌈ＥεＬκ±Ｌε

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

≔Ｅθ§ι¹η≔Ｅθ§ι⁰ζ

Estrai le coordinate dall'input.

Ｆ…·⌊ζ⌈ζ«

Passa sopra le coordinate x.

≔Ｅ…·⌊η⌈η⭆θ⎇∧⁼ι§μ⁰⁼κ§μ¹§μ²ωε

Scorri le coordinate y, estraendo e concatenando tutte le stringhe in corrispondenza delle coordinate indicate.

⮌ε

Stampa le stringhe in ordine inverso mentre le coordinate y sono invertite rispetto al sistema di coordinate del carbone.

Ｍ⌈ＥεＬκ±Ｌε

Passa all'inizio della colonna successiva.

Perl 5 -p00 -MList::Util=max, 148 byte

s/(\S+) (\S+) (.*)
/$a{$1}=max$a{$1},length($h{$2}{$1}.=$3);''/ge;for$y(sort{$b-$a}keys%h){map{printf"%-$a{$_}s",$h{$y}{$_}}sort{$a-$b}keys%a;say""}

TIO

Come

• s/(\S+) (\S+) (.*) /... ;''/ge;, i flag di sostituzione eseguono il /gloop /eeval, la sostituzione restituisce una variabile di input / default della riga di cancellazione vuota
• $a{$1}=max$a{$1},length($h{$2}{$1}.=$3), autovivifica una mappa% h della mappa il cui primo livello imposta il ysecondo livello xe concatena la stringa $3al valore, ottiene la lunghezza e autoviva una seconda mappa% a le cui chiavi xe valuta la lunghezza massima della colonna (x )
• for$y(sort{$b-$a}keys%h){... ;say""}, per gli indici di riga $yin chiavi di %hordine numerico inverso, say""alla fine per stampare una nuova riga
• map{... }sort{$a-$b}keys%a, per l'indice di colonna $_nelle chiavi% un ordinato numericamente
• printf"%-$a{$_}s",$h{$y}{$_}, stampa la stringa allineata a sinistra con la larghezza della colonna

Pulito , 212 206 byte

import StdEnv,StdLib
? =minList
m=maxList
c=flatten
$a#(x,y,z)=unzip3 a
=flatlines(map c(transpose[[ljustify(m(map length l))k\\l<-[reverse[c[s\\(u,v,s)<-a|u==i&&v==j]\\j<-[?y..m y]]],k<-l]\\i<-[?x..m x]]))

Provalo online!