Défi:

Étant donné une liste de chaînes multi-lignes, superposez-les (en haut à gauche) et affichez le résultat.

Exemple:

Entrée: ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
Sortie:

cbaa
bbaa
bbaa
aaaa

Règles du défi:

• Le format d'entrée est flexible. Vous êtes autorisé à obtenir l'entrée sous la forme d'une liste 2D de lignes (ie [["aaaa","aaaa","aaaa","aaaa"],["bb","bb","bb"],["c"]]) ou d'une liste 3D de caractères (ie [[["a","a","a","a"],["a","a","a","a"],["a","a","a","a"],["a","a","a","a"]],[["b","b"],["b","b"],["b","b"]],[["c"]]]). Vous êtes autorisé à prendre toutes les entrées une par une via STDIN. Etc.
• Le format de sortie est strict. Vous pouvez choisir d'imprimer ou de renvoyer la chaîne multiligne. (Si votre langue n'a pas de chaînes, la sortie sous forme de liste 2D de caractères est autorisée comme alternative. Mais uniquement si votre langue n'a pas de chaînes du tout.)
• L'ordre de la liste d'entrées est bien sûr important (mais vous pouvez prendre l'entrée en sens inverse si vous le souhaitez).
• Les entrées ne contiendront que de l'ASCII imprimable dans la plage unicode $[33,126]$ ( !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~).
• Les entrées ne seront que des rectangles (donc pas de formes étranges). Cependant, la sortie n'est pas un rectangle nécessaire.
• Les espaces de fin et une seule nouvelle ligne de fin sont autorisés. Espaces de tête et / ou nouvelles lignes non.

Règles générales:

• C'est du code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse avec des règles d'E / S défaut , vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code (par exemple TIO ).
• De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

Cas de test:

Entrée: ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
Sortie:

cbaa
bbaa
bbaa
aaaa

Entrée: ["12345\n54321","00\n00\n00\n00","001\n011\n012"]
Sortie:

00145
01121
012
00

Entrée: ["sm\noo\nmr\nee\nt!\nh_\ni_\nn_\ng_","!@#$%^\n&*()_+\nqwerty\nuiopas","this\nis_a\ntest"]
Sortie:

this%^
is_a_+
testty
uiopas
t!
h_
i_
n_
g_

Gelée , 3 octets

a/Y

Essayez-le en ligne!

Je n'avais pas utilisé Jelly depuis un moment mais je pensais que le défi dans les commentaires était battable. Utilise très directement logique et ( a) pour effectuer l'opération d'empilement entre chaque élément de l'entrée ( /). Yest utilisé pour imprimer dans le format requis.

JavaScript (Node.js) , 24 octets

Sauvegardé 2 octets grâce à @Grimy

Suppose que la chaîne renvoyée est imprimée sur un terminal qui prend en charge les codes d'échappement ANSI . Contient le caractère non imprimable ESC, qui est échappé (sans jeu de mots) comme \x1Bci-dessous.

a=>`\x1B[2J\x1B[H`+a.join`\x1B[H`

Cela ne fonctionne pas sur TIO, mais vous pouvez l' essayer en ligne! pour voir la sortie brute à la place.

Comment?

Les séquences CSI utilisées sont:

• ED (Effacer à l'écran):

  ESC[2J

  où $2$ signifie "effacer tout l'écran"

• CUP (position du curseur):

  ESC[H

  ce qui signifie "déplace le curseur sur la ligne $n$ , colonne $m$ " où $n$ et $m$ sont omis et définis implicitement sur $1$ (coin supérieur gauche de l'écran).

Exemple de sortie

R , 120 , 111 110 107 octets

function(x,`!`=ncol,M=array('',Reduce(pmax,Map(dim,x)))){for(m in x)M[1:!t(m),1:!m]=m
write(t(M),1,!M,,'')}

Essayez-le en ligne!

Une fonction acceptant une liste de matrice de caractères (la saisie 3D est acceptée).

(comme vous pouvez le constater à partir du nombre d'octets, ce n'est pas très facile à faire dans R ...)

• -9 octets grâce à @Giuseppe
• -4 octets grâce à @RobinRyder

Python 2 , 88 octets

n,f=None,filter
for l in map(n,*input()):print''.join(f(n,x)[-1]for x in map(n,*f(n,l)))

Essayez-le en ligne!

Explication (avec exemple):

Prend une liste 2D en entrée.

Input: [["12345","54321"],["00","00","00","00"],["001","011","012"]]

D'abord, la liste d'entrée est zippée, pour obtenir les lignes de chaque rectangle d'entrée ( map(None,l)est la même une plus longue zip):

map(n,*input())   gives:

('12345', '00', '001')
('54321', '00', '011')
(None, '00', '012')
(None, '00', None)

Chacune de ces lignes est ensuite filtrée en Nones supprimés et zippée à nouveau:

map(None,*filter(None,l))

filter(None,l) for each l gives:

('12345', '00', '001')
('54321', '00', '011')
('00', '012')
('00',)

map*... gives:

[('1', '0', '0'), ('2', '0', '0'), ('3', None, '1'), ('4', None, None), ('5', None, None)]
[('5', '0', '0'), ('4', '0', '1'), ('3', None, '1'), ('2', None, None), ('1', None, None)]
[('0', '0'), ('0', '1'), (None, '2')]
['0', '0']

C'est une liste de caractères pour chaque position du résultat souhaité. Ces listes sont à nouveau filtrées et la dernière est prise:

filter(None,x)   gives:

[('1', '0', '0'), ('2', '0', '0'), ('3', '1'), ('4',), ('5',)]
[('5', '0', '0'), ('4', '0', '1'), ('3', '1'), ('2',), ('1',)]
[('0', '0'), ('0', '1'), ('2',)]
['0', '0']

and with [-1]:

['0', '0', '1', '4', '5']
['0', '1', '1', '2', '1']
['0', '1', '2']
['0', '0']

Enfin, les listes résultantes sont jointes et imprimées:

print''.join(..)

00145
01121
012
00

R, 107 97 octets

function(x)for(i in 1:max(lengths(x))){for(m in x)if(i<=length(m))cat(m[i],'\r',sep='');cat('
')}

Ne semble pas fonctionner sur TIO, ce qui pourrait être lié à l'utilisation du \r caractère de retour chariot. Cela fonctionne sur mon installation locale de R.

Prend l'entrée comme une liste contenant un vecteur de lignes:

x <- list(c("aaaa","aaaa","aaaa","aaaa"),c("bb","bb","bb"),c("c"))

Boucles sur les lignes de chaque rectangle, imprimant un retour chariot après chaque, redémarrant la ligne.

Si nous étirons un peu les règles, nous pouvons éliminer la vérification de la longueur de l'entrée et boucler à l'infini, en imprimant une énorme quantité de nouvelles lignes:

R, 85 octets

function(x)for(i in 1:8e8){for(m in x)if(i<=length(m))cat(m[i],'\r',sep='');cat('
')}

APL (Dyalog Unicode) , 22 octets ^SBCS

Fonction de préfixe tacite anonyme prenant comme argument la liste des tableaux de caractères 2D. Impressions.

(⊃{⍺@(⍳⍴⍺)⊢⍵}/)⌽,∘⊂1⌷↑

Essayez-le en ligne!

Cela fonctionne en créant un canevas, puis en l'ajoutant à la liste des blocs et en réduisant (pliant) avec une fonction qui place les blocs dans le coin.

↑ mélanger le bloc 2D pour créer un bloc 3D orthogonal, en les remplissant d'espaces au besoin

1⌷ prendre la première couche

⊂ joindre qui
 ∘ ensuite
⌽, ajouter la liste inversée des blocs

(… ) Appliquez la fonction tacite suivante:

 {… }/ Réduisez en utilisant le lambda anonyme suivant:

  ⊢⍵ avec le bon argument comme toile…

  ⍺@(… ) Modifier avec les éléments de l'argument de gauche, placés aux indices suivants:

   ⍴⍺ la forme de l'argument de gauche

   ⍳ les ɩ ndices d'un tableau de cette forme

 ⊃ divulguer (parce que la réduction incluse pour réduire le rang)

Haskell, 66 octets

unlines.foldl((const?)?)[]
(g?(a:b))(c:d)=g a c:(g?b)d;(_?a)b=a++b

L' entrée est considérée comme une liste de la liste des chaînes dans l' ordre inverse, par exemple pour le premier test: [["c"],["bb","bb","bb"],["aaaa","aaaa","aaaa","aaaa"]].

Essayez-le en ligne!

05AB1E , 12 octets

Port de la solution python de TFeld
2 octets économisés grâce à Grimy

ζεðKζðδK€θJ,

Essayez-le en ligne!

Explication

ζ             # transpose input with space as filler
 ε            # apply to each
  ðK          # remove spaces
    ζ         # transpose with space as filler
     ðδK      # deep remove spaces
        €θ    # get the tail of each
          J   # join each
           ,  # print

Version alternative à 14 octets

õζεÅ»DŠg.$J}θ,

Essayez-le en ligne!

Explication

õζ              # zip with empty string as filler
  ε             # apply to each
   Å»      }    # cumulative reduce by
     D          # duplicate second input
      Š         # move down twice on stack
       g.$      # remove len(other_copy) elements from the other input
          J     # join with other copy
            θ,  # print the last element

Canevas , 5 octets

Ｈ１１╋╋

Essayez-le ici!

Si le chevauchement de /+ \→ X, -+ |→ +, etc. convenait, 2 octets fonctionneraient.

Python 2 , 77 octets

for t in map(None,*input()):
 r=''
 for s in t:
	if s:r=s+r[len(s):]
 print r

Essayez-le en ligne!

PowerShell 6 , console uniquement, 20 octets

basé sur Arnauld réponse . Cela fonctionne uniquement avec la console et ne fonctionne pas sur TIO.

cls
$args-join"`e[H"

Essayez-le en ligne!

PowerShell , 103 octets

$args|%{$l=$_-split'
';$r=&{$r+($l|%{''})|%{($x=$l[$j++])+($_-replace"^.{0,$("$x"|% Le*)}")}|?{$_}}}
$r

Essayez-le en ligne!

Déroulé:

$args|%{
    $l=$_-split"`n"
    $r=&{                           # run this scriptblock in a new scope
        $r+($l|%{''})|%{
            $x=$l[$j++]             # a new line or $null
            $w="$x"|% Length
            $y=$_-replace"^.{0,$w}" # remove first chars from the current line
            $x+$y                   # output the new line plus tail of the overlapped line
        }|?{$_}                     # filter out not empty lines only
    }                               # close the scope and remove all variables created in the scope
}
$r

C # (.NET Core) , 68 + 23 = 91 octets

n=>{C.Clear();n.ForEach(k=>{C.SetCursorPosition(0,0);C.Write(k);});}

23 octets pour l'importation, using C=System.Console;

Ne fonctionne pas dans TIO, car ce n'est pas une console.

Essayez-le en ligne!

Rubis , 67 octets

L'entrée est une liste de lignes. Construit une liste de lignes et écrase tout au long des entrées, puis les joint avec une nouvelle ligne (représentée par la variable $/) à la fin pour correspondre à la sortie stricte.

->i,*r{i.map{|e|j=-1;e.map{|l|r[j+=1]||='';r[j][0,l.size]=l}};r*$/}

Essayez-le en ligne!

C (GCC, MinGW) 138 octets

Suppose que CR place le curseur au début de la ligne actuelle.

d,i,l;f(S,n,p,t)char**S,*p,*t;{for(d=i=0;i<n;d+=l)p=strchr(t=S[i],10),printf("\n%.*s\r"+!!i,l=p?p-t:strlen(t),t),S[i++]+=l+!!p;d&&f(S,n);}

Testé avec:

int main()
{
    char *test1[] = {"aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"};
    char *test2[] = {"12345\n54321","00\n00\n00\n00","001\n011\n012"};
    char *test3[] = {"sm\noo\nmr\nee\nt!\nh_\ni_\nn_\ng_","!@#$%^\n&*()_+\nqwerty\nuiopas","this\nis_a\ntest"};

    f(test1, 3);
    f(test2, 3);
    f(test3, 3);
}

Octave , 71 67 octets

function y=f(x)
for k=1:size(x)
y(1:(t=size(x{k})),1:t(2))=x{k};end

Fonction qui prend un tableau de cellules verticales de matrices de caractères et renvoie une matrice de caractères.

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

Javascript (navigateur) , 216 208 204 octets

Ma tentative. Je ne suis pas content de la taille, et il doit certainement y avoir plus à améliorer, mais je ne suis pas très expérimenté au golf.

var n='\n',x=s=>s.split``.reverse().join``,i,j,f=a=>a.map(s=>s.split(n).map(y=>x(y))).reduce((a,b)=>{for(i=0;i<b.length;i++){j=a[i];if(!j)j=b[i];a[i]=b[i].padStart(j.length,j)}return a}).map(s=>x(s)).join(n)

Quoi qu'il en soit, ce qu'il fait est d'abord de diviser toutes les chaînes, puis d'inverser toutes les chaînes, puis tout en bouclant dans un pad d' opération de réduction toutes les chaînes ensemble. Ensuite, inversez à nouveau toutes les chaînes, puis joignez-les à nouveau avec des nouvelles lignes.

Un merci spécial à Kevin Cruijssen pour m'avoir rappelé que la dernière partie d'une boucle for se produit à la fin et une économie d'octets totale de 8 octets.

var n='\n',x=s=>s.split``.reverse().join``,i,j,f=a=>a.map(s=>s.split(n).map(y=>x(y))).reduce((a,b)=>{for(i=0;i<b.length;a[i]=b[i++].padStart(j.length,j))if(!(j=a[i]))j=b[i];return a}).map(s=>x(s)).join(n)

console.log(f(["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]));
console.log(f(["12345\n54321","00\n00\n00\n00","001\n011\n012"]));
console.log(f(["sm\noo\nmr\nee\nt!\nh_\ni_\nn_\ng_","!@#$%^\n&*()_+\nqwerty\nuiopas","this\nis_a\ntest"]));

C (gcc) , 51 47 octets

f(char**s){for(;*s;printf("\e[s%s\e[u",*s++));}

Essayez-le en ligne!

-4 octets grâce au plafond.

Utilise les séquences CSI pour enregistrer / restaurer la position du curseur. Itère simplement sur le tableau de chaînes passé (au même format que argv) et imprime<save position>string<restore position> pour chacun.

Cela laisse le curseur en haut à gauche, donc lors de l'exécution sur le terminal, il est important de laisser suffisamment de nouvelles lignes par la suite pour que l'invite n'encombre pas l'entrée.

Japt -P , 7 octets

Prend l'entrée comme un tableau de chaînes multi-lignes, produit une seule chaîne multi-lignes.

ú y_¸¬Ì

Essayez-le

ú y_¸¬Ì     :Implicit input of array
ú           :Right pad each line of each element with spaces to the length of the longest
  y         :Transpose
   _        :Map
    ¸       :  Split on spaces
     ¬      :  Join
      Ì     :  Last character
            :Implicitly join and output

Requête T-SQL, 297 295 octets

Utiliser ¶ comme séparateur et une variable de table comme entrée.

DECLARE @ table(a varchar(max),k int identity(1,1))
INSERT @ values('aaaa¶aaaa¶aaaa¶aaaa'),('bb¶bv¶bb'),('c');

WITH c as(SELECT k,row_number()over(partition
by k order by k)s,value v FROM @ CROSS APPLY
string_split(a,'¶')s),m(i,l,e)as(SELECT*FROM c
WHERE k=1UNION ALL
SELECT k,s,STUFF(e,1,len(v),v)FROM m
JOIN c ON-~i=k and s=l)SELECT
top 1with ties e FROM m
ORDER BY rank()over(partition by l order by-i)

Essayez-le en ligne

Javascript (navigateur), 129 124 octets

Ma première tentative de golf de code. J'ai lu les liens donnés dans les règles (failles, règles standard ...), donc j'espère avoir fait quelque chose de mal!

J'ai conservé les entrées telles qu'elles sont dans le premier message (sous forme de tableau plat).

_=o=>{o=o.map(i=>i.split`\n`),r=o.shift();for(a of o)for(l in a)b=a[l],r[l]=r[l]?b+r[l].slice(b.length):b;return r.join`\n`}

Merci à Kevin Cruijssen d' avoir économisé 5 octets.

Tests:

_=o=>{o=o.map(i=>i.split`\n`),r=o.shift();for(a of o)for(l in a)b=a[l],r[l]=r[l]?b+r[l].slice(b.length):b;return r.join`\n`}

console.log(_(["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]));
console.log(_(["12345\n54321","00\n00\n00\n00","001\n011\n012"]));
console.log(_(["sm\noo\nmr\nee\nt!\nh_\ni_\nn_\ng_","!@#$%^\n&*()_+\nqwerty\nuiopas","this\nis_a\ntest"]));

Pyth , 18 octets

L.tb0VyQsme #dy #N

Essayez-le en ligne!(remarque: le code lui-même n'évalue qu'un seul bloc, le mode suite de tests de l'interpréteur exécute le programme une fois pour chaque ligne d'entrée)

Basé sur la solution Python 2 de TFeld .

Explication:

L.tb0         # define a lambda function called y which does a transpose, padding with integer 0's
VyQ           # loop over transposed first input line (Q = eval(input()) ) (loop index = N)
   s          # concatenate array of strings (implicitly printed)
    m         # map over
         y #N # transpose of non-falsy values of N
     e        # for each item: last element of array
       #d     # relevant space at the start! filter with identity function, removes falsy values

pour une explication des raisons pour lesquelles l'algorithme lui-même fonctionne, voir la réponse de TFeld.

Fusain , 4 octets

ＦθＰι

Essayez-le en ligne (verbeux) ou essayez-le en ligne (pur) .

Explication:

Boucle sur la liste d'entrée des chaînes multi-lignes:

For(q)
Ｆθ

Et imprimez la chaîne multi-lignes sans déplacer le curseur:

Multiprint(i);
Ｐι