Écrivez un programme qui, étant donné un nombre quelconque de chaînes de longueur «m», renvoie un nombre de chaînes «m» de longueur «m», avec cette condition:

Chaque nouvelle chaîne doit contenir les lettres du même index que les autres chaînes

Par exemple, la première chaîne de sortie doit contenir la première lettre de toutes les chaînes d'entrée, la deuxième chaîne de sortie doit contenir la deuxième lettre de toutes les chaînes d'entrée, etc.

Exemples (les chiffres sous les lettres sont les index des chaînes):

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

Supposons que l'entrée est correcte à chaque fois

Le code des octets les plus courts gagne!

Éditer:

Étant donné qu'il existe de nombreux langages de programmation et qu'il pourrait y avoir de nombreuses solutions possibles pour chacun d'eux, je publierai la solution la plus courte pour chaque langage de programmation et l'utilisateur qui l'a fourni. Continuez à coder!

Rééditer:

Grâce à l'utilisateur Dennis, j'ai inséré un extrait pour les classements.

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>

Pyth, 1 octet

C

Essayez-le ici

Une autre transposition intégrée

Python, 36 29 octets

zip(*s) renvoie une liste de tuples de chaque caractère, transposée.

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

Essayez-le en ligne

Gelée , 1 octet

Z

Essayez-le en ligne!

MATL , 1 octet

!

Essayez-le en ligne!

Prend l'entrée implicitement, transpose, affiche la sortie implicitement.

PowerShell v2 +, 66 54 octets

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

Yo ... non map, non zip, non transpose, etc., donc nous pouvons rouler les nôtres. Gros accessoires à @DarthTwon pour le golf de 12 octets.

Prend l'entrée $n, établit une forboucle. L'initialisation est définie $xsur 0, le test consiste à savoir si nous avons encore des lettres dans notre mot $n[0][$x]et nous incrémentons $x++chaque itération.

À l'intérieur de la boucle, nous prenons notre tableau de chaînes, le canalisons vers une boucle intérieure qui crache le caractère approprié de chaque mot. Cela est encapsulé dans un -joinpour former une chaîne, et cette chaîne est laissée sur le pipeline. À la fin de l'exécution, les chaînes du pipeline sont implicitement imprimées.

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

Vim, 37 36 frappes

Toutes les autres réponses sont ennuyeuses et utilisent des fonctions ennuyeuses d'un seul octet. Voici une réponse hacky qui fait le tout manuellement, dans quelque chose qui n'est même pas un langage de programmation:

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

Explication:

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

Maintenant, tout va bien, mais le tampon a du texte supplémentaire. Nous devons donc:

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

CJam, 6 5 octets

1 octet enregistré grâce à Luis Mendo.

qS%zp

Essayez-le en ligne!

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 octet

,

Essayez-le ici!

Transposer.

Rétine , 45 43 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Le saut de ligne de tête est significatif. L'entrée et la sortie sont des listes terminées par saut de ligne de chaînes ASCII imprimables (notez que les deux ont un seul saut de ligne de fin).

Essayez-le en ligne!

Je savais depuis un moment que la transposition de blocs rectangulaires serait une douleur dans la rétine (alors que la transposition de carrés n'est pas trop mal), mais je n'ai jamais vraiment essayé. La première solution était en effet un énorme 110 octets de long, mais après plusieurs changements substantiels dans l'approche, les 45 octets résultants ne sont de loin pas aussi mauvais que je le pensais (mais quand même ...). L'explication suivra demain.

Explication

Étape 1: trier

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

Cela fait le travail principal de réordonner les caractères dans l'entrée, mais cela finit par gâcher la séparation en lignes. Fait intéressant, si nous supprimons le |¶, nous obtenons le code requis pour transposer une entrée carrée.

Les étapes de tri (indiquées par le O) fonctionnent comme ceci: elles trouvent toutes les correspondances de l'expression rationnelle donnée (la chose après le `), puis trient ces correspondances et les réinsèrent dans les endroits où les correspondances ont été trouvées. En fait, cette expression régulière correspond à chaque caractère: les sauts de ligne non via l' .(?<=(.*))alternative et les sauts de ligne via le ¶. Par conséquent, il trie tous les caractères de l'entrée. La partie la plus intéressante est ce qu'ils sont classés par .

L' $option active un mode de "tri par", où chaque correspondance est remplacée par le modèle de substitution sur la deuxième ligne, qui est ensuite utilisé pour comparer les correspondances. De plus, le #paramètre indique à Retina de convertir le résultat de la substitution en un entier et de comparer ces entiers (au lieu de les traiter comme des chaînes).

Donc, finalement, nous devons examiner l'expression rationnelle et la substitution. Si les premières correspondances alternatives (c'est-à-dire que nous avons fait correspondre n'importe quel caractère dans l'une des lignes), le (?<=(.*))capture tout dans ce groupe jusqu'à ce caractère sur cette ligne 1. Le $.1dans le modèle de substitution le remplace par la longueur du groupe 1. Par conséquent, le premier caractère de chaque chaîne devient 1, le second devient 2, le troisième devient3 et ainsi de suite. Il devrait être clair maintenant comment cela transpose une entrée carrée: tous les premiers caractères des lignes viennent en premier et se retrouvent tous dans la ligne la plus haute, puis tous les seconds caractères se retrouvent dans la deuxième ligne et ainsi de suite. Mais pour ces entrées rectangulaires, nous faisons également correspondre les sauts de ligne. Depuis le groupe1n'est pas utilisé dans ce cas, la substitution est vide, mais aux fins de l' #option, cela est considéré 0. Cela signifie que tous les sauts de ligne sont triés vers l'avant.

Alors maintenant, nous avons les caractères dans le premier ordre (premier caractère de chaque chaîne, deuxième caractère de chaque chaîne, etc.) et tous les sauts de ligne au début.

Étape 2: Match

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

Nous devons maintenant diviser les caractères en lignes de la bonne longueur. Cette longueur correspond au nombre de lignes dans l'entrée d'origine, qui correspond au nombre de sauts de ligne que nous avons au début de la chaîne.

Le fractionnement se fait ici à l'aide d'une étape de correspondance, qui trouve simplement toutes les correspondances de l'expression régulière donnée et utilise l' !option pour imprimer ces correspondances (la valeur par défaut serait de les compter à la place). Le but de l'expression régulière est donc de faire correspondre une ligne à la fois.

Nous commençons par «compter» le nombre avec le lookbehind (?<=(¶)*.*). Il génère une capture en groupe 1pour chaque saut de ligne à l'avant.

Ensuite, pour chacune de ces captures, nous associons un seul caractère avec (?<-1>.)+.

code machine x86, 19 octets

En hex:

fc89d35651a401dee2fb91aa595e464a75f1c3

Entrée:: ECX# de chaînes (n) EDX,: longueur de chaîne individuelle (m) ESI,: tableau de chaînes d'entrée,: EDItampon de sortie recevant un tableau de chaînes. Le tableau est présumé être défini comme char src[n][m+1]pour l'entrée et char dst[m][n+1]pour la sortie, et toutes les chaînes sont terminées par 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

Brachylog , 5 octets

z:ca.

Attend une liste de chaînes en entrée, par exemple run_from_atom('z:ca.',["money":"taken":"trust"],Output).

Explication

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

05AB1E, 3 octets

ø€J

Expliqué

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

Essayez-le en ligne

CJam , 3 octets

{z}

Il s'agit d'un bloc de code (équivalent à une fonction; autorisé par défaut ) qui attend l'entrée sur la pile et laisse la sortie sur la pile.

Essayez-le en ligne!

JavaScript ES6, 48 46 octets

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

Je me sens exclu, nous n'avons pas de fonction zip intégrée. Merci nicael d'avoir signalé mon erreur de type.

Usage

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

Retour

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

Utilitaires Bash + BSD, 27

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

E / S via des chaînes séparées par des sauts de ligne STDIN / STDOUT.

Vous devrez peut-être installer rsavec sudo apt install rsou similaire. Fonctionne prêt à l'emploi sur OS X.

L' -Toption de faire rsle gros du travail de la transposition. Le reste est juste un formatage:

• La sedcommande insère simplement :après chaque caractère
• -c:spécifie que les colonnes d'entrée sont :séparées
• -g0 spécifie que les colonnes de sortie ont une séparation de largeur nulle

Si ma lecture de la rspage de manuel est correcte, alors ce qui suit devrait fonctionner pour un score de 12, mais malheureusement cela ne fonctionne pas - voir la note ci-dessous:

rs -E -g0 -T

Exemple de sortie:

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

Si l'entrée est censée être entièrement ASCII imprimable, le :peut être remplacé par un caractère non imprimable, par exemple 0x7 BEL.

Remarque

Je voulais comprendre pourquoi je ne pouvais pas obtenir l' -Eoption de travailler et de me débarrasser du sedprétraitement. J'ai trouvé le rscode source ici . Comme vous pouvez le voir, donner cette option définit le ONEPERCHARdrapeau. Cependant, il n'y a rien dans le code qui vérifie réellement l'état de cet indicateur. Je pense donc que nous pouvons dire que même si cette option est documentée, elle n'est pas mise en œuvre.

En fait, cette option est documentée dans la rspage de manuel Linux :

-E Considérez chaque caractère d'entrée comme une entrée de tableau.

mais pas la version OS X.

PHP, 82 bytes

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

takes and returns an array of strings

break down

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

examples

$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

↓⍉↑

↑ takes the input strings and turns them into a char matrix. ⍉ transposes the matrix. ↓ splits back the rows of the resulting matrix into strings.

K, 1 byte

+

Try it here!

Transpose

Mathematica, 26 bytes

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

Anonymous function. Takes a string list as input and returns a string list as output. The Unicode character is U+F3C7, representing \[Transpose]. Works by converting to a character matrix, transposing, and converting back to a string list. If the input/output format was stretched, then a simple 5-byte transpose would work:

#&

MATLAB / Octave, 4 bytes

@(x)x'

This defines an anonymous function. Input format is ['car'; 'dog'; 'man'; 'yay'].

Try it here.

Haskell, 41 bytes

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

Or with a bit more air:

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

The second list is the list of words repeated “the length of a word” time. On each list of words, we select the n-th letter of each word, giving the result.

Common Lisp, 62 bytes

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

The map function takes a result type (here list), a function f to apply and one or more sequences s1, ..., sn. All sequences are iterated in parallel. For each tuple of elements (e1,...,en) taken from those sequences, we call (f e1 ... en) and the result is accumulated in a sequence of the desired type.

We take a list of strings, say ("car" "dog" "man" "yay"), and use apply to call map. We have to do this so that the input list is used as more arguments to map. More precisely, this:

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

... is equivalent to:

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

And since strings are sequences, we iterate in parallel over all first characters, then all second characters, etc... For example, the first iteration calls f as follows:

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

The anonymous lambda takes the list of arguments given to it and coerces it back to a string.

Perl, 91 bytes

So lengthy one..

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

Try it here!

Ruby, 46 bytes

Probably the first time that "Ruby strings aren't Enumerables" is actually biting me hard since I had to map the strings into arrays before processing. (Normally having to use String#chars isn't enough of a byte loss to matter, but since I need to map them, it stings a lot more)

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

Maps a function which is just reduce (goes on elements of the list one by one and joins nth character of the string) on the range from 0 to length of the first string.

See it online: https://ideone.com/pwhZ8e

C#, 53 bytes

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

C# lambda (Func) where the output is IList<string> and the output is IEnumerable<string>. I dont know how work zip in other language but I can't find a way to use the C#'s one here. Aggregate fit the need well. No transpose in C#, there is one in Excel but I wont use it.

Try it online!