M uzunluktaki n dizeleri n uzunluktaki m dizelere dönüştür


16

'M' uzunluğundaki herhangi bir 'n' sayıda dize verildiğinde, 'm' sayıda 'n'-uzunluklu dize döndüren bir program yazın, bu koşulla:

Her yeni dize, diğer dizelerle aynı dizindeki harfleri içermelidir

Örneğin, ilk çıkış dizesi tüm giriş dizelerinin ilk harfini içermelidir, ikinci çıkış dizesi tüm giriş dizelerinin ikinci harfini içermelidir, vb.

Örnekler (harflerin altındaki sayılar dizelerin dizinleridir):

input: "car", "dog", "man", "yay"
        012    012    012    012
output: "cdmy", "aoaa", "rgny"
         0000    1111    2222

input: "money", "taken", "trust"
        01234    01234    01234
output: "mtt", "oar", "nku", "ees", "ynt"
         000    111    222    333    444

Her seferinde girişin doğru olduğunu varsayın

En kısa bayt kodu kazanır!

Düzenle:

Birçok programlama dili olduğundan ve her biri için birçok olası çözüm olabileceğinden, her programlama dili ve bunu sağlayan kullanıcı için en kısa çözümü göndereceğim. Kodlamaya devam edin!

Yeniden Düzenleme:

Kullanıcı Dennis sayesinde skor tabloları için bir pasaj ekledim.


2
Soru bedeninize ekleyebileceğiniz bir liderlik snippet'imiz var. Bunu elle yapmaya gerek yok.
Dennis


Özür dilerim, "transposing" olarak adlandırıldığını bilmiyordum
Giriş Adı Here

6
Diğer sorudaki düzensiz transpozisyon ve bazı garip boşluk işleme ile ilgili farklılıklar nedeniyle bu zorlukların çift olduğuna inanmıyorum. Bazı dillerde cevaplar çok benzer olsa da, çoğunda bunun kopya olmaması için yeterince farklı olacağını düşünüyorum.
FryAmTheEggman

Yanıtlar:



9

Python, 36 29 bayt

zip(*s) aktarılan her karakterin tuples listesini döndürür.

lambda s:map(''.join,zip(*s))

Çevrimiçi deneyin


Çıktı "cdmy", "aoaa", "rgny", bir liste ["cdmy", "aoaa", "rgny"]veya bir demet olduğunu söylüyor("cdmy", "aoaa", "rgny")
mbomb007

map(''.join,zip(*s))Ayrıca dize dönüşümü (yalnızca Python 2) ve Python 3 için [*map(''.join,zip(*s))]çalışır , afaik çalışır
Value Ink

@ KevinLau-notKenny map(''.join,zip(*s))Python 3 için de geçerlidir - varsayılan olarak listelerin yerine yineleyicilere / jeneratörlere izin veririz.
Mego



7

PowerShell v2 +, 66 54 bayt

param($n)for($x=0;$n[0][$x];$x++){-join($n|%{$_[$x]})}

Yo ... hayır map, hayır zip, hayır transpose, vb. 12 bayt golf için @ DarthTwon büyük sahne .

Girdi alır $n, bir fordöngü kurar . Başlatma setleri $xiçin 0, hala sözümüzün harfleri olup olmadığını testtir $n[0][$x]ve biz artırmak $x++her yineleme.

Döngünün içinde, dizeler dizimizi alırız, her kelimeden uygun karakteri veren bir iç döngüye bağlarız. Bu, -joinbir dize oluşturmak üzere bir ile kapsüllenir ve bu dize boru hattında bırakılır. Yürütmenin sonunda, boru hattındaki dizeler örtülü olarak yazdırılır.

PS C:\Tools\Scripts\golfing> .\convert-n-strings.ps1 "Darth","-Twon","Rocks"
D-R
aTo
rwc
tok
hns

1
Güzel, görmek istediğim cevaplar bu tür;) ,Cevabı düşünmekten çok basit bir yazı
Input Name Here

Bir süre döngüsünü kullanarak ayrıca bu aşağı pare edebilirsiniz: param($n)$x=0;while($n[0][$x]){-join($n|%{$_[$x]});$x++}. Ve burada hata yok: D
ThePoShWolf

@DarthTwon Mükemmel. Ya da, fordiğer ikisi için bir döngü kullanın . ;-)
AdmBorkBork

Hmm ... Bunu denedim, ama gerçekten döngümden ayrıldıktan sonra değil while. İyi iş efendim!
ThePoShWolf

Powershell'de Linq kullanabilir misiniz?
aloisdg taşınma codidact.com

7

Vim, 37 36 tuş vuruşları

Diğer tüm cevaplar sıkıcı ve sıkıcı tek baytlı yerleşikler kullanıyor. İşte her şeyi bir programlama dili bile olmayan bir şeyde elle yapan hacky bir cevap:

Gmaqqgg:s/./&<cr>d<C-v>`aGo<esc>pvGgJ@qq@q`adgg

Açıklama:

G                                   "move to the end of this line
     ma                             "And leave mark 'a' here
       qq                           "Start recording in register 'q'
         gg                         "Move to the beginning
           :s/./&<cr>               "Assert that there is atleast one character on this line
                      d             "Delete
                       <C-v>        "Blockwise
                            `a      "Until mark 'a'

    G                               "Move to the end of the buffer
     o<esc>                         "Open a newline below us
           p                        "And paste what we deleted
            vG                      "Visually select everything until the end
              gJ                    "And join these without spaces
                @q                  "Call macro 'q'. The first time, this will do nothing,
                                    "The second time, it will cause recursion.
                  q                 "Stop recording
                   @q               "Call macro 'q' to start it all

Şimdi, her şey iyi, ancak arabellekte fazladan metin kaldı. Bu yüzden:

`a                              "Move to mark 'a'
  dgg                           "And delete everything until the first line

5

CJam, 6 5 bayt

Luis Mendo sayesinde 1 bayt kurtardı.

qS%zp

Çevrimiçi deneyin!

q      e# Get all input
 S%    e# Split it on spaces
   z   e# Take the transpose
    p  e# Print it as an array


4

Retina , 45 43 bayt

Bayt sayımı ISO 8859-1 kodlamasını varsayar.

O$#`.(?<=(.+))|¶
$.1
!`(?<=(¶)+.*)(?<-1>.)+

Baştaki satır besleme önemlidir. Giriş ve çıkış yazdırılabilir ASCII dizelerinin satır beslemeli sonlandırılmış listeleridir (her ikisinin de tek bir satır besleme beslemesi olduğunu unutmayın).

Çevrimiçi deneyin!

Bir süredir dikdörtgen blokların transpozasyonunun Retina'da bir ağrı olacağını biliyordum (oysa transpozisyonlar çok kötü değil), ama aslında hiç denemedim. İlk çözüm gerçekten 110 bayt uzunluğundaydı, ancak yaklaşımdaki bazı önemli değişikliklerden sonra, ortaya çıkan 45 bayt, şüphelendiğim kadar kötü değil (ama yine de ...). Açıklama yarın takip edecek.

açıklama

Aşama 1: Sırala

O$#`.(?<=(.+))|¶
$.1

Bu, girişteki karakterleri yeniden sıralamanın ana işini yapar, ancak satırlara ayırmayı karıştırır. İlginç bir şekilde, 'i kaldırırsak, kare bir girişi aktarmak için gerekli kodu alırız.

Sıralama aşamaları (ile gösterilir O) şu şekilde çalışır: verilen normal ifadenin tüm maçlarını bulurlar (sonrasındaki `) ve daha sonra bu maçları sıralar ve maçların bulunduğu yerlere yeniden yerleştirirler. Olduğu gibi, bu normal ifade her bir karakterle eşleşir: .(?<=(.*))alternatif üzerinden satır beslemeleri ve . Bu nedenle, girişteki tüm karakterleri sıralar. Daha ilginç olan kısmı, sıralamalarına göre sıralanıyor .

$Seçenek aktive eden "sort-by", her bir maç sonra sonuç karşılaştırılması için kullanılan ikinci hat, üzerindeki ikame modeli ile değiştirilir modunda. Ayrıca #Retina'ya, ikame sonucunu bir tamsayıya dönüştürmesini ve bu tamsayıları karşılaştırmasını (onlara dize olarak işlemek yerine) söyler.

Son olarak, normal ifadeye ve ikamesine bakmamız gerekiyor. İlk alternatif eşleşirse (yani, satırlardan birinde herhangi bir karakteri eşleştirdiysek), o (?<=(.*))satırdaki o karaktere kadar olan her şeyi grup olarak yakalar 1. $.1İkame desen ile değiştirir uzunluğu grubunun 1. Böylece, her dizgideki ilk karakter olur 1, ikincisi olur 2, üçüncüsü olur 3. Şimdi bunun bir kare girdiyi nasıl dönüştürdüğü açık olmalıdır: satırların tüm ilk karakterleri önce gelir ve hepsi en üst satırda sona erer, daha sonra tüm ikinci karakterler ikinci satırda sona erer vb. Ancak bu dikdörtgen girdiler için satır beslemelerini de eşleştiriyoruz. Gruptan beri1bu durumda kullanılmamışsa, ikame boştur, ancak #opsiyonun amaçları için bu dikkate alınır 0. Bu, tüm hat beslemelerinin öne doğru sıralandığı anlamına gelir.

Şimdi ilk sırada karakterler var (her dizenin ilk karakteri, her dizenin ikinci karakteri, vb.) Ve başlangıçtaki tüm satır beslemeleri var.

Aşama 2: Maç

!`(?<=(¶)+.*)(?<-1>.)+

Şimdi karakterleri doğru uzunlukta satırlara ayırmamız gerekiyor. Bu uzunluk, orijinal girdideki satır sayısına, yani dizenin başında sahip olduğumuz satır besleme sayısına karşılık gelir.

Bölme burada verilen regex'in tüm eşleşmelerini bulan ve !bu eşleşmeleri yazdırma seçeneğini kullanan bir eşleştirme aşaması yardımıyla yapılır (varsayılan, onları saymak olacaktır). Normal ifadenin amacı, her seferinde bir satırla eşleşmektir.

İşe baktığımızda sayıyı "sayarak" başlıyoruz (?<=(¶)*.*). 1Öndeki her hat beslemesi için grup halinde bir yakalama oluşturur .

Ardından, bu yakalamaların her biri için tek bir karakterle eşleşiriz (?<-1>.)+.


4

x86 makine kodu, 19 bayt

Onaltılı olarak:

fc89d35651a401dee2fb91aa595e464a75f1c3

Girdi:: ECXdizi sayısı (n),: EDXtek tek dizi uzunluğu (m) ESI,: girdi EDIdizi dizisi,: dizi dizi alan çıktı tamponu. Dizinin, char src[n][m+1]girdi ve char dst[m][n+1]çıktı için tanımlandığı varsayılır ve tüm dizeler NULL ile sonlandırılır.

0:  fc                  cld
1:  89 d3               mov ebx,edx   ;EDX is the counter for the outer loop
_outer:
3:  56                  push esi
4:  51                  push ecx
_inner:
5:  a4                  movsb         ;[EDI++]=[ESI++]
6:  01 de               add esi,ebx   ;Same char, next string
8:  e2 fb               loop _inner   ;--ECX==0 => break
a:  91                  xchg eax,ecx  ;EAX=0
b:  aa                  stosb         ;NULL-terminate just completed string
c:  59                  pop ecx
d:  5e                  pop esi       ;First string,
e:  46                  inc esi       ;...next char
f:  4a                  dec edx
10: 75 f1               jnz _outer
12: c3                  ret

3

Brachylog , 5 bayt

z:ca.

Dizelerin bir listesini girdi olarak bekler, ör. run_from_atom('z:ca.',["money":"taken":"trust"],Output).

açıklama

z       Zip the strings in the Input list
 :ca.   output is the application of concatenation to each element of the zip

3

05AB1E, 3 bayt

ø€J

Açıklaması

     # implicit input, eg: ['car', 'dog', 'man', 'yay']
ø    # zip, producing [['c', 'd', 'm', 'y'], ['a', 'o', 'a', 'a'], ['r', 'g', 'n', 'y']]
 €J  # map join, resulting in ['cdmy', 'aoaa', 'rgny']

Çevrimiçi deneyin



2

JavaScript ES6, 48 46 bayt

a=>[...a[0]].map((n,x)=>a.map(a=>a[x]).join``)

Dışarıda hissediyorum, yerleşik zip fonksiyonumuz yok. Benim tip hata işaret ettiğiniz için teşekkürler nicael.

kullanım

(a=>[...a[0]].map((n,x)=>a.map(a=>a[x])))(["asd","dsa"]); //or whatever is above, might change due to edits

İadeler

["ad","ss","da"]

İstisna: TypeError: a [0] .map bir işlev değil
edc65

1
İhtiyacınız var [...a[0]].map, çünkü a[0]bir dizi değil.
nicael

@nicael teşekkürler. türleri berbat. bu sabah erken saatlerde neden golf oynamamam gerektiğini kanıtlıyor.
charredgrass

@nicael .joinBu sorunu çözmek için onları düzenledim .
charredgrass

1
join`` join('')2 bayt kaydetmek yerine . Downvote geri çekildi
edc65

2

Bash + BSD yardımcı programları, 27

sed s/./\&:/g|rs -c: -g0 -T

STDIN / STDOUT yeni satırla ayrılmış dizelerle G / Ç.

Sen yüklemeniz gerekebilir rsilesudo apt install rs veya benzeri. OS X'te kutudan çıkar çıkmaz çalışır.

-TSeçeneği rstranspozisyonunun ağır işleri yapıyor. Gerisi sadece biçimlendiriyor:

  • sedKomut basitçe ekler :her karakterden sonra
  • -c:giriş sütunlarının :ayrıldığını belirtir
  • -g0 çıktı sütunlarının sıfır genişlik ayrımına sahip olduğunu belirtir

rsManpage okumam doğru ise, o zaman aşağıdakiler gerekir , 12 puan için çalışmak, ancak ne yazık ki işi değil - aşağıdaki nota bakınız:

rs -E -g0 -T

Örnek çıktı:

$ printf "%s\n" car dog man yay |sed s/./\&:/g|rs -c: -g0 -T
cdmy
aoaa
rgny
$

Girişin tüm yazdırılabilir ASCII olması bekleniyorsa, : yazdırılamayan bir karakterle değiştirilebilir, örneğin 0x7 BEL.


Not

Neden -Eçalışma ve sedönişlemeden kurtulamadığımı anlamak istedim . rsKaynak kodunu burada buldum . Gördüğünüz gibi, bu seçeneğin verilmesiONEPERCHAR bayrağı . Ancak, kodda bu bayrağın durumunu denetleyen hiçbir şey yoktur. Bu yüzden, seçeneğin belgelenmesine rağmen, uygulanmadığını söyleyebiliriz.

Aslında, bu seçenek Linux rskılavuzunda belgelenmiştir :

-E Girdinin her karakterini dizi girişi olarak düşünün.

ancak OS X sürümü değil.


2

PHP, 82 bayt

function f($a){foreach($a as$s)foreach(str_split($s)as$i=>$c)$y[$i].=$c;return$y;}

bir dizi dizeyi alır ve döndürür

Yıkmak

function f($a)
{
    foreach($a as$s)                    // loop through array $a
        foreach(str_split($s)as$i=>$c)  // split string to array, loop through characters
            $y[$i].=$c;                 // append character to $i-th result string
    return$y;
}

örnekler

$samples=[
    ["asd","dsa"], ["ad","ss","da"],
    ["car", "dog", "man", "yay"], ["cdmy", "aoaa", "rgny"],
    ["money", "taken", "trust"], ["mtt", "oar", "nku", "ees", "ynt"]
];
echo '<pre>';
while ($samples)
{
    echo '<b>in:</b> ';         print_r($x=array_shift($samples));
    echo '<b>out:</b> ';        print_r(f($x));
    echo '<b>expected:</b> ';   print_r(array_shift($samples));
    echo '<hr>';
}

2

APL, 3 bayt

↓⍉↑

girdi dizelerini alır ve bir char matrisine dönüştürür. matrisi aktarır. elde edilen matrisin satırlarını dizelere böler.



1

Mathematica, 26 bayt

""<>#&/@(Characters@#)&

Anonim işlev. Bir dize listesini girdi olarak alır ve bir dize listesini çıktı olarak döndürür. Unicode karakteri temsil eden U + F3C7'dir \[Transpose]. Bir karakter matrisine dönüştürerek, transpoze ederek ve bir dize listesine dönüştürerek çalışır. Giriş / çıkış formatı uzatılmışsa, 5 baytlık basit bir aktarım işe yarayacaktır:

#&

+1 beni yumruk attı! (Ama Devrik sembolünü kullanamadım.) Bu arada, T neden ekranda görünmüyor? (Kodunuzu Mathematica'ya kopyaladığımda var).
DavidC

@DavidC Unicode karakteri Özel Kullanım Alanındadır ve özel karakterler için bir bölüm olarak işaretlenmiştir ve bu nedenle ne resmi olarak bir glif atanmamıştır, ne de çoğu yazı tipinde görüntülenmez. Mathematica'nın yazı tipi, bu karakteri bir üst simge T olarak oluşturmak ve bir \[Transpose].
LegionMammal978

@DavidC Neden kullanmıyorlar ?
Adám

@ Adám IDK, bana değil Wolfram Research'e bunu sormak zorunda
kalacaksın

@ LegionMammal978 Hayır, APL açık olduğu sürece mutluyum .
Adám

1

MATLAB / Oktav, 4 bayt

@(x)x'

Bu anonim bir işlevi tanımlar. Girdi biçimi ['car'; 'dog'; 'man'; 'yay'].

Burada deneyin .


Bu çözüm için girdi nedir? Matlabby olarak girmeye çalışırsanız Matlab dizeleri işleme biçimiyle çalışacağını düşünmüyorum, örneğin f = @(x)x', f([{'abcd'},{'abcd'},{'abcd'}])çıkışlar ans = 'abcd' 'abcd' 'abcd'
sintax

@sintax Girdi biçimi, yanıtta bağlantılı örnekte olduğu gibi 2B karakter dizisi olmalıdır. Hücre dizeleri dizisi kullanıyorsunuz (tekli hücre dizilerini birleştirerek elde edilir). Öyle olmalı: f(['abcd';'abcd';'abcd']). Giriş formatını belirtmek için cevabı düzenledim
Luis Mendo

1

Haskell, 41 bayt

f l=zipWith($)[map(!!n)|n<-[0..]]$l<$l!!0

Ya da biraz daha fazla hava ile:

f l = zipWith ($) [map (!! n) | n <- [0..]] $
                  l <$ (l !! 0)

İkinci liste, “bir kelimenin uzunluğu” süresinde tekrarlanan kelimelerin listesidir. Her bir kelime listesinde, sonucu veren her kelimenin n. Harfini seçiyoruz.


1
Tam bir programa gerek yoktur, çünkü "program" "program veya fonksiyon" anlamına gelir , bu nedenle bir işlev yeterlidir. Dizelerin bir listesini geçip döndürebilir ve bu nedenle wordsve öğelerini atlayabilirsiniz unwords. Bundan başka, map(\_->l)(l!!0)bir l<*l!!0o aşağı kaynar böylece, \l->zipWith($)[map(!!n)|n<-[0..]]$l<$l!!0.
nimi

Oh, iyi teşekkürler :) Güncelliyorum.
villou24

Hata! Yazım hatası: l<$l!!0(ilk kez yanlış, ikinci kez doğru), ama yine de doğru anladınız.
nimi

1

Ortak Lisp, 62 bayt

(lambda(s)(apply'map'list(lambda(&rest x)(coerce x'string))s))

mapİşlevi, bir sonuç türü (burada sürer list), bir işlev f uygulamak ve bir veya daha fazla dizilerin s1 , ..., sn . Tüm sekanslar paralel olarak yinelenir. Bu dizilerden alınan her bir eleman grubu (e1, ..., en) için (f e1 ... en) ve sonuç istenen tipte bir sekansta biriktiriliyor.

Dize söyle ("car" "dog" "man" "yay")ve applyçağırmak için kullanıyoruz map. Bunu, giriş listesinin daha fazla argüman olarak kullanılması için yapmalıyız map. Daha doğrusu, bu:

(apply #'map 'list fn '("car" "dog" "man" "yay"))

... şuna eşittir:

(map 'list f "car" "dog" "man" "yay")

Ve dizeler diziler olduğundan, önce tüm ilk karakterler, sonra tüm ikinci karakterler, vb. Üzerinde paralel olarak yineliyoruz. Örneğin, ilk yineleme f'yi aşağıdaki gibi çağırır :

(f #\c #\d #\m #\y)

Anonim lambda, kendisine verilen argümanların listesini alır ve bir dizeye geri zorlar.



0

Yakut, 46 bayt

Muhtemelen "Ruby dizeleri Numaralandırılamaz" ilk kez işlemeden önce dizeleri eşlemek zorunda çünkü gerçekten beni ısırıyor. (Normalde kullanmak zorunda olmak String#charsönemli bir bayt kaybı değildir, ancak onları eşlemem gerektiğinden, çok daha fazla sokuyor)

->s{s.map!(&:chars).shift.zip(*s).map &:join}

0

Clojure, 68 bayt

#(map(fn[g](reduce(fn[a b](str a(nth b g)))""%))(range(count(% 0))))

Sadece bir işlevi eşler reduce0'dan ilk dizenin uzunluğuna kadar (listenin öğelerini tek tek gider ve dizenin n. Karakterini birleştirir) eşler.

Çevrimiçi görün: https://ideone.com/pwhZ8e


0

C #, 53 bayt

t=>t[0].Select((_,i)=>t.Aggregate("",(a,b)=>a+b[i]));

FuncÇıktının olduğu IList<string>ve çıktının olduğu C # lambda ( ) IEnumerable<string>. zipDiğer dilde nasıl çalıştığını bilmiyorum ama burada C # 'ı kullanmanın bir yolunu bulamıyorum . Aggregateihtiyaca iyi uyuyor. C # 'da devrik yok, var , Excel'de bir tane ama kullanmayacağım.

Çevrimiçi deneyin!

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.