En este desafío, colocará letras del alfabeto en un plano cartesiano y mostrará el resultado como un texto.

Su entrada consistirá en una lista de lista con 3 parámetros:

• Coordenada X
• Coordenada Y
• Cuerda

¿Cómo?

Sabemos que un plano cartesiano contiene 2 ejes $(X, Y)$ y 4 cuadrantes donde los signos de las coordenadas $(X,Y)$ son $(+,+)$ , $(−,+)$ , $(−,−)$ y $(+,−)$ . Por ejemplo

Considere la siguiente matriz 3 por 3 como un plano cartesiano

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

Si se nos da en la entrada, algo así como [[-1,1,L],[0,1,F]]nuestra matriz se verá similar a

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

Y la salida final LF

Además de eso, hay algunos puntos que debemos seguir para obtener la salida correcta:

• Cuando se repite una coordenada X, Y, deberá concatenar las cadenas. Ejemplo: suponga que en (-1,1) Fse coloca la cadena y necesita colocarla aen el mismo punto. Concatena ambas cadenas que resultan en Fay ese es el valor que irá en (-1,1).
• Su salida debe ser coherente con la matriz. Ejemplo imagina esto como tu resultado final:

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

Debe salida

Ma  rie 
i   s       
cute

¿Por qué?

Puede ver esto como una tabla donde las columnas son los valores del eje xy las filas el eje y.

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

Todos los valores de las columnas deben tener la misma longitud.

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

Finalmente sacamos el resultado

Ma  rie
i   s
cute

---

Casos de prueba

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

---

Notas

• Se supone que esto es código golf
• Puede ajustar las coordenadas en una sola lista, por ejemplo [[3, 3], "c"]
• Puede tomar la entrada en cualquier formato razonable
• Puede suponer que no habrá ningún número o espacios vacíos solo en la entrada. Por ejemplo, puede haber algo como a apero nunca 1o " "o 1ao1 1

JavaScript (ES8),  186 180  179 bytes

Guardado 1 byte gracias 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`
`)``

Pruébalo en línea!

Índices negativos en JS (o la falta de ellos)

Dada una matriz A[], es perfectamente legal en JS hacer algo así A[-1] = 5. Sin embargo, esto no guardará el valor en la matriz misma. En cambio, obligará implícitamente este índice negativo a una cadena ( "-1") y establecerá la propiedad correspondiente en el objeto circundante de la matriz.

La mala noticia es que las propiedades no son iterables con métodos como map():

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

Pruébalo en línea!

El código anterior solo mostrará 3 is stored at index 1 .

Una posible solución sería:

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

Pruébalo en línea!

Pero:

• Esto no es muy amigable para el golf.
• Las claves no están ordenadas en orden numérico.

Que hacemos aqui

$x$$y$ para evitar los problemas descritos anteriormente.

$x$$y$ . Pero eso sería bastante largo.

Esto es lo que hacemos en su lugar:

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

Python 2 , 188 185 181 bytes

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

Pruébalo en línea!

APL (Dyalog Unicode) , ^{SBCS de} 39 bytes

Infix lambda anónimo tomando * listas de coordenadas y cadenas como argumentos izquierdo y derecho.

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

Pruébalo en línea!

{... } "dfn"; Los argumentos izquierdo (coordenadas) y derecho (cadenas) son ⍺y ⍵:

 ⊂'' cadena vacía cerrada, así que úsela como relleno para una matriz

 (... )⍴ cíclicamente r eshape en una matriz de las siguientes dimensiones:

  ⌊/⍺ el valor más bajo a lo largo de cada eje de las coordenadas

  ⍺- restar eso de todas las coordenadas

  1+ agregue eso a uno (ya que queremos el rango inclusivo)

  c← tienda en c(para c oordinates)

  ⌈/ el valor más alto a lo largo de cada eje de esos

  ⊃ desempaquetar para usar como dimensiones

 m← almacenar en m(para m atrix)

 ⍵⊣ descartar eso a favor de las cuerdas

 m[c],← agregarlos a mlas coordenadasc

 m⊣ descartar a los partidarios de la enmienda m

 ⌽ espejo

 ↓ dividido en una lista de listas de cadenas

 ↑¨ mezcle cada lista de cadenas en una matriz de caracteres, rellenando con espacios

 ,/ reducir por concatenación horizontal

 ⊃ desempaquetar (ya que la reducción reduce el rango de 1 a 0)

---

^{* Si se requiere tomar un solo argumento de coordenadas y cadenas entrelazadas, será 5 bytes más largo.}

05AB1E , 45 44 bytes

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

Toma las coordenadas de entrada como una lista interna.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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)

Carbón , 60 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

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

Extraer las coordenadas de la entrada.

Ｆ…·⌊ζ⌈ζ«

Pase sobre las coordenadas x.

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

Pase sobre las coordenadas y, extrayendo y concatenando todas las cadenas en las coordenadas dadas.

⮌ε

Imprima las cadenas en orden inverso a medida que las coordenadas y se invierten en comparación con el sistema de coordenadas de carbón.

Ｍ⌈ＥεＬκ±Ｌε

Ir al inicio de la siguiente columna.

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

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

Cómo

• s/(\S+) (\S+) (.*) /... ;''/ge;, las banderas de sustitución evalúan el /gbucle /e, el reemplazo se evalúa como entrada vacía de la línea de compensación / variable predeterminada
• $a{$1}=max$a{$1},length($h{$2}{$1}.=$3), autovivifica un mapa% h del mapa cuyas claves de primer nivel ysegundo nivel xy concatena la cadena $3al valor, obtiene la longitud y autovivifica un segundo mapa% a cuyas teclas xy valor el máximo de longitud sobre la columna ( x)
• for$y(sort{$b-$a}keys%h){... ;say""}, para los índices de fila $yen claves de orden %hnumérico inverso, say""al final para imprimir una nueva línea
• map{... }sort{$a-$b}keys%a, para el índice de columna $_en claves% a ordenado numéricamente
• printf"%-$a{$_}s",$h{$y}{$_}, imprimir cadena alineada a la izquierda con ancho de columna

Limpio , 212 206 bytes

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

Pruébalo en línea!