灵感。*我不敢相信我们之前没有遇到过这样的挑战：

任务

给定一个或多个可打印的ASCII字符串，通过从每个字符串中取出一个字符来循环插入它们，直到出现字符不足。如果字符串先于其他字符用完，则从此以后跳过该字符串。

例子

SIMPLE 给 SIMPLE

POLLS并EPEES给PEOPLELESS

LYES并APRONS给LAYPERSONS

ABCDE并a c和123 567给Aa1B 2Cc3D E567

"\n$?*和​（空字符串）和,(.)" （尾随空格）给出",\(n.$)?"* （尾随空格）

^{*有较短的APL解决方案。}

果冻，1字节

Z

在线尝试！

内置的“移调”功能将完全对字符串列表执行此操作。

Python 2，101 89 86 69字节

我希望可以通过某种方式将其放入lambda，并通过使其递归来缩短它。这不是理想的，因为您希望移调更短，但是不幸的是，移调不是很短（到目前为止，我已经设法提出了）。

f=lambda s:' '*any(s)and''.join(x[:1]for x in s)+f([x[1:]for x in s])

旧解决方案：

w=input();o=''
while any(w):
 for i in range(len(w)):o+=w[i][:1];w[i]=w[i][1:]
print o

lambda s:''.join(''.join([c,''][c<' ']for c in x)for x in map(None,*[list(y)for y in s]))

w=input();o=''
while any(x>=' 'for x in w):
 for i in range(len(w)):o+=w[i][:1];w[i]=w[i][1:]
print o

^{感谢mathmandan使我感到愚蠢;）节省了我很多字节！（在旧的解决方案上）}

Perl 6的，34 32个字节

{[~] flat roundrobin |$_».comb}

{roundrobin(|$_».comb).flat.join}

一个lambda，它将字符串数组作为参数，并返回一个字符串。

（在线尝试）

CJam，4个字节

qN/z

在线尝试！

我们还可以为4个字节编写一个未命名的函数，该函数期望在堆栈顶部有一个字符串列表：

{zs}

在线尝试！

Pyth-3个字节

很简单，以后会在移动设备上添加扩展。

s.T

测试套件

s                         Join all the strings together
 .T                       Transpose, without chopping off overhang
  (Q implicit)

JavaScript（ES6），52 46字节

f=([[c,...s],...a])=>s+a?c+f(s+s?[...a,s]:a):c

将输入作为字符串数组，将输出作为单个字符串。

测试片段

f=([[c,...s],...a])=>s+a?c+f(s+s?[...a,s]:a):c

g=a=>console.log("Input:",JSON.stringify(a),"Output:",JSON.stringify(f(a)))

g(["SIMPLE"])
g(["POLLS","EPEES"])
g(["LYES","APRONS"])
g(["ABCDE","a c","123 567"])
g(["\"\\n$?*",",(.)\" "]) // Backslash and quote are escaped, but in/output are correct

Haskell，33个字节

import Data.List
concat.transpose

在Ideone上尝试。用法：

Prelude Data.List> concat.transpose$["ABCDE","a c","123 567"]
"Aa1B 2Cc3D E567"

不使用内置函数：（38 34字节）

f[]=[]
f x=[h|h:_<-x]++f[t|_:t<-x]

在Ideone上尝试。多亏Zgarb减少4个字节！用法：

Prelude> f["ABCDE","a c","123 567"]
"Aa1B 2Cc3D E567"

C，114 84字节

-20个字节，用于不计算长度。

i,b;f(char**s){b=1;while(b){i=-1;b=0;while(s[++i]>0)if(*s[i])putchar(*s[i]++),++b;}}

接受char指针数组，并要求最后一项为空指针（请参阅用法）。

脱胶和用法：

i,b;f(char**s){
 b=1;
 while(b){
  i=-1;
  b=0;
  while(s[++i]>0)
   if(*s[i])
    putchar(*s[i]++),++b;
 }
}


int main(){
 char*a[]={ 
//  "POLLS","EPEES"
//  "LYES","APRONS"
 "ABCDE","a c","123 567"
 ,0};
 f(a);
 puts("");
}

PHP，68 67字节

for(;$f=!$k=$f;$i++)for(;y|$v=$argv[++$k];$f&=""==$c)echo$c=$v[$i];

循环遍历命令行参数。用运行-r。

内循环之后$f是1所有字符串都结束的时间，0否则（按位&强制转换""==$c为int）。
外循环的下一个迭代：复制$f到$k（从节省一个字节$k=0）并切换$f：
完成所有字符串后，$f现在false是，循环中断。

视网膜，13字节

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

O$#`.
$.%`
¶

在线尝试！

说明

O$#`.
$.%`

这基于Retina中的标准转置技术。我们将（O）所有非换行字符（.）排序为（）$#，它们位于同一行（$.%`）前面的字符数，即其水平位置。

然后，第二阶段只需从输入中删除换行符。

Java中，19 + 155 = 174 160

String f(java.util.Queue<String> q){String s,r="";while(!q.isEmpty()){s=q.poll();r+=s.isEmpty()?"":s.charAt(0);if(s.length()>1)q.add(s.substring(1));}return r;}

取消高尔夫：

  String f(java.util.Queue<String> q) {
    String s, r = "";
    while (!q.isEmpty()) {
      s = q.poll();
      r += s.isEmpty() ? "" : s.charAt(0);
      if (s.length() > 1) {
        q.add(s.substring(1));
      }
    }
    return r;
  }

输出：

简单

无人

莱珀森

Aa1B 2Cc3D E567

“，（n。$）？” *

第一种修改：合并字符串声明以节省一些字节。删除后import，它也被需要的main()方法（此处未显示）使用LinkedList。Queue直接引用的字节较少。

PHP，77字节

打高尔夫球

function($a){for($d=1;$d!=$s;$i++){$d=$s;foreach($a as$v)$s.=$v[$i];}echo$s;}

需要一个字符串数组的匿名函数。

我敢肯定这可能会打更多，但这还为时过早。在每次迭代中，我们从每个给定的字符串中获取第i个字母，并将其一次附加到我们的最终字符串中。如果我们访问不存在的字符串，PHP只会发出警告，所以很好。我们仅在循环遍历所有字符串之后没有进行任何更改时才停止。

我觉得$d可以进一步打高尔夫球，但这还为时过早。：P

其实是7 6个字节

欢迎打高尔夫球！在线尝试！

编辑： -1字节感谢蓝绿色鹈鹕。

a Z♂ΣΣ

开球

          Implicit input each string.
a         Invert the stack so that the strings are in the correct order.
<space>   Get the number of items on the stack, len(stack).
Z         Zip all len(stack) strings into one, transposing them.
♂Σ        sum() every transposed list of chars into strings.
Σ         sum() again to join the strings together.

JavaScript（ES6），46个字节

f=([[c,...s],...a])=>c?c+f([...a,s]):a+a&&f(a)

<textarea oninput=o.textContent=f(this.value.split`\n`)></textarea><div id=o>

Python 2，58字节

lambda*m:''.join(map(lambda*r:''.join(filter(None,r)),*m))

在线尝试！

J，13个字节

({~/:)&;#\&.>

在线尝试！

基于此问题的启发。

另一种方法是占用27个字节，但使用转置操作。大多数字节用于处理填充中自动添加的零。

[:u:0<:@-.~[:,@|:(1+3&u:)&>

说明

({~/:)&;#\&.>  Input: list of boxed strings S
          &.>  For each boxed string x in S
        #\       Get the length of each prefix from shortest to longest
                 This forms the range [1, 2, ..., len(x)]
                 Rebox it
(    )         Operate on S and the prefix lengths
      &;         Raze both
   /:            Grade up the raze of the prefix lengths
 {~              Index into the raze of S using the grades
               Return

Bash + GNU实用程序，55

 eval paste `sed "s/.*/<(fold -1<<<'&')/g"`|tr -d \\n\\t

通过STDIN（行分隔）和STDOUT进行I / O。

将sed每一行的格式设置为bash进程替换。然后将它们eval编入paste进行实际的交织。 tr然后删除不必要的换行符和制表符。

Ideone。

PHP，63字节

注意：使用IBM-850编码

for(;$s^=1;$i++)for(;n|$w=$argv[++$$i];$s&=$x<~■)echo$x=$w[$i];

像这样运行：

php -r 'for(;$s^=1;$i++)for(;n|$w=$argv[++$$i];$s&=$x<~■)echo$x=$w[$i];' "\"\n\$?*" "" ",(.)\" " 2>/dev/null;echo
> ",\(n.$)?"* 

说明

for(                       # Iterate over string index.
  ;
  $s ^= 1;                 # Continue until $s (stop iterating) is 1.
                           # Flip $s so each iteration starts with $s
                           # being 1.
  $i++                     # Increment string index.
)
  for(
    ;
    "n" | $w=$argv[++$$i]; # Iterate over all input strings. OR with "n"
                           # to allow for empty strings.
    $s &= $x<~■            # If last character printed was greater than
                           # \x0 (all printable chars), set $s to 0,
                           # causing the loop to continue.
  )
    echo $x = $w[$i];      # Print char $i of current string.

Python 3，75字节

我知道另一个Python较短，但这是map我一生中第一次使用它，因此我为此感到自豪

lambda n:''.join(i[k]for k in range(max(map(len,n)))for i in n if len(i)>k)

C，75 71字节

唯一的限制是输出长度。目前是99，但可以轻松扩展到999（+1字节）。

i;main(a,b)char**b;{a--;for(;i<99;i++)*b[i%a+1]&&putchar(*b[i%a+1]++);}

取消高尔夫：

i;
main( a, b )
char **b;
{
    a--;
    for( ; i < 99; i++ )
        *b[i % a + 1] && putchar( *b[i % a + 1]++ );
}

Oracle SQL，195个字节

    select listagg(b,'') within group(order by l,o) from(select substr(a,level,1) b,level l,o from i start with length(a)>0 connect by prior a=a and level<=length(a) and prior sys_guid() is not null)

从i以列a（包含字符串）和o（字符串的顺序）命名的表中获取其输入：

    create table i (a varchar2(4000), a integer)

说明：
我们正在利用CONNECT BY将字符串分解为组成它们的每个字符。PRIOR SYS_GUID()为NOT NULL确保我们不会最终停留在循环。
然后，我们将单个字符与连接在一起，LISTAGG但是我们使用ORDER BY子句打乱，首先根据它们在原始字符串中的位置，然后再根据它们来自的字符串的顺序对其进行排序。

不像其他答案那么短，但是SQL并不是真正的字符串处理语言:)

蟒蛇2，128 96

我希望不必使用itertools

a=lambda a:"".join([i for i in reduce(lambda: b,c:b+c, map(None,*map(lambda m:list(m),a)) if i])

不打高尔夫球

 a=lambda a:                              #Start a lambda taking in a
    "".join(                              #Join the result together with empty string
        [i for i in reduce(               #For every item, apply the function and 'keep'
           lambda: b,c:b+c,               #Add lists from...
                map(None,*map(            #None = Identity function, over a map of...
                    lambda m:list(m), a)  #list made for mthe strings m
                   ) if i                 #truthy values only (otherwise the outer map will padd with None.
       ])

Perl 5个字节

26个字节的代码+ 2个-0n。

s/^./!print$&/gem while/./

在线尝试！

R，73字节

for(i in 1:max(nchar(s<-scan(,""))))for(j in seq(s))cat(substr(s[j],i,i))

在线尝试！

说明：非常简单（但很冗长），只需循环打印i第jth个字符串的字符即可。幸运的是，substr如果输入超出范围，则返回一个空字符串。

Python，112字节

i=len(x)if len(x)>len(y) else len(y) h=0 a="" while h<i: if h<len(x) a+=x[h] if h<len(y): a += y[h] h+=1 print a

Perl 5，53个字节

$i=0,map{push@{$a[$i++]},$_}/./g for<>;print@$_ for@a

在线尝试！

方法

创建一个二维数组，其中行数等于最长字符串的长度，最大列数等于字符串的数量。然后输出数组的每一行而没有间距。

TXR Lisp，20字节

(opip weave cat-str)

跑：

1> (opip weave cat-str)
#<intrinsic fun: 0 param + variadic>
2> [*1 "LYES" "APRONS"]
"LAYPERSONS"
3> [*1 "ABCDE" "a c" "" "123 567"]
"Aa1B 2Cc3D E567"
4> [*1 "\"\\n$?*" "" ",(.) "]
"\",\\(n.$)? *"

该weave函数是惰性的，因此它返回一个列表，这就是为什么我们必须将结果强制为字符串的原因。懒惰，它可以编织无限的序列。例如，我们可以编织偶数和奇数自然数，它们本身是无限的惰性列表：

5> (take 20 (weave (range 2 : 2) (range 1 : 2)))
(2 1 4 3 6 5 8 7 10 9 12 11 14 13 16 15 18 17 20 19)

K（oK），35 29字节

解：

{`c$r@&~^r:,/+(`i$x)[;!#,/x]}

在线尝试！

例：

> {`c$r@&~^r:,/+(`i$x)[;!#,/x]}("ABCDE";"a c";"123 567")
"Aa1B 2Cc3D E567"
> {`c$r@&~^r:,/+(`i$x)[;!#,/x]}("\n$?*";"";",(.)\" ")
"\n,$(?.*)\" "
> {`c$r@&~^r:,/+(`i$x)[;!#,/x]}("POLLS";"EPEES")
"PEOPLELESS"

说明：

使用第二级索引可以在所有输入列表中从0到最大值（平展列表的长度）提取索引。超出子列表范围的任何索引将返回null。翻转（旋转90），展平，然后拉出非零结果。

笔记：

• 我将其强制转换为整数（i$），以便获得有用的null，例如空格（对于字符列表，）被视为空值，这意味着您无法从有效空间中分辨出空值。
• 我也无法让TIO与输入配合使用（在ok repl中工作正常），因此TIO链接包括“ ABCDE” ...示例。

jQuery 1.5，49个字节

map(explode)|transpose|map(map(values)[])|implode

说明

                      # example input:          ["LYES","APRONS"]
  map(explode)        # make list of ordinals   [[76,89,69,83],[65,80,82,79,78,83]]
| transpose           # zip lists               [[76,65],[89,80],[69,82],[83,79],[null,78],[null,83]]
| map(map(values)[])  # rm nulls and flatten    [76,65,89,80,69,82,83,79,78,83]
| implode             # convert back to string  "LAYPERSONS"

样品运行

$ paste input <(jq -Mrc 'map(explode)|transpose|map(map(values)[])|implode' input)
["SIMPLE"]                  SIMPLE
["POLLS","EPEES"]           PEOPLELESS
["LYES","APRONS"]           LAYPERSONS
["ABCDE", "a c", "123 567"] Aa1B 2Cc3D E567
["\"\\n$?*", "", ",(.)\" "] ",\(n.$)?"* 

$ echo -n 'map(explode)|transpose|map(map(values)[])|implode' | wc -c
  49    

在线尝试