Dans ce défi, vous allez placer des lettres de l'alphabet dans un plan cartésien et produire le résultat sous forme de texte.

Votre saisie consistera en une liste de liste avec 3 paramètres:

• Coordonnée X
• Coordonnée Y
• Chaîne

Comment?

Nous savons qu'un plan cartésien contient 2 axes $(X, Y)$ et 4 quadrants où les signes des coordonnées $(X,Y)$ sont $(+,+)$ , $(−,+)$ , $(−,−)$ et $(+,−)$ . Par exemple

Considérez la matrice 3 x 3 suivante comme un plan cartésien

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

Si on nous donne en entrée quelque chose comme [[-1,1,L],[0,1,F]] notre matrice ressemblera à quelque chose

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

Et la sortie finale LF

En plus de cela, nous devons suivre certains points pour obtenir la sortie correcte:

• Lorsqu'une coordonnée X, Y est répétée, vous devrez concaténer les chaînes. Exemple: supposons dans (-1,1) la chaîneF est placée et vous devez placer la chaîne aau même point. Vous concaténez les deux chaînes résultant en Faet c'est la valeur qui ira dans (-1,1).
• Votre sortie doit être cohérente avec la matrice. Exemple imaginez ceci comme votre résultat final:

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

Vous devez sortir

Ma  rie 
i   s       
cute

Pourquoi?

Vous pouvez le voir comme un tableau où les colonnes sont les valeurs de l'axe des x et les lignes de l'axe des y.

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

Toutes les valeurs des colonnes doivent avoir la même longueur

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

Enfin, nous sortons le résultat

Ma  rie
i   s
cute

---

Cas de 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

---

Remarques

• C'est censé être code-golf
• Vous pouvez envelopper les coordonnées dans une seule liste, par exemple [[3, 3], "c"]
• Vous pouvez prendre l'entrée dans n'importe quel format raisonnable
• Vous pouvez supposer qu'il n'y aura pas de nombre ou d'espaces vides uniquement dans l'entrée. Par exemple, il peut y avoir quelque chose comme a amais jamais 1ou " "ou 1aou1 1

JavaScript (ES8),  186180  179 octets

1 octet enregistré grâce à @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`
`)``

Essayez-le en ligne!

Indices négatifs dans JS (ou leur absence)

Étant donné un tableau A[], il est parfaitement légal dans JS de faire quelque chose comme A[-1] = 5. Cependant, cela n'enregistrera pas la valeur dans le tableau lui-même. Au lieu de cela, il contraindra implicitement cet index négatif à une chaîne ( "-1") et définira la propriété correspondante dans l' objet environnant du tableau.

La mauvaise nouvelle est que les propriétés ne sont pas itérables avec des méthodes telles que map():

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

Essayez-le en ligne!

Le code ci-dessus s'affiche uniquement 3 is stored at index 1.

Une solution de contournement possible serait:

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

Essayez-le en ligne!

Mais:

• Ce n'est pas très adapté au golf.
• Les clés ne sont pas triées dans l'ordre numérique.

Ce que nous faisons ici

Nous voulons vraiment travailler avec des valeurs positives des deux $x$ et $y$ afin d'éviter les problèmes décrits ci-dessus.

Nous pourrions faire un premier passage sur les données, en recherchant la valeur minimale de $x$ et la valeur minimale de $y$. Mais ce serait assez long.

Voici ce que nous faisons à la place:

• nous commençons par $d=0$
• nous traitons une itération où $x$ est remplacé par $x+d$ et $y$ est remplacé par $d-y$
• si nous avons soit $x<0$ ou $y<0$ pour toute entrée, nous abandonnons et commençons récursivement une autre tentative avec $d+1$

Python 2 , 188 185 181 181 octets

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

Essayez-le en ligne!

APL (Dyalog Unicode) , 39 octets ^SBCS

Infixe anonyme lambda prenant * des listes de coordonnées et de chaînes comme arguments gauche et droit.

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

Essayez-le en ligne!

{… } "Dfn"; les arguments gauche (coordonnées) et droite (chaînes) sont ⍺et ⍵:

 ⊂'' chaîne vide incluse, donc utilisez comme remplissage pour un tableau

 (... de )⍴ manière cyclique r Eshape dans un tableau de dimensions suivantes:

  ⌊/⍺ la valeur la plus basse le long de chaque axe des coordonnées

  ⍺- soustrayez cela de toutes les coordonnées

  1+ ajouter cela à un (puisque nous voulons la gamme inclusive)

  c← Magasin à c(pour c oordinates)

  ⌈/ la valeur la plus élevée le long de chaque axe de ceux

  ⊃ déballer pour utiliser comme dimensions

 m← stocker m(pour m atrix)

 ⍵⊣ jeter cela au profit des cordes

 m[c],← ajouter ceux-ci aux mcoordonnéesc

 m⊣ jeter ceux qui sont en faveur de l'amendement m

 ⌽ miroir

 ↓ divisé en liste de listes de chaînes

 ↑¨ mélanger chaque liste de chaînes dans une matrice de caractères, en remplissant les espaces

 ,/ réduire par concaténation horizontale

 ⊃ décompresser (puisque la réduction réduit le rang de 1 à 0)

---

^{* Si la prise d'un seul argument de coordonnées et de chaînes entrelacées est requise, elle sera de 5 octets de plus.}

05AB1E , 45 44 octets

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

Prend les coordonnées d'entrée comme une liste intérieure.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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)

Charbon de bois , 60 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

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

Extrayez les coordonnées de l'entrée.

Ｆ…·⌊ζ⌈ζ«

Boucle sur les coordonnées x.

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

Boucle sur les coordonnées y, extrayant et concaténant toutes les chaînes aux coordonnées données.

⮌ε

Imprimez les chaînes dans l'ordre inverse car les coordonnées y sont inversées par rapport au système de coordonnées de Charcoal.

Ｍ⌈ＥεＬκ±Ｌε

Passez au début de la colonne suivante.

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

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

Comment

• s/(\S+) (\S+) (.*) /... ;''/ge;, les drapeaux de substitution évaluent la /gboucle /e, le remplacement est évalué comme entrée de ligne de compensation vide / variable par défaut
• $a{$1}=max$a{$1},length($h{$2}{$1}.=$3), active automatiquement une carte% h de carte dont le premier niveau définit le ydeuxième niveau xet concatène la chaîne $3à la valeur, obtient la longueur et active une deuxième carte% a dont les clés xet la valeur maximale de la longueur sur la colonne ( x)
• for$y(sort{$b-$a}keys%h){... ;say""}, pour les index des lignes $ydans les clés de %htri numérique inversé, say""à la fin pour imprimer une nouvelle ligne
• map{... }sort{$a-$b}keys%a, pour l'index des colonnes $_dans les clés% a triées numériquement
• printf"%-$a{$_}s",$h{$y}{$_}, imprimer la chaîne alignée à gauche avec la largeur de la colonne

Nettoyer , 212 206 octets

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

Essayez-le en ligne!