Meydan okuma:

Çok satırlı dizelerin bir listesi göz önüne alındığında, üst üste (sol üstte) üst üste gelin ve sonucu çıkartın.

Örnek:

Giriş: ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
Çıkış:

cbaa
bbaa
bbaa
aaaa

Meydan okuma kuralları:

• Giriş formatı esnektir. Girişin 2B satır listesi (yani [["aaaa","aaaa","aaaa","aaaa"],["bb","bb","bb"],["c"]]) veya 3B karakter listesi (örneğin ) almasına izin verilir [[["a","a","a","a"],["a","a","a","a"],["a","a","a","a"],["a","a","a","a"]],[["b","b"],["b","b"],["b","b"]],[["c"]]]. STDIN ile tüm girişleri tek tek almak için izin verilir. Vb.
• Çıktı formatı katı. Çok satırlı dizeyi yazdırmayı veya döndürmeyi seçebilirsiniz. (Dilinizde herhangi bir dize yoksa, 2B karakter listesi olarak çıktısı alınmasına alternatif olarak izin verilir.
• Giriş listesinin sırası elbette önemlidir (ancak seçerseniz girişi tersine çevirmenize izin verilir).
• Girişler yalnızca unicode aralığında ( ) yazdırılabilir ASCII içerecektir .$[33,126]$!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
• Girişler sadece dikdörtgen olacaktır (bu yüzden tuhaf şekiller). Yine de çıktı gerekli dikdörtgenler değildir.
• Sondaki boşluklar ve sondaki tek satırsonuna izin verilir. Önde gelen boşluklar ve / veya yeni satırlar değil.

Genel kurallar:

• Bu kod golf , bayt cinsinden en kısa cevap kazanır.
  Code-golf dillerinin, codegolfing olmayan dillerle cevap göndermekten vazgeçmesine izin vermeyin. Herhangi bir programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Standart G / Ç kurallarına cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT işlevlerini, uygun parametreleri içeren fonksiyonlar / yöntemleri ve dönüş tipini, tam programları kullanmanıza izin verilir. Senin çağrı.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuzu test eden bir bağlantı ekleyin (ör. TIO ).
• Ayrıca, cevabınız için bir açıklama eklemek şiddetle tavsiye edilir.

Test durumları:

Giriş: ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
Çıkış:

cbaa
bbaa
bbaa
aaaa

Giriş: ["12345\n54321","00\n00\n00\n00","001\n011\n012"]
Çıkış:

00145
01121
012
00

Giriş: ["sm\noo\nmr\nee\nt!\nh_\ni_\nn_\ng_","!@#$%^\n&*()_+\nqwerty\nuiopas","this\nis_a\ntest"]
Çıkış:

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

Jöle , 3 bayt

a/Y

Çevrimiçi deneyin!

Jelly'i bir süredir kullanmamıştım ama yorumlardaki zorlukların yenilebilir olduğunu düşündüm. Çok direkt olarak mantıksal ve ( a), girişin ( /) her elemanı arasında istifleme işlemini gerçekleştirmek için kullanır . Yİstenilen formatta yazdırmak için kullanılır.

JavaScript (Node.js) , 24 bayt

@Grimy sayesinde 2 bayt kaydedildi

Dönen dizenin, ANSI çıkış kodlarını destekleyen bir terminale basıldığını varsayar . Aşağıdaki ESCgibi kaçan ( punto amaçsız) yazdırılamaz karakterini içerir \x1B.

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

Bu TIO'da çalışmıyor, ancak çevrimiçi deneyebilirsiniz! bunun yerine ham çıktıyı görmek için.

Nasıl?

Kullanılan CSI dizileri :

• ED (Ekranda Sil):

  ESC[2J

  nerede vasıta "açık tüm ekran"$2$

• CUP (İmleç Konumu):

  ESC[H

  bu vasıtalar, "imleç satır hareket , kolon "$n$$m$ , hem ve atlanmış ve dolaylı olarak ayarlanır (ekranın sol üst köşesinde).$n$$m$$1$

Örnek çıktı

R , 120 , 111 110 107 bayt

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,,'')}

Çevrimiçi deneyin!

Bir karakter matrisi listesini kabul eden bir fonksiyon (3D giriş kabul edilir).

(Bayt sayısından fark edebileceğiniz gibi, bu R'de yapmak çok kolay değil ...)

• @Giuseppe sayesinde -9 bayt
• @RobinRyder sayesinde -4 bayt

Python 2,8 bayt

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

Çevrimiçi deneyin!

Açıklama (örneğin):

Giriş olarak 2D listesini alır.

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

Öncelikle, her giriş dikdörtgeninin satırlarını almak için giriş listesi sıkıştırılır ( map(None,l)aynı zip uzunluğudur):

map(n,*input())   gives:

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

Bu sıraların her biri daha sonra Nones'den süzüldü ve tekrar sıkıştırıldı:

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

İstenilen sonucun her konumu için bir karakter listesidir. Bu listeler tekrar filtrelenir ve en sonuncusu alınır:

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

Son olarak ortaya çıkan listeler birleştirilir ve yazdırılır:

print''.join(..)

00145
01121
012
00

R, 107 97 bayt

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

\rTaşıyıcı dönüş karakterinin kullanımıyla ilgili olabilecek TIO'da işe görünmüyor . Yerel kurulumumda R çalışıyor.

Girdiyi bir satır vektörü içeren bir liste olarak alır:

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

Her dikdörtgenin satırları üzerinde dolaşır, her satırdan sonra satır başı basar ve satır yeniden başlar.

Kuralları biraz uzatırsak, girişin uzunluğunu kontrol etmekten vazgeçebiliriz ve sınırsız bir şekilde yeni döngüler yazdırabiliriz:

R, 85 bayt

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 bayt ^SBCS

2D karakter dizilerinin listesini argüman olarak alarak adsız tacit önek işlevi. Baskılar.

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

Çevrimiçi deneyin!

Bu, bir tuval oluşturarak, bunu bloklar listesine ekleyerek ve blokları köşeye yerleştiren bir fonksiyonla küçülterek (katlayarak) çalışır.

↑ ortogonal bir 3D blok oluşturmak için 2B bloğu karıştırın, gerektiğinde boşluklarla doldurun

1⌷ ilk katmanı al

⊂ kuşatmaktadırlar bu
 ∘ daha sonra
⌽, blok ters listesini başa eklemek

(… ) Aşağıdaki taktik işlevini uygulayın:

 {… }/ Aşağıdaki anonim lambda'yı kullanarak azaltın:

  ⊢⍵ tuval olarak doğru argümanla…

  ⍺@(... ) yerleştirilen sol argüman, unsurları ile değiştirilmesi de aşağıdaki endeksleri:

   ⍴⍺ sol argümanın şekli

   ⍳ bu şeklin bir dizisinin ekleri

 ⊃ ifşa (çünkü rütbe azaltmak için kapalı azaltma)

Haskell, 66 bayt

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

Girdi İlk test durumu için örneğin, ters sırada dizeleri listenin bir liste olarak alınır: [["c"],["bb","bb","bb"],["aaaa","aaaa","aaaa","aaaa"]].

Çevrimiçi deneyin!

05AB1E , 12 bayt

Port TFeld en piton çözümü
2 byte sayesinde kaydedilen Güvenlik çok kötü

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

Çevrimiçi deneyin!

açıklama

ζ             # 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

Alternatif 14 byte versiyonu

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

Çevrimiçi deneyin!

açıklama

õζ              # 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

Tuval , 5 bayt

Ｈ１１╋╋

Burada dene!

Üst üste binen /+ \→ X, -+ |→ +, vb. İyi olurdu, 2 bayt işe yarar .

Python 2,77 bayt

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

Çevrimiçi deneyin!

PowerShell 6 , yalnızca konsol, 20 bayt

Arnauld'un cevabına göre . Bu yalnızca konsolla çalışır ve TIO'da çalışmaz.

cls
$args-join"`e[H"

Çevrimiçi deneyin!

PowerShell , 103 bayt

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

Çevrimiçi deneyin!

unrolled:

$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 bayt

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

23 bayt ithalat içindir, using C=System.Console;

Konsol olmadığı için TIO'da çalışmaz.

Çevrimiçi deneyin!

Ruby , 67 bayt

Giriş, satırların bir listesidir. Satırların bir listesini oluşturur ve girdilerin üzerinden geçerken üzerine yazar, daha sonra $/katı çıktının eşleşmesi için sonunda yeni bir satırla (değişken tarafından temsil edilir ) birleştirilir.

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

Çevrimiçi deneyin!

C (GCC, MinGW) 138 bayt

CR'nin imleci mevcut satırın başına getirdiğini varsayar.

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

Şununla test edildi:

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 bayt

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

Char matrislerinin dikey hücre dizisini alan ve char matrisini döndüren işlev.

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

Javascript (tarayıcı) , 216 208 204 bayt

Bu benim girişimim. Büyüklükten memnun değilim ve kesinlikle iyileştirme için daha fazla olmalı, ancak golf oynamakta o kadar da deneyimli değilim.

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)

Her neyse, yaptığı şey önce tüm dizeleri bölmek, sonra tüm dizeleri ters çevirmek, sonra da bir azaltma işleminde ilmek yaparken tüm dizeleri bir araya getirmek. Sonra tüm dizeleri tekrar ters çevirin ve ardından yeni satırlarla tekrar birleştirin.

Kevin Cruijssen'e , for döngüsünün son kısmının sonunda gerçekleştiğini ve toplamda 8 baytlık bir tasarruf sağladığını hatırlattığım için teşekkür ederim .

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 bayt

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

Çevrimiçi deneyin!

Ceilingcat sayesinde -4 bayt.

İmleç konumunu kaydetme / geri yükleme için CSI dizilerini kullanır. Sadece iletilen string dizisinin (aynı formatta argv) üzerinden tekrar eder ve <save position>string<restore position>her biri için basar .

Bu, imleci sol üstte bırakır, bu yüzden terminalde çalışırken, istemin girişi engellememesi için yeterince yeni satır bırakılması önemlidir.

Japt -P , 7 bayt

Girdiyi çok satırlı dizeler dizisi olarak alır, tek bir çok satırlı dizge çıktılar.

ú y_¸¬Ì

Dene

ú 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

T-SQL sorgusu, 297 295 bayt

Ayırıcı olarak ¶ ve girdi olarak bir tablo değişkeni kullanın.

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)

Çevrimiçi deneyin

Javascript (tarayıcı), 129 124 bayt

Kod golf oynamadaki ilk denemem. Kurallarda verilen bağlantıları okudum (boşluklar, standart kurallar ...), umarım yanlış bir şey yapmışımdır!

Girişleri ilk yazıdaki gibi tuttum (flat array formu).

_=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`}

5 bayt kaydettiğiniz için Kevin Cruijssen teşekkürler .

Testler:

_=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 bayt

L.tb0VyQsme #dy #N

Çevrimiçi deneyin! (not: kodun kendisi yalnızca bir bloğu değerlendirir, tercümanın test paketi modu programı her giriş satırı için bir kez çalıştırır)

Dayanarak TFeld Python 2 solüsyon .

Açıklama:

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

Algoritmanın kendisinin neden çalıştığının bir açıklaması için, bkz. TFeld'in cevabı.

Kömür , 4 bayt

ＦθＰι

Çevrimiçi deneyin (ayrıntılı) veya çevrimiçi deneyin (yalnızca saf) .

Açıklama:

Çok satırlı dizgelerin giriş listesi üzerinde döngü:

For(q)
Ｆθ

Ve imleci hareket ettirmeden çok satırlı dizgeyi yazdırın:

Multiprint(i);
Ｐι