Schreiben Sie ein Programm, das bei einer gegebenen Anzahl von 'n' Zeichenfolgen mit 'm' Länge 'm' Anzahl von 'n' Zeichenfolgen mit folgender Bedingung zurückgibt:

Jede neue Zeichenfolge sollte die Buchstaben am selben Index wie die anderen Zeichenfolgen enthalten

Beispielsweise muss die erste Ausgabezeichenfolge den ersten Buchstaben aller Eingabezeichenfolgen enthalten, die zweite Ausgabezeichenfolge muss den zweiten Buchstaben aller Eingabezeichenfolgen enthalten und so weiter.

Beispiele (die Zahlen unter den Buchstaben sind die Indizes der Zeichenfolgen):

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

Angenommen, die Eingabe ist immer korrekt

Kürzester Byte-Code gewinnt!

Bearbeiten:

Da es viele Programmiersprachen gibt und es für jede davon viele mögliche Lösungen geben könnte, werde ich die kürzeste Lösung für jede Programmiersprache und den Benutzer, der sie bereitgestellt hat, veröffentlichen. Kodierung beibehalten!

Neu bearbeiten:

Dank Benutzer Dennis habe ich ein Snippet für die Bestenlisten eingefügt.

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 Byte

C

Probieren Sie es hier aus

Eine weitere Transponierung eingebaut

Python, 36 29 Bytes

zip(*s) gibt eine Liste von Tupeln jedes Zeichens zurück, transponiert.

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

Probieren Sie es online aus

Gelee , 1 Byte

Z

Probieren Sie es online!

MATL , 1 Byte

!

Probieren Sie es online!

Nimmt Eingaben implizit auf, transponiert und zeigt Ausgaben implizit an.

PowerShell v2 +, 66 54 Bytes

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

Yo ... nein map, nein zip, nein transpose, usw., also können wir unsere eigenen rollen. Große Requisiten an @DarthTwon für das 12-Byte-Golf.

Nimmt Eingaben auf $n, richtet eine forSchleife ein. Die Initialisierung setzt $xauf 0, der Test ist , ob wir noch Briefe in unserem Wort haben $n[0][$x], und wir erhöhen bei $x++jeder Iteration.

Innerhalb der Schleife nehmen wir unser String-Array und leiten es zu einer inneren Schleife, die aus jedem Wort das entsprechende Zeichen ausspuckt. Das wird in a gekapselt -join, um eine Zeichenfolge zu bilden, und diese Zeichenfolge verbleibt in der Pipeline. Am Ende der Ausführung werden die Zeichenfolgen in der Pipeline implizit gedruckt.

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

Vim, 37 36 Tastenanschläge

Alle anderen Antworten sind langweilig und verwenden langweilige Single-Byte-Builtins. Hier ist eine knifflige Antwort, die das Ganze manuell erledigt, in etwas, das nicht einmal eine Programmiersprache ist:

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

Erläuterung:

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

Jetzt ist alles in Ordnung, aber der Puffer enthält noch zusätzlichen Text. Also müssen wir:

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

CJam, 6 5 Bytes

1 Byte dank Luis Mendo gespeichert.

qS%zp

Probieren Sie es 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

,

Probieren Sie es hier aus!

Transponieren.

Retina , 45 43 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Der Zeilenvorschub ist signifikant. Eingabe und Ausgabe sind Zeilenvorschub-terminierte Listen druckbarer ASCII-Zeichenfolgen (beachten Sie, dass beide einen einzelnen nachgestellten Zeilenvorschub haben).

Probieren Sie es online!

Ich wusste für eine Weile, dass das Transponieren von rechteckigen Blöcken eine Belastung für die Netzhaut sein würde (wohingegen das Transponieren von Quadraten nicht allzu schlimm ist), habe es aber nie wirklich versucht. Die erste Lösung war in der Tat satte 110 Bytes lang, aber nach einigen wesentlichen Änderungen im Ansatz sind die resultierenden 45 Bytes bei weitem nicht so schlecht, wie ich vermutet habe (aber immer noch ...). Erklärung folgt morgen.

Erläuterung

Stufe 1: Sortieren

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

Dies erledigt die Hauptarbeit des Neuordnens der Zeichen in der Eingabe, führt jedoch dazu, dass die Trennung in Zeilen durcheinander gebracht wird. Interessanterweise, wenn wir die entfernen|¶ , den Code, der erforderlich ist, um eine Quadrateingabe zu transponieren.

Sortierphasen (gekennzeichnet durch O) funktionieren wie folgt: Sie finden alle Übereinstimmungen des angegebenen regulären Ausdrucks (das Ding nach dem `), sortieren diese Übereinstimmungen und fügen sie erneut an den Stellen ein, an denen die Übereinstimmungen gefunden wurden. Dieser reguläre Ausdruck entspricht zufällig jedem einzelnen Zeichen: Nicht-Zeilenvorschub über die .(?<=(.*))Alternative und Zeilenvorschub über die ¶. Daher werden alle Zeichen in der Eingabe sortiert. Der interessantere Teil ist, was sie sortiert sind durch .

Die $Option aktiviert einen "Sortieren nach" -Modus, in dem jede Übereinstimmung durch das Substitutionsmuster in der zweiten Zeile ersetzt wird, das dann zum Vergleichen der Übereinstimmungen verwendet wird. Darüber hinaus ist die# weist Retina an, das Ergebnis der Ersetzung in eine Ganzzahl umzuwandeln und diese Ganzzahlen zu vergleichen (anstatt sie als Zeichenfolgen zu behandeln).

Schließlich müssen wir uns den regulären Ausdruck und die Substitution ansehen. Wenn die erste Alternative zutrifft (dh wir haben ein Zeichen in einer der Zeilen gefunden), (?<=(.*))fängt das Programm alles bis zu diesem Zeichen in dieser Zeile in Gruppen ein 1. Das $.1in dem Substitutionsmuster ersetzt dies durch die Länge der Gruppe 1. Daher wird das erste Zeichen in jeder Zeichenfolge 1, das zweite wird2 das dritte 3und so weiter. Es sollte jetzt klar sein, wie dies eine Quadrateingabe transponiert: Alle ersten Zeichen der Zeilen kommen zuerst und landen alle in der obersten Zeile, dann enden alle zweiten Zeichen in der zweiten Zeile und so weiter. Für diese rechteckigen Eingänge passen wir jedoch auch die Zeilenvorschübe an. Seit Gruppe1Wird in diesem Fall nicht verwendet, ist die Ersetzung leer, dies wird jedoch für die Zwecke der #Option berücksichtigt 0. Das heißt, alle Zeilenvorschübe werden nach vorne sortiert.

Jetzt haben wir also die Zeichen in der ersten Reihenfolge (erstes Zeichen jeder Zeichenfolge, zweites Zeichen jeder Zeichenfolge usw.) und alle Zeilenvorschübe am Anfang.

Stufe 2: Match

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

Wir müssen jetzt die Zeichen in Zeilen der richtigen Länge aufteilen. Diese Länge entspricht der Anzahl der Zeilen in der ursprünglichen Eingabe, die der Anzahl der Zeilenvorschübe entspricht, die wir am Anfang der Zeichenfolge haben.

Die Aufteilung erfolgt hier mit Hilfe einer Match-Phase, die einfach alle Übereinstimmungen des angegebenen Regex findet und die !Option verwendet, um diese Übereinstimmungen auszudrucken (standardmäßig werden sie stattdessen gezählt). Das Ziel des regulären Ausdrucks besteht also darin, jeweils eine Zeile abzugleichen.

Wir beginnen mit dem "Zählen" der Zahl mit dem Lookbehind (?<=(¶)*.*). Es wird eine Erfassung in der Gruppe 1für jeden Zeilenvorschub an der Vorderseite generiert .

Dann ordnen wir für jede dieser Erfassungen ein einzelnes Zeichen zu (?<-1>.)+.

x86-Maschinencode, 19 Byte

In hex:

fc89d35651a401dee2fb91aa595e464a75f1c3

Eingabe:: Anzahl ECXder Zeichenfolgen (n) EDX,: Länge der einzelnen Zeichenfolgen (m) ESI,: Array von Eingabezeichenfolgen,: EDIAusgabepuffer, der ein Array von Zeichenfolgen empfängt. Es wird davon ausgegangen, dass das Array sowohl char src[n][m+1]für die Eingabe als auch char dst[m][n+1]für die Ausgabe definiert ist und alle Zeichenfolgen mit NULL-Abschluss versehen sind.

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 Bytes

z:ca.

Erwartet eine Liste von Zeichenfolgen als Eingabe, z run_from_atom('z:ca.',["money":"taken":"trust"],Output).

Erläuterung

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

Erklärt

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

Probieren Sie es online aus

CJam , 3 Bytes

{z}

Dies ist ein Codeblock (äquivalent zu einer Funktion; standardmäßig zulässig ), der die Eingabe auf dem Stapel erwartet und die Ausgabe auf dem Stapel belässt.

Probieren Sie es online!

JavaScript ES6, 48 46 Bytes

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

Ich fühle mich ausgeschlossen, wir haben keine eingebaute Zip-Funktion. Danke nicael für den hinweis auf meinen typenfehler.

Verwendung

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

kehrt zurück

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

Bash + BSD-Dienstprogramme, 27

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

E / A über durch STDIN / STDOUT durch Zeilenumbrüche getrennte Zeichenfolgen.

Möglicherweise müssen Sie rsmit sudo apt install rsoder ähnlich installieren . Funktioniert sofort unter OS X.

Die -TOption, um rsdas schwere Heben der Umsetzung zu tun. Der Rest ist nur die Formatierung:

• Das sed Befehl wird einfach :nach jedem Zeichen eingefügt
• -c: Gibt an, dass Eingabespalten sind : getrennt werden
• -g0 Gibt an, dass Ausgabespalten eine Breite von Null haben

Wenn meine Lektüre der rsmanpage richtig ist, dann folgende sollte für eine Punktzahl von 12 arbeiten, aber leider funktioniert es nicht - siehe Anmerkung unten:

rs -E -g0 -T

Beispielausgabe:

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

Wenn erwartet wird, dass die Eingabe vollständig druckbares ASCII ist, wird das :möglicherweise durch ein nicht druckbares Zeichen ersetzt, z. B. 0x7BEL . .

Hinweis

Ich wollte verstehen, warum ich nicht die -EMöglichkeit hatte zu arbeiten und die sedVorverarbeitung loszuwerden . Ich habe den rsQuellcode hier gefunden . Wie Sie sehen können, setzt die Angabe dieser Option dasONEPERCHAR Flag. Der Code enthält jedoch nichts, was den Status dieses Flags überprüft. Wir können also sagen, dass diese Option, obwohl sie dokumentiert ist, nicht implementiert ist.

Tatsächlich ist diese Option in der Linux- rsManpage dokumentiert:

-E Betrachte jedes Zeichen der Eingabe als einen Array-Eintrag.

aber nicht die OS X-Version.

PHP, 82 Bytes

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

nimmt und gibt ein Array von Strings zurück

Nervenzusammenbruch

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

Beispiele

$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

↓⍉↑

↑Nimmt die Eingabezeichenfolgen und verwandelt sie in eine Zeichenmatrix. ⍉transponiert die Matrix. ↓Teilt die Zeilen der resultierenden Matrix in Strings auf.

K, 1 Byte

+

Probieren Sie es hier aus!

Transponieren

Mathematica, 26 Bytes

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

Anonyme Funktion. Nimmt eine Stringliste als Eingabe und gibt eine Stringliste als Ausgabe zurück. Das Unicode-Zeichen ist U + F3C7 und steht für \[Transpose]. Konvertiert in eine Zeichenmatrix, transponiert und konvertiert zurück in eine Zeichenfolgenliste. Wenn das Eingabe- / Ausgabeformat gestreckt wäre, würde eine einfache 5-Byte-Transponierung funktionieren:

#&

MATLAB / Octave, 4 Bytes

@(x)x'

Dies definiert eine anonyme Funktion. Eingabeformat ist ['car'; 'dog'; 'man'; 'yay'].

Probieren Sie es hier aus .

Haskell, 41 Bytes

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

Oder mit etwas mehr Luft:

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

Die zweite Liste ist die Liste von Wörtern, die sich "die Länge eines Wortes" Mal wiederholen. In jeder Liste von Wörtern wählen wir den n-ten Buchstaben jedes Wortes aus und geben das Ergebnis an.

Common Lisp, 62 Bytes

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

Die mapFunktion nimmt einen Ergebnistyp (hier list), eine anzuwendende Funktion f und eine oder mehrere Folgen s1 , ..., sn . Alle Sequenzen werden parallel durchlaufen. Für jedes Tupel von Elementen (e1, ..., en), die aus diesen Sequenzen entnommen wurden, rufen wir (fe1 ... en) auf und das Ergebnis wird in einer Sequenz des gewünschten Typs akkumuliert.

Wir nehmen eine Liste von Strings, sagen wir ("car" "dog" "man" "yay"), und verwenden sie, applyum anzurufen map. Wir müssen dies tun, damit die Eingabeliste als Argument für mehr verwendet wird map. Genauer gesagt:

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

... ist äquivalent zu:

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

Und da Strings Sequenzen sind, iterieren wir parallel über alle ersten Zeichen, dann über alle zweiten Zeichen usw. Die erste Iteration ruft beispielsweise f wie folgt auf:

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

Das anonyme Lambda nimmt die Liste der Argumente und zwingt sie zu einer Zeichenfolge zurück.

Perl, 91 Bytes

So lange ein ..

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

Probieren Sie es hier aus!

Ruby, 46 Bytes

Wahrscheinlich ist das erste Mal, dass "Ruby-Strings keine Enumerables" sind, ein heftiger Biss für mich, da ich die Strings vor der Verarbeitung in Arrays abbilden musste. (Normalerweise String#charsreicht es nicht aus, Byteverluste zu verwenden , um eine Rolle zu spielen, aber da ich sie abbilden muss, sticht es viel mehr)

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

Ordnet eine Funktion zu, die gerecht ist reduce im Bereich von 0 bis zur Länge der ersten Zeichenfolge (geht nacheinander auf Elemente der Liste und verbindet das n-te Zeichen der Zeichenfolge).

Sehen Sie es online: https://ideone.com/pwhZ8e

C #, 53 Bytes

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

C # lambda ( Func) wo die Ausgabe ist IList<string>und die Ausgabe ist IEnumerable<string>. Ich weiß nicht, wie man zipin einer anderen Sprache arbeitet, aber ich kann hier keinen Weg finden, das C # zu benutzen . Aggregatepassen die Notwendigkeit gut. Keine Transponierung in C #, es gibt eine in Excel, aber ich verwende sie nicht.

Probieren Sie es online!