将n个长度为m的字符串转换为n个长度为m的字符串

16

编写一个程序，给定任何'n'个长度为'm'的字符串，并在以下条件下返回'm'个长度为'n'的字符串：

每个新字符串应包含与其他字符串相同索引的字母

例如，第一个输出字符串必须包含所有输入字符串的第一个字母，第二个输出字符串必须包含所有输入字符串的第二个字母，依此类推。

示例（字母下面的数字是字符串的索引）：

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

假设每次输入都是正确的

最短字节的代码获胜！

编辑：

由于有多种编程语言，并且每种语言都有很多可能的解决方案，因此我将针对每种编程语言和提供该语言的用户发布最短的解决方案。继续编码！

重新编辑：

多亏了用户Dennis，我为排行榜插入了一个代码段。

显示代码段

code-golf  string 
— 在这里输入名称
source
2
我们有一个排行榜摘要，您可以将其添加到问题正文中。无需手动操作。
— 丹尼斯
— msh210 '16
抱歉，我不知道它被称为“移调”
— 在此处输入名称
6
我不认为这些挑战是重复的，因为在另一个问题中，涉及参差不齐的换位和一些奇怪的空白处理的差异。虽然在某些语言中答案可能非常相似，但我认为大多数情况下它们的差异将足够大，因此不应重复。
— FryAmTheEggman'7
— FlipTack

Answers:

9

Python，36 29字节

zip(*s) 返回每个字符的元组列表，已转置。

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

在线尝试

— mbomb007
source
输出说"cdmy", "aoaa", "rgny"，这是一个列表["cdmy", "aoaa", "rgny"]或元组("cdmy", "aoaa", "rgny")
— mbomb007 '16
map(''.join,zip(*s))也适用于字符串转换（仅适用于Python 2），对于Python 3，[*map(''.join,zip(*s))]afaik也适用
— Value Ink
@ KevinLau-notKenny map(''.join,zip(*s))也适用于Python 3-默认情况下，我们允许迭代器/生成器代替列表。
— Mego
7

PowerShell v2 +，66 54字节

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

哟...不map，不zip，不transpose，等等，所以我们开始自己动手。@DarthTwon的12字节高尔夫的重要道具。

输入$n，建立for循环。初始化设置$x为0，测试的是单词中是否仍然有字母$n[0][$x]，并且$x++每次迭代都要递增。

在循环内部，我们采用字符串数组，将其通过管道传递到内部循环，该循环从每个单词中吐出适当的字符。将其封装在一个-join字符串中，然后将该字符串留在管道中。在执行结束时，管道上的字符串被隐式打印。

PS C:\Tools\Scripts\golfing> .\convert-n-strings.ps1 "Darth","-Twon","Rocks"
D-R
aTo
rwc
tok
hns
— AdmBorkBork
source
1
很好，这就是我想看到的答案；）这太简单了，,而不是思考答案
— 在此处输入名称
使用while循环可以进一步减少这种情况：param($n)$x=0;while($n[0][$x]){-join($n|%{$_[$x]});$x++}。而且这里没有错误：D
— ThePoShWolf '16
@DarthTwon非常好。或者，使用for另外两个循环。;-)
— AdmBorkBork
嗯...我尝试过，但是在真正减少while循环次数之后才尝试。先生，辛苦了！
— ThePoShWolf
您可以在Powershell中使用Linq吗？
— aloisdg移至codidact.com，2016年
7

Vim，37 36击键

所有其他答案都很无聊，并且使用了无聊的单字节内置函数。这是一个很拙劣的答案，可以用一种甚至不是编程语言的方式手动完成全部操作：

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

说明：

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

现在，一切都很好，但是缓冲区中还有一些多余的文本。因此，我们必须：

`a                              "Move to mark 'a'
  dgg                           "And delete everything until the first line
— DJMcMayhem
source
5

CJam，6个 5字节

感谢Luis Mendo，节省了1个字节。

qS%zp

在线尝试！

q      e# Get all input
 S%    e# Split it on spaces
   z   e# Take the transpose
    p  e# Print it as an array
— 商务猫
source
4

视网膜，45 43字节

字节数假定为ISO 8859-1编码。

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

前导换行很重要。输入和输出是可打印ASCII字符串的换行符终止列表（请注意，两者都具有单个尾随换行符）。

在线尝试！

我有一阵子知道，在视网膜中放置矩形块会很痛苦（而放置正方形并不算太糟），但从未尝试过。第一个解决方案的确确实是一个高达110字节长的方法，但是在对该方法进行了几处重大更改之后，所得到的45个字节到目前为止还没有我怀疑的那么糟（但仍然...）。明天将进行解释。

说明

阶段1：排序

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

这完成了对输入中的字符进行重新排序的主要工作，但是最终将分隔符弄乱了。有趣的是，如果删除|¶，我们将获得转置平方输入所需的代码。

排序阶段（由表示O）的工作方式是这样的：它们找到给定正则表达式的所有匹配项（之后的东西`），然后对这些匹配项进行排序并将它们重新插入找到匹配项的位置。碰巧的是，此正则表达式匹配每个单个字符：.(?<=(.*))替代字符中的非换行符和字符中的换行符。因此，它将对输入中的所有字符进行排序。更有趣的部分是它们的排序依据。

该$选项激活“排序”模式，其中每个匹配项都用第二行上的替换模式替换，然后用于比较匹配项。此外，#告诉Retina将替换结果转换为整数，并比较这些整数（而不是将它们视为字符串）。

最后，我们需要查看正则表达式和替换。如果第一个替代项匹配（即我们已经匹配了其中一行中的任何字符），则(?<=(.*))捕获会将直到该行中该字符的所有内容捕获到group中1。在$.1与在取代模式取代此长度组1。因此，每个字符串中的第一个字符变为1，第二个变为2，第三个变为3等等。现在应该清楚这是如何转置方形输入的：所有行的所有第一个字符都排在最前一行，然后所有所有第二个字符在第二行都以此类推。但是对于这些矩形输入，我们还要匹配换行符。自组1在这种情况下未使用时，替换为空，但出于选择的目的，将#其视为0。这意味着，所有换行符都排在最前面。

因此，现在我们确实具有第一顺序的字符（每个字符串的第一个字符，每个字符串的第二个字符，等等），并且所有换行符都位于开头。

阶段2：比赛

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

现在，我们需要将字符分成正确长度的行。该长度对应于原始输入中的行数，它对应于我们在字符串开头处的换行数。

这里是在match阶段的帮助下完成拆分的，该阶段仅查找给定正则表达式的所有匹配项，并使用!选项来打印这些匹配项（默认情况下将对它们进行计数）。因此，正则表达式的目标是一次匹配一行。

我们通过“计数”与回顾后对方的电话号码(?<=(¶)*.*)。它1为前端的每个换行生成一个捕获。

然后，对于每个捕获，我们将一个字符与匹配(?<-1>.)+。

— 马丁·恩德
source
4

x86机器码，19个字节

十六进制：

fc89d35651a401dee2fb91aa595e464a75f1c3

输入：：ECX字符串数（n），：EDX单个字符串长度（m）ESI，：输入字符串数组，EDI：输出缓冲区，接收字符串数组。假定将数组定义char src[n][m+1]为输入和char dst[m][n+1]输出，并且所有字符串均以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
— 梅登
source
3

Brachylog，5个字节

z:ca.

需要一个字符串列表作为输入，例如 run_from_atom('z:ca.',["money":"taken":"trust"],Output).

说明

z       Zip the strings in the Input list
 :ca.   output is the application of concatenation to each element of the zip
— 致命
source
3

05AB1E，3个字节

ø€J

解释

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

在线尝试

— 艾米尼亚
source
2

JavaScript ES6，48 个 46字节

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

我感到被排除在外，我们没有内置的zip功能。感谢nicael指出我的类型错误。

用法

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

退货

["ad","ss","da"]
— 烧焦草
source
异常：TypeError：a [0] .map不是函数
— edc65 '16
1
您需要[...a[0]].map，因为a[0]它不是数组。
— nicael
@nicael谢谢。弄乱了类型。这证明了为什么我不应该在今早打高尔夫球。
— charredgrass
@nicael我教.join他们解决该问题。
— charredgrass
1
join`` 而不是join('')节省2个字节。Downvote撤回
— edc65 '16
2

Bash + BSD实用程序，27

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

通过STDIN / STDOUT用换行符分隔的字符串进行I / O。

您可能需要rs使用sudo apt install rs或类似版本进行安装。在OS X上开箱即用。

该-T选项可rs进行繁重的移调。其余的只是格式化：

  • 该sed命令仅:在每个字符后插入
  • -c:指定输入列是:分开的
  • -g0 指定输出列的宽度分隔为零

如果我对手册rs页的阅读是正确的，那么以下内容应能得分为12，但不幸的是它不起作用-请参见以下注释：

rs -E -g0 -T

输出示例：

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

如果期望输入全部为可打印的ASCII，则输入 :可以将其替换为某些不可打印的字符，例如0x7 BEL。

注意

我想了解为什么我无法-E选择工作并摆脱sed预处理。我找到了rs源代码在这里。如您所见，提供此选项可设置ONEPERCHAR标志。但是，代码中没有任何内容可以实际检查此标志的状态。因此，我认为可以说，尽管记录了选项的事实，但尚未实现。

实际上，Linux中记录了该选项 rs页中：

-E将输入的每个字符视为数组条目。

但不是OS X版本。

— 数字创伤
source
2

PHP，82字节

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

接受并返回一个字符串数组

分解

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

例子

$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>';
}
— 提图斯
source
2

APL，3个字节

↓⍉↑

↑接受输入字符串并将其转换为char矩阵。 ⍉转置矩阵。 ↓将结果矩阵的行拆分回字符串。

— 斯蒂芬诺
source
1

Mathematica，26个字节

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

匿名函数。将字符串列表作为输入，并返回字符串列表作为输出。Unicode字符为U + F3C7，表示\[Transpose]。通过转换为字符矩阵，转置并转换回字符串列表来工作。如果输入/输出格式被拉伸，那么一个简单的5字节转置将起作用：

#&
— 军团哺乳动物978
source
+1你击败了我！（但是我无法使用“移调”符号。）顺便说一句，为什么T不显示在屏幕上？（当我将您的代码复制到Mathematica时就在那里。）
— DavidC
@DavidC Unicode字符位于“专用区域”中，该区域被标记为专有字符的一部分，因此，既没有正式分配字形，也没有使用大多数字体进行渲染。Mathematica的字体恰好将此字符呈现为下标T并将其解释为\[Transpose]。
— LegionMammal978 '16
@DavidC他们为什么不使用ᵀ？
— 亚当
@AdámIDK，您必须向Wolfram Research询问，而不是向我询问
— LegionMammal978
@ LegionMammal978不，只要我有APL的明显表现，我就很高兴 ⍉。
— 2013年
1

MATLAB /八度，4字节

@(x)x'

这定义了一个匿名函数。输入格式为['car'; 'dog'; 'man'; 'yay']。

在这里尝试。

— 路易斯·门多
source
此解决方案的输入格式是什么？我不认为它会与Matlab的方式把手字符串的工作，如果你试图输入他们在一个Matlabby的方式，例如f = @(x)x'，f([{'abcd'},{'abcd'},{'abcd'}])输出ANS =“ABCD”“ABCD”“ABCD”
— sintax
@sintax输入格式应为2D char数组，如答案中链接的示例所示。您正在使用字符串的单元格数组（通过连接单例单元格数组获得）。应该是：f(['abcd';'abcd';'abcd'])。我已经编辑了答案以指定输入格式
— Luis Mendo
1

Haskell，41个字节

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

或者有更多的空气：

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

第二个列表是重复“单词的长度”时间的单词列表。在每个单词列表上，我们选择每个单词的第n个字母，得出结果。

— villou24
source
1
不需要完整的程序，因为“程序”表示“程序或功能”，因此功能就足够了。您可以传递并返回字符串列表，因此省略words和unwords。更进一步，map(\_->l)(l!!0)是l<*l!!0，因此归结为\l->zipWith($)[map(!!n)|n<-[0..]]$l<$l!!0。
— nimi
哦，非常感谢：）我正在更新。
— villou24 '16
糟糕，错别字：（l<$l!!0第一次错了，第二次错了），但是您还是正确的。
— nimi
1

Common Lisp，62个字节

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

该map函数采用结果类型（在此处list），要应用的函数f以及一个或多个序列s1，...，sn。所有序列都是并行迭代的。对于从这些序列中获取的每个元组元素（e1，...，en），我们称（f e1 ... en），结果以所需类型的序列累加。

我们说一个字符串列表("car" "dog" "man" "yay")，然后使用applycall map。我们必须这样做，以便将输入列表用作的更多参数map。更准确地说，这是：

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

...相当于：

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

并且由于字符串是序列，所以我们在所有第一个字符，然后在所有第二个字符等上并行进行迭代。例如，第一次迭代调用 按以下方式 f：

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

匿名lambda接受为其提供的参数列表，并将其强制返回字符串。

— 核心转储
source
0

Ruby，46个字节

可能第一次“ Ruby字符串不是Enumerables”实际上使我很痛苦，因为我必须在处理之前将字符串映射到数组中。（通常不必使用String#chars字节损失就足够了，但是由于我需要映射它们，因此刺痛了很多）

->s{s.map!(&:chars).shift.zip(*s).map &:join}
— 价值墨水
source
0

Clojure，68个字节

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

映射一个函数 reduce在从0到第一个字符串的长度范围内（在列表的元素上一个接一个，并连接字符串的第n个字符）。

在线查看：https：//ideone.com/pwhZ8e

— 悬崖根
source
0

C＃，53个字节

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

C＃lambda（Func），输出为IList<string>，输出为IEnumerable<string>。我不知道如何zip用其他语言工作，但是我找不到使用C＃语言的方法在这里。Aggregate非常适合需要。在C＃中没有转置，在Excel中有一个，但是我不会使用它。

在线尝试！

— aloisdg移至codidact.com
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.