Dada a entrada de uma lista de fatias de uma sequência, produza a sequência original.

Cada fatia será fornecida como uma lista de comprimento 2, contendo a posição inicial da fatia (um número inteiro ≥0) e a própria fatia. Se o seu idioma não suportar matrizes de tipos arbitrários, você também pode considerá-lo como uma estrutura ou similar, ou simplesmente como uma sequência que consiste no número, um espaço e, em seguida, a fatia.

A ordem dos dois elementos de cada fatia é sua. Além disso, se você optar por usar a representação de fatias como uma matriz de comprimento 2, poderá receber a entrada como uma matriz bidimensional ou uma única matriz plana. Finalmente, o número inteiro que representa a posição pode ser indexado a zero ou indexado a um (todos os exemplos aqui são indexados a zero).

A entrada sempre será suficiente para determinar a sequência inteira até a posição mais alta fornecida. Ou seja, não haverá "buracos" ou "lacunas". Portanto, a saída não deve conter nenhum caractere final à direita ou à esquerda (além da nova linha opcional à direita). A entrada sempre será consistente e nenhuma fatia entrará em conflito entre si.

Como esse é o código-golfe , o código mais curto em bytes será vencedor.

Casos de teste:

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

Geléia, 10 9 bytes

Ḣ0ẋ;Fµ€o/

Experimente online!

Como funciona

Ḣ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 bytes

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

Primeiro, alinha as cordas preenchendo seus deslocamentos com espaços (mostrados como sublinhados para maior clareza)

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

__CG
PP
_PC

Então, usos mappara zipe tomar o máximo de cada coluna, que ignora os valores menores de espaços (o carácter de impressão menor) e Noneé onde algumas cordas eram muito curtos.

__CG
PP
_PC

PPCG

Finalmente, ''.joinpara uma string usando o [2::5]truque.

Perl, 25

Adicionado +2 para -lp

Obtenha a entrada do STDIN, por exemplo

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

(Feche com ^ D ou ^ Z ou o que fechar STDIN no seu sistema)

slices.pl:

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

JavaScript (ES6), 61 bytes

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

Editar: salvou 4 bytes graças a @ edc65.

Haskell, 57 bytes

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

Exemplo de uso:

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

Como funciona: crie pares (index,letter)para cada letra de cada fatia, concatene em uma única lista, remova duplicatas, classifique por índice, remova índices.

MATL , 15 bytes

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

Funciona com a versão atual (13.0.0) do idioma / compilador.

A entrada é entre chaves e aspas simples. (Os colchetes no MATLAB / MATL definem matrizes de células , que são listas que podem ter conteúdo de tipos arbitrários e possivelmente diferentes.) Os casos de teste são:

{{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'}}

Experimente online!

''      % 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 bytes

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

Try it here.

Lambda anônimo. Uso:

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

NOTA: O DUP realmente não possui matrizes, portanto, espero que este formato de entrada esteja correto.

Explicação

Bem, a compreensão de cordas do DUP é ... interessante. As cadeias são armazenadas como uma série de variáveis ​​numéricas, cada uma das quais contém um código da cadeia. Algo como 2"CG"funciona empurrando 2 para a pilha e, em seguida, criando uma string com o índice iniciando em 2.

Como esses índices são realmente variáveis, eles podem ser substituídos. É isso que a entrada realmente está fazendo: substituindo! Tente pressionar Stepo site do intérprete para ter uma ideia melhor disso. Depois disso, obtemos uma sequência sem fatias.

É aqui que a saída entra.

[            ] {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 caracteres

Nota: Avaliar a entrada do usuário é sempre uma boa ideia.

Golfe

<?$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";

Ungolfed

<?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";
?>

Você pode ver que estou escrevendo a entrada em uma matriz com a chave específica que cada caractere possui e, em seguida, produzindo tudo.

Testes

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

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

php shorten.php unslice.php-> Script reduzido por 107 caracteres. : D

Sério, 48 bytes

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

Sério é muito ruim na manipulação de cordas.

Experimente online!

Explicação:

,`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

Mapa 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

Mapa 2:

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

Mapa 3:

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

Mapa 4:

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

Em poucas palavras, este programa cria uma sequência com nespaços, onde né o comprimento mínimo em que a sequência pode ser baseada na entrada. Ele determina o índice na sequência de resultados de cada caractere em cada fatia e define o caractere na sequência de resultados nesse índice para o caractere.

Python, 91 bytes.

Guardado 1 byte graças a cat.

É um pouco longo. Vou jogar mais um pouco.

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, 119 115 bytes

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

Casos de teste

CJam, 26 bytes

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

Experimente online! . Recebe entrada no formulário [["CG"2]["PP"0]["PC"1]].

Explicação:

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 bytes

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

Com quebras de linha:

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

Funciona em R Gui (linha única uma, ou sourcing para a linha múltipla), mas não em ideone, por exemplo:

> 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

Nota sobre o método de entrada:

ou simplesmente uma sequência que consiste no número, um espaço e depois a fatia.

Eu suponho que eu cumpra essa parte da especificação com esse tipo de entrada, ela pode ser fornecida em várias linhas, isso não tem impacto desde que haja uma linha em branco para finalizar a entrada.

Eu acho que 2 caracteres podem ser salvos removendo o +1 e usando uma indexação baseada em 1, mas comecei com a entrada do desafio.

C, 110 bytes

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++]));}

Este programa pega a fatia após seu índice em uma linha de entrada cada.

Ungolfed:

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++]));
}

Teste em ideone.com

Lua, 113 bytes

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

Este é provavelmente um dos códigos mais seguros que eu escrevi. A ideia é simples. O usuário digitará uma matriz formatada da seguinte forma: {{1, "1"}, {3, "3"}, {2, "2"}}e a tabela será classificada pelo primeiro índice e o segundo índice será impresso.