Neste desafio, você colocará as letras do alfabeto em um plano cartesiano e produzirá o resultado como um texto.

Sua entrada consistirá em uma lista de lista com 3 parâmetros:

• Coordenada X
• Coordenada Y
• Corda

Quão?

Sabemos que um plano cartesiano contém 2 eixos e 4 quadrantes, onde os sinais das coordenadas são , , e . Por exemplo$(X, Y)$$(X,Y)$$(+,+)$$(−,+)$$(−,−)$$(+,−)$

Considere a seguinte matriz 3 por 3 como um plano cartesiano

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

Se formos informados na entrada, algo como [[-1,1,L],[0,1,F]]nossa matriz será semelhante a

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

E a saída final LF

Além disso, há alguns pontos que precisamos seguir para obter a saída correta:

• Quando uma coordenada X, Y é repetida, você precisará concatenar as strings. Exemplo: suponha que em (-1,1) a string Fseja colocada e você precisará colocá-la ano mesmo ponto. Você concatena as duas cadeias resultando Fae esse é o valor que será inserido (-1,1).
• Sua saída precisa ser consistente com a matriz. Exemplo, imagine isso como seu resultado final:

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

Você deve produzir

Ma  rie 
i   s       
cute

Por quê?

Você pode visualizar isso como uma tabela em que as colunas são os valores do eixo x e as linhas o eixo y.

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

Todos os valores das colunas devem ter o mesmo comprimento

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

Por fim, produzimos o resultado

Ma  rie
i   s
cute

---

Casos de teste

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

• Isso deveria ser código-golfe
• Você pode agrupar as coordenadas em uma única lista, por exemplo [[3, 3], "c"]
• Você pode receber a entrada em qualquer formato razoável
• Você pode assumir que não haverá número ou espaços vazios apenas na entrada. Por exemplo, pode haver algo como, a amas nunca 1ou " "ou 1aou1 1

JavaScript (ES8),  186 180  179 bytes

Guardado 1 byte graças 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`
`)``

Experimente online!

Índices negativos em JS (ou a falta deles)

Dada uma matriz A[], é perfeitamente legal em JS fazer algo assim A[-1] = 5. No entanto, isso não salvará o valor na própria matriz. Em vez disso, ele coagirá implicitamente esse índice negativo a uma string ( "-1") e definirá a propriedade correspondente no objeto circundante da matriz.

A má notícia é que as propriedades não são iteráveis ​​com métodos como map():

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

Experimente online!

O código acima será exibido apenas 3 is stored at index 1.

Uma possível solução alternativa seria:

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

Experimente online!

Mas:

• Isto não é muito favorável ao golfe.
• As chaves não são classificadas em ordem numérica.

O que fazemos aqui

$x$$y$

$x$$y$

Aqui está o que fazemos:

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

Experimente online!

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

Infix anônimo lambda usando * listas de coordenadas e seqüências de caracteres como argumentos esquerdo e direito.

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

Experimente online!

{... } "dfn"; os argumentos esquerdo (coordenadas) e direito (cadeias) são ⍺e ⍵:

 ⊂'' cadeia vazia fechada, portanto, use como preenchimento para uma matriz

 (... )⍴ ciclicamente r eshape em uma matriz com as seguintes dimensões:

  ⌊/⍺ o menor valor ao longo de cada eixo das coordenadas

  ⍺- subtrair isso de todas as coordenadas

  1+ adicione isso a um (já que queremos o intervalo inclusivo)

  c← loja em c(para c oordinates)

  ⌈/ o valor mais alto ao longo de cada eixo daqueles

  ⊃ descompacte para usar como dimensões

 m← armazenar em m(para m atrix)

 ⍵⊣ descartar isso em favor das cordas

 m[c],← anexá-los às mcoordenadasc

 m⊣ descartar aqueles a favor da emenda m

 ⌽ espelho

 ↓ dividido em lista de listas de strings

 ↑¨ misture cada lista de strings em uma matriz de caracteres, preenchendo espaços

 ,/ reduzir por concatenação horizontal

 ⊃ descompactar (uma vez que a redução reduz a classificação de 1 para 0)

---

^{* Se for necessário usar um único argumento de coordenadas e cadeias entrelaçadas, serão 5 bytes mais longos.}

05AB1E , 45 44 bytes

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

Toma as coordenadas de entrada como uma lista interna.

Experimente online ou verifique todos os casos de teste .

Explicação:

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)

Carvão , 60 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

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

Extraia as coordenadas da entrada.

Ｆ…·⌊ζ⌈ζ«

Faça um loop sobre as coordenadas x.

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

Faça um loop sobre as coordenadas y, extraindo e concatenando todas as seqüências nas coordenadas fornecidas.

⮌ε

Imprima as strings na ordem inversa, pois as coordenadas y são invertidas em comparação com o sistema de coordenadas do carvão vegetal.

Ｍ⌈ＥεＬκ±Ｌε

Vá para o início da próxima coluna.

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

Quão

• s/(\S+) (\S+) (.*) /... ;''/ge;, sinalizadores de substituição /gloop /eeval, a substituição avalia como entrada de linha de compensação vazia / variável padrão
• $a{$1}=max$a{$1},length($h{$2}{$1}.=$3), autivivifica um mapa% h do mapa cujas chaves de primeiro nível se encontram no ysegundo nível xe concatena a string $3com o valor, obtém o comprimento e obtém automaticamente um segundo mapa% h cujas chaves xe valoriza o comprimento máximo na coluna ( x)
• for$y(sort{$b-$a}keys%h){... ;say""}, para índices de linha $yem chaves de %hordem inversa numericamente, say""no final para imprimir uma nova linha
• map{... }sort{$a-$b}keys%a, para o índice da coluna $_nas chaves% a ordenadas numericamente
• printf"%-$a{$_}s",$h{$y}{$_}, imprima a sequência alinhada à esquerda com a largura da coluna

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

Experimente online!