给定一个字符串切片列表的输入，输出原始字符串。

每个切片将以长度2的列表形式给出，其中包含切片的起始位置（整数≥0）和切片本身。如果您的语言不支持任意类型的数组，则也可以将其作为结构或类似结构，或仅由数字，空格和切片组成的字符串。

每个切片的两个元素的顺序由您决定。此外，如果您选择将切片的表示形式用作长度为2的数组，则可以将输入作为二维数组或单个平面数组。最后，代表位置的整数可以是零索引或一索引（此处所有示例均为零索引）。

输入将始终足以确定直到给定最高位置的整个字符串。也就是说，将没有“漏洞”或“缺口”。因此，输出中不得包含任何多余的尾随或前导字符（典型的可选尾随换行符除外）。输入将始终是一致的，并且没有片段会相互冲突。

因为这是code-golf，所以以字节为单位的最短代码将获胜。

测试用例：

In                                                Out
-----------------------------------------------------------
[[2, "CG"], [0, "PP"], [1, "PC"]]               | PPCG
[[0, "foobarbaz"]]                              | foobarbaz
[[0, "foobar"], [6, "baz"]]                     | foobarbaz
[[2, "ob"], [5, "rba"], [0, "fooba"], [8, "z"]] | foobarbaz
[[0, "fo"], [0, "fooba"], [0, "foobarbaz"]]     | foobarbaz

果冻，10 9个字节

Ḣ0ẋ;Fµ€o/

在线尝试！

怎么运行的

Ḣ0ẋ;Fµ€o/  Main link. Input: A (list of pairs)

     µ€    Convert the chain to the left into a link, and apply it to each pair.
Ḣ          Pop the first element.
 0ẋ        Yield a list of that many zeroes.
   ;F      Concatenate the list of zeroes with the popped, flattened pair.
       o/  Reduce the generated lists by logical OR.
           Since all characters are truthy, this overwrites zeroes with characters,
           but never characters with zeroes.

Python 2，49字节

lambda l:`map(max,*[' '*n+s for n,s in l])`[2::5]

首先，通过用空格填充字符串的偏移量来对齐字符串（为清楚起见，显示为下划线）

[[2, "CG"], [0, "PP"], [1, "PC"]] 

__CG
PP
_PC

然后，使用mapto zip并取每列的最大值，这将忽略None一些字符串太短的较小的空格（可打印的最小字符）和s 的较小值。

__CG
PP
_PC

PPCG

最后，''.join使用[2::5]技巧来字符串。

Perl，25岁

为+2 -lp

从STDIN获取输入，例如

perl -lp slices.pl
2 CG
0 PP
1 PC

（用^ D或^ Z或任何在系统上关闭STDIN的东西关闭）

slices.pl：

/ /;$r|=v0 x$`.$'}{*_=r

JavaScript（ES6），61个字节

a=>a.map(([o,s])=>[...s].map(c=>r[o++]=c),r=[])&&r.join``

编辑：由于@ edc65，节省了4个字节。

Haskell，57个字节

import Data.List
map snd.sort.nub.(>>= \(n,s)->zip[n..]s)

用法示例：

*Main> map snd.sort.nub.(>>= \(n,s)->zip[n..]s) $ [(2,"CG"),(0,"PP"),(1,"PC")]
"PPCG"

工作原理：(index,letter)为每个切片的每个字母成对，连接成一个列表，删除重复项，按索引排序，删除索引。

MATL，15字节

''i"@Y:Y:tn:b+(

与语言/编译器的当前版本（13.0.0）一起使用。

输入带有大括号和单引号。（MATLAB / MATL中的大括号定义了单元格数组，它们是可以包含任意（可能是不同类型）内容的列表。）因此，测试用例为：

{{2, 'CG'}, {0, 'PP'} {1, 'PC'}}
{{0, 'foobarbaz'}}
{{0, 'foobar'}, {6, 'baz'}}
{{2, 'ob'}, {5, 'rba'}, {0, 'fooba'}, {8, 'z'}}
{{0, 'fo'}, {0, 'fooba'}, {0, 'foobarbaz'}}

在线尝试！

''      % push empty string. This will be filled with the slices to produce the result
i       % take input: cell array of cell arrays. For example: {{0, 'foobar'}, {6, 'baz'}}
"       % for each (1st-level) cell
  @     %   push that cell. Example: {{0, 'foobar'}}
  Y:    %   unpack (1st-level) cell, i.e. push its contents. Example: {0, 'foobar'}
  Y:    %   unpack (2nd-level) cell array: gives number and substring. Example: 0, 'foobar'
  tn:   %   duplicate substring and generate vector [1,2,...,n], where n is length of
        %   current substring (in the example: 6)
  b+    %   add input number that tells the position of that substring within the whole
        %   string (in the example: 0; so this gives [1,2,...,6] again)
  (     %   assign substring to the total string, overwriting if necessary. Note that
        %   MATL uses 1-indexing
        % end for each
        % implicit display

DUP，14个字节

[0[$;$][,1+]#]

Try it here.

匿名lambda。用法：

2"CG"0"PP"1"PC"[0[$;$][,1+]#]!

注意：DUP确实没有数组，所以我希望这种输入格式可以。

说明

好吧，DUP的字符串理解很有趣。字符串存储为一系列数字变量，每个数字变量都包含字符串中的一个字符代码。类似于2"CG"将2压入堆栈，然后创建索引从2开始的字符串。

因为这些索引实际上是变量，所以它们可以被覆盖。这就是输入的实际作用：覆盖！尝试按Step一下翻译站点，以获取更好的主意。此后，我们得到一个未切片的字符串。

这是输出的来源。

[            ] {lambda}
 0             {push 0 to the stack as accumulator}
  [   ][   ]#  {while loop}
   $;$         {duplicate, get var at TOS value, see if that var is defined}
        ,1+    {if so, output charcode at TOS and increment accumulator}

PHP，146个字符

注意：始终评估用户输入是一个好主意。

打高尔夫球

<?$a=[];$f=0;eval("\$b={$argv[1]};");foreach($b as$d){$f=$d[0];$e=str_split($d[1]);foreach($e as$c){$a[$f++]=$c;}}ksort($a);echo join('',$a)."\n";

不打高尔夫球

<?php
$array = array();
$p = 0;
eval("\$input = {$argv[1]};");
foreach($input as $item)
{
    $p = $item[0];
    $str = str_split($item[1]);
    foreach($str as $part)
    {
        $array[$p++] = $part;
    }
}
ksort($array);
echo join('', $array)."\n";
?>

您可以看到，我只是将输入写入每个字符具有特定键的数组，然后将其全部输出。

测验

php unslice.php '[[0, "foobar"], [6, "baz"]]' -> foobarbaz

php unslice.php '[[2, "CG"], [0, "PP"], [1, "PC"]]' -> PPCG

php shorten.php unslice.php->脚本缩短了107个字符。：D

严重的是48个字节

,`i@;l(;)+(x@#@k`M;`i@X@M`MMu' *╗`iZi`M`i╜T╗`MX╜

严重严重不利于字符串操作。

在线尝试！

说明：

,`i@;l(;)+(x@#@k`M;`i@X@M`MMu' *╗`iZi`M`i╜T╗`MX╜
,                                                 get input
 `              `M;                               perform the first map and dupe
                   `     `MM                      perform the second map, get max element
                            u' *╗                 increment, make string of that many spaces, save in reg 0
                                 `   `M           third map
                                       `    `M    fourth map
                                              X╜  discard and push register 0

地图1：

i@;l(;)+(x@#@k
i@;l            flatten, swap, dupe string, get length
    (;)+(       make stack [start, end, str]
         x@#@k  push range(start, end), explode string, make list of stack

地图2：

i@X@M
i@X     flatten, swap, discard (discard the string)
   @M   swap, max (take maximum element from range)

地图3：

iZi  flatten, zip, flatten (make list of [index, char] pairs)

地图4：

i╜T╗  flatten, push reg 0, set element, push to reg 0

简而言之，该程序创建一个带n空格的字符串，其中n是基于输入的字符串的最小长度。它确定每个片段中每个字符的结果字符串中的索引，并将该索引处的结果字符串中的字符设置为该字符。

Python，91个字节。

感谢cat，节省了1个字节。

有点长 我会再打一点。

def f(x):r={j+i:q for(i,s)in x for j,q in enumerate(s)};return"".join(map(r.get,sorted(r)))

Python，119115字节

def f(x,s=""):
 x.sort()
 for e in x:
  a=e[0];b=e[1]
  for i,c in enumerate(b):
   if len(s)<=(i+a):s+=c
 return s

测试用例

CJam，26个字节

q~{~0c*\+}%{.{s\s|}}*e_0c-

在线尝试！。以形式输入[["CG"2]["PP"0]["PC"1]]。

说明：

q~           Read and eval input

{~0c*\+}%    Convert input strings into workable format
{      }%     Map onto each input
 ~            Evaluate
  0c          Null character
    *\+       Multiply by input number and concat to string

{.{s\s|}}*   Combine strings
{       }*    Fold array
 .{    }       Vectorize, apply block to corresponding elements of arrays
   s\s         Convert elements to strings
      |        Set Union

e_0c-        Remove null characters

R，181字节

n=nchar;m=matrix(scan(,'raw'),ncol=2,byrow=T);w=rep('',max(n(m[,2])+(i<-strtoi(m[,1]))));for(v in 1:nrow(m)) w[seq(i[v]+1,l=n(m[v,2]))]=unlist(strsplit(m[v,2],''));cat("",w,sep="")

带换行符：

n=nchar
m=matrix(scan(,'raw'),ncol=2,byrow=T)
w=rep('',max(n(m[,2])+(i<-strtoi(m[,1]))))
for(v in 1:nrow(m)) w[seq(i[v]+1,l=n(m[v,2]))]=unlist(strsplit(m[v,2],''))
cat("",w,sep="")

在R Gui中工作（单行，或为多行采购），但不在ideone中工作，例如：

> n=nchar;m=matrix(scan(,'raw'),ncol=2,byrow=T);w=rep('',max(n(m[,2])+(i<-strtoi(m[,1]))));for(v in 1:nrow(m)) w[seq(i[v]+1,l=n(m[v,2]))]=unlist(strsplit(m[v,2],''));cat("",w,sep="")
1: 2 ob 5 rba 0 fooba 8 z
9: 
Read 8 items
foobarbaz

注意输入法：

或仅由数字，空格和切片组成的字符串。

我假设我使用这种输入符合规范的这一部分，可以在多行中给出，只要没有空行结束输入，这就没有影响。

我认为可以通过删除+1并使用基于1的索引来节省2个字符，但我从挑战输入开始。

C，110字节

c,i,j;char s[99];main(){while(~scanf("%i ",&i))for(;(c=getchar())>10;s[i++]=c);for(;s[j]>10;putchar(s[j++]));}

该程序在输入的每一行中将其索引之后的切片作为对象。

取消高尔夫：

c,i,j;char s[99];

main(){
    while(~scanf("%i ",&i))
        for(;(c=getchar())>10;s[i++]=c);
    for(;s[j]>10;putchar(s[j++]));
}

在ideone.com上测试

Lua，113个字节

z=loadstring("return "..io.read())()table.sort(z,function(a,b)return a[1]<b[1]end)for a=1,#z do print(z[a][2])end

这可能是我编写的一些更安全的代码。这个想法很简单。用户将输入一个格式如下的数组：{{1, "1"}, {3, "3"}, {2, "2"}}然后该表将按第一个索引排序，然后将打印第二个索引。