Escreva um programa que, dado qualquer número 'n' de strings de 'm' de comprimento, retorne 'm' número de strings de 'n' de comprimento, com esta condição:

Cada nova string deve conter as letras no mesmo índice das outras strings

Por exemplo, a primeira cadeia de saída deve conter a primeira letra de todas as cadeias de entrada, a segunda cadeia de saída deve conter a segunda letra de todas as cadeias de entrada e assim por diante.

Exemplos (os números sob as letras são os índices das strings):

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

Suponha que a entrada esteja correta sempre

O código dos bytes mais curtos vence!

Editar:

Como existem muitas linguagens de programação e pode haver muitas soluções possíveis para cada uma delas, publicarei a solução mais curta para cada linguagem de programação e para o usuário que a forneceu. Continue codificando!

Reeditar:

Graças ao usuário Dennis , inseri um trecho para as tabelas de classificação.

var QUESTION_ID=85255,OVERRIDE_USER=56179;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Pitão, 1 byte

C

Experimente aqui

Outra transposição incorporada

Python, 36 29 bytes

zip(*s) retorna uma lista de tuplas de cada caractere, transpostas.

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

Experimente online

Geléia , 1 byte

Z

Experimente online!

MATL , 1 byte

!

Experimente online!

Pega entrada implicitamente, transpõe, exibe saída implicitamente.

PowerShell v2 +, 66 54 bytes

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

Ei ... não map, não zip, não transpose, etc., então começamos a rolar. Grandes adereços para @DarthTwon para o golfe de 12 bytes.

Recebe entrada $n, configura um forloop. A inicialização é definida $xcomo 0, o teste é se ainda temos letras em nossa palavra $n[0][$x]e incrementamos $x++cada iteração.

Dentro do loop, pegamos nossa matriz de strings e o canalizamos para um loop interno que cospe o caractere apropriado de cada palavra. Isso é encapsulado em a -joinpara formar uma sequência e essa sequência é deixada no pipeline. No final da execução, as seqüências de caracteres no pipeline são implicitamente impressas.

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

Vim, 37 36 pressionamentos de tecla

Todas as outras respostas são monótonas e usam componentes monótonos de um byte. Aqui está uma resposta hacky que faz a coisa toda manualmente, em algo que nem sequer é uma linguagem de programação:

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

Explicação:

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

Agora, está tudo bem, mas o buffer tem algum texto extra sobrando. Então devemos:

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

CJam, 6 5 bytes

Guardado 1 byte graças a Luis Mendo.

qS%zp

Experimente online!

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

Pyke, 1 byte

,

Experimente aqui!

Transpor.

Retina , 45 43 bytes

A contagem de bytes assume a codificação ISO 8859-1.

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

O avanço de linha principal é significativo. Entrada e saída são listas terminadas com avanço de linha de seqüências de caracteres ASCII imprimíveis (observe que ambos têm um único avanço de linha final).

Experimente online!

Eu sabia por um tempo que a transposição de blocos retangulares seria uma dor na Retina (enquanto a transposição de quadrados não é tão ruim), mas nunca realmente tentei. A primeira solução foi de fato de 110 bytes, mas após várias mudanças substanciais na abordagem, os 45 bytes resultantes não são tão ruins quanto eu suspeitava (mas ainda assim ...). A explicação seguirá amanhã.

Explicação

Etapa 1: Classificar

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

Isso faz o trabalho principal de reordenar os caracteres na entrada, mas acaba atrapalhando a separação em linhas. Curiosamente, se removermos o|¶ , obteremos o código necessário para transpor uma entrada quadrada.

Os estágios de classificação (indicados por O) funcionam assim: eles encontram todas as correspondências da regex especificada (a coisa após a `) e, em seguida, classificam essas correspondências e as reinserem nos locais onde as correspondências foram encontradas. Por acaso, esse regex corresponde a todos os caracteres: feeds sem linha via .(?<=(.*))alternativa e feeds de linha via ¶. Portanto, ele classifica todos os caracteres na entrada. A parte mais interessante é o que são classificados por .

A $opção ativa um modo "ordenar por", em que cada partida é substituída pelo padrão de substituição na segunda linha, que é usada para comparar as partidas. Além disso, o# informa ao Retina para converter o resultado da substituição em um número inteiro e comparar esses números inteiros (em vez de tratá-los como seqüências de caracteres).

Então, finalmente, precisamos olhar para o regex e a substituição. Se a primeira alternativa corresponder (ou seja, correspondermos a qualquer caractere dentro de uma das linhas), o grupo (?<=(.*))capturará tudo até esse caractere nessa linha no grupo 1. O $.1padrão de substituição substitui isso pelo comprimento do grupo 1. Portanto, o primeiro caractere em cada string se torna 1, o segundo se torna 2, o terceiro se torna3 e assim por diante. Agora deve ficar claro como isso transpõe uma entrada quadrada: todos os primeiros caracteres das linhas vêm primeiro e todos acabam na linha superior, depois todos os segundos caracteres terminam na segunda linha e assim por diante. Mas para essas entradas retangulares, também estamos combinando os feeds de linha. Desde grupo1não é usado nesse caso, a substituição está vazia, mas para os fins da #opção, isso é considerado 0. Isso significa que todos os feeds de linha são classificados para a frente.

Portanto, agora temos os caracteres na primeira ordem (primeiro caractere de cada string, segundo caractere de cada string, etc.) e todos os feeds de linha no início.

Etapa 2: partida

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

Agora precisamos dividir os caracteres em linhas do tamanho correto. Esse comprimento corresponde ao número de linhas na entrada original, que corresponde ao número de feeds de linha que temos no início da string.

A divisão é feita aqui com a ajuda de um estágio de correspondência, que simplesmente encontra todas as correspondências do regex especificado e usa a !opção para imprimir essas correspondências (o padrão seria contá-las). Portanto, o objetivo da regex é corresponder uma linha por vez.

Começamos "contando" o número com o lookback atrás (?<=(¶)*.*). Ele gera uma captura em grupo 1para cada avanço de linha na frente.

Então, para cada uma dessas capturas, combinamos um único caractere com (?<-1>.)+.

código de máquina x86, 19 bytes

Em hexadecimal:

fc89d35651a401dee2fb91aa595e464a75f1c3

Entrada:: ECX# de strings (n) EDX,: comprimento individual de strings (m) ESI,: array de strings de entrada,: EDIbuffer de saída que recebe o array de strings. Presume-se que a matriz seja definida como char src[n][m+1]para entrada e char dst[m][n+1]saída, e todas as seqüências são terminadas em NULL.

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

Braquilog , 5 bytes

z:ca.

Espera uma lista de strings como entrada, por exemplo run_from_atom('z:ca.',["money":"taken":"trust"],Output).

Explicação

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

05AB1E, 3 bytes

ø€J

Explicado

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

Experimente online

CJam , 3 bytes

{z}

Este é um bloco de código (equivalente a uma função; permitido por padrão ) que espera a entrada na pilha e deixa a saída na pilha.

Experimente online!

JavaScript ES6, 48 46 bytes

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

Sinto-me deixado de fora, não temos nenhuma função zip integrada. Obrigado nicael por apontar meu erro de tipo.

Uso

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

retorna

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

Utilitários Bash + BSD, 27

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

E / S via cadeias separadas por nova linha STDIN / STDOUT.

Pode ser necessário instalar rscom sudo apt install rsou similar. Funciona imediatamente no OS X.

A -Topção de rsfazer o trabalho pesado da transposição. O resto é apenas formatação:

• O sedcomando simplesmente insere :após cada caractere
• -c:especifica que as colunas de entrada são :separadas
• -g0 especifica que as colunas de saída têm separação de largura zero

Se minha leitura da página de rsmanual estiver correta, o seguinte deverá funcionar com uma pontuação de 12, mas infelizmente não funciona - veja a nota abaixo:

rs -E -g0 -T

Exemplo de saída:

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

Se se espera que a entrada seja toda ASCII imprimível, ela :pode ser substituída por algum caractere não imprimível, por exemplo, 0x7 BEL.

Nota

Queria entender por que não consegui -Etrabalhar com a opção e me livrar do sedpré - processamento. Encontrei o rscódigo fonte aqui . Como você pode ver, dar essa opção define o ONEPERCHARsinalizador. No entanto, não há nada no código que realmente verifique o estado desse sinalizador. Então, acho que podemos dizer que, apesar do fato de essa opção estar documentada, ela não é implementada.

De fato, esta opção está documentada na página de rsmanual do Linux :

-E Considere cada caractere de entrada como uma entrada de matriz.

mas não a versão do OS X.

PHP, 82 bytes

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

pega e retorna uma matriz de strings

demolir

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

exemplos

$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>';
}

APL, 3 bytes

↓⍉↑

↑pega as seqüências de entrada e as transforma em uma matriz de caracteres. ⍉transpõe a matriz. ↓divide novamente as linhas da matriz resultante em seqüências de caracteres.

K, 1 byte

+

Experimente aqui!

Transpor

Mathematica, 26 bytes

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

Função anônima. Pega uma lista de cadeias como entrada e retorna uma lista de cadeias como saída. O caractere Unicode é U + F3C7, representando \[Transpose]. Trabalha convertendo para uma matriz de caracteres, transpondo e convertendo de volta para uma lista de cadeias. Se o formato de entrada / saída for esticado, uma simples transposição de 5 bytes funcionará:

#&

MATLAB / oitava, 4 bytes

@(x)x'

Isso define uma função anônima. O formato de entrada é ['car'; 'dog'; 'man'; 'yay'].

Experimente aqui .

Haskell, 41 bytes

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

Ou com um pouco mais de ar:

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

A segunda lista é a lista de palavras repetidas "o comprimento de uma palavra". Em cada lista de palavras, selecionamos a n-ésima letra de cada palavra, fornecendo o resultado.

Lisp comum, 62 bytes

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

A mapfunção usa um tipo de resultado (aqui list), uma função f para aplicar e uma ou mais seqüências s1 , ..., sn . Todas as sequências são iteradas em paralelo. Para cada tupla de elementos (e1, ..., en) extraídos dessas seqüências, chamamos (f e1 ... en) e o resultado é acumulado em uma sequência do tipo desejado.

Pegamos uma lista de strings, digamos ("car" "dog" "man" "yay"), e usamos applypara ligar map. Temos que fazer isso para que a lista de entrada seja usada como mais argumentos para map. Mais precisamente, isso:

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

... é equivalente a:

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

E como strings são seqüências, iteramos em paralelo sobre todos os primeiros caracteres, depois todos os segundos caracteres, etc ... Por exemplo, a primeira iteração chama f da seguinte maneira:

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

O lambda anônimo pega a lista de argumentos dados e a força a voltar a uma string.

Perl, 91 bytes

Tão demorado ..

$l=<>;$p=index($l," ")+1;@i=split//,$l;for$a(0..$p-1){print$i[$a+$_*$p]for(0..$p);print" "}

Experimente aqui!

Ruby, 46 bytes

Provavelmente, a primeira vez que "strings de Ruby não são enumeráveis" está realmente me mordendo muito, pois tive que mapear as strings em matrizes antes do processamento. (Normalmente, a necessidade de usar String#charsnão é suficiente para a perda de bytes, mas como eu preciso mapeá-los, isso dói muito mais)

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

Clojure, 68 bytes

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

Mapeia uma função que é apenas reduce (vai nos elementos da lista um por um e une o enésimo caractere da sequência) no intervalo de 0 a comprimento da primeira sequência.

Veja on-line: https://ideone.com/pwhZ8e

C #, 53 bytes

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

C # lambda ( Func) onde a saída é IList<string>e a saída é IEnumerable<string>. Não sei como funciona zipem outro idioma, mas não consigo encontrar uma maneira de usar o c # aqui. Aggregateatender bem a necessidade. Não há transposição em C #, existe uma no Excel, mas eu não a utilizarei.

Experimente online!