Dada una entrada de una lista de sectores de una cadena, genera la cadena original.

Cada segmento se dará como una lista de longitud 2, que contiene la posición de inicio del segmento (un entero ≥0) y el segmento en sí. Si su idioma no admite matrices de tipos arbitrarios, también puede tomar esto como una estructura o similar, o simplemente una cadena que consiste en el número, un espacio y luego el segmento.

El orden de los dos elementos de cada segmento depende de usted. Además, si elige usar la representación de cortes como una matriz de longitud 2, puede tomar la entrada como una matriz bidimensional o una matriz plana única. Finalmente, la posición que representa el número entero puede estar indexada a cero o indexada a una (todos los ejemplos aquí están indexados a cero).

La entrada siempre será suficiente para determinar la cadena completa hasta la posición más alta dada. Es decir, no habrá "agujeros" o "brechas". Por lo tanto, la salida no debe contener caracteres finales o iniciales adicionales (excepto la nueva línea final opcional típica). La entrada siempre será coherente y ningún segmento entrará en conflicto entre sí.

Como se trata de code-golf , ganará el código más corto en bytes.

Casos de prueba:

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

Jalea, 10 9 bytes

Ḣ0ẋ;Fµ€o/

Pruébalo en línea!

Cómo 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]

Primero, alinee las cadenas rellenando sus desplazamientos con espacios (mostrados como guiones bajos para mayor claridad)

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

__CG
PP
_PC

A continuación, los usos mapa zipy tomar el máximo de cada columna, que ignora los valores más pequeños de espacios (el más pequeño carácter imprimible) y Nonees donde algunas cadenas eran demasiado cortos.

__CG
PP
_PC

PPCG

Finalmente, ''.joina una cuerda usando el [2::5]truco.

Perl, 25

Se agregó +2 por -lp

Obtenga la entrada de STDIN, p. Ej.

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

(Cierre con ^ D o ^ Z o lo que cierre STDIN en su 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: Guardado 4 bytes gracias a @ edc65.

Haskell, 57 bytes

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

Ejemplo de uso:

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

Cómo funciona: hacer pares de (index,letter)cada letra de cada segmento, concatenar en una sola lista, eliminar duplicados, ordenar por índice, eliminar índices.

MATL , 15 bytes

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

Funciona con la versión actual (13.0.0) del lenguaje / compilador.

La entrada es con llaves y comillas simples. (Las llaves en MATLAB / MATL definen matrices de celdas , que son listas que pueden tener contenidos de tipos arbitrarios, posiblemente diferentes). Los casos de prueba son los siguientes:

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

Pruébalo en línea!

''      % 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ónima. Uso:

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

NOTA: DUP realmente no tiene matrices, así que espero que este formato de entrada esté bien.

Explicación

Bueno, la comprensión de cuerdas de DUP es ... interesante. Las cadenas se almacenan como una serie de variables numéricas, cada una de las cuales contiene un código de char de la cadena. Algo así 2"CG"funciona como empujar 2 a la pila, luego crear una cadena con índice a partir de 2.

Debido a que estos índices son realmente variables, pueden sobrescribirse. Eso es lo que realmente está haciendo la entrada: anular! Intente presionar Stepen el sitio del intérprete para tener una mejor idea de esto. Después de esto, obtenemos una cadena sin cortar.

Aquí es donde entra la salida.

[            ] {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: Evaluar la entrada del usuario es siempre una buena idea.

Golfed

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

Sin golf

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

Puedes ver que solo estoy escribiendo la entrada en una matriz con la clave específica que tiene cada personaje y luego lo saco todo.

Pruebas

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

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

php shorten.php unslice.php-> Guión acortado por 107 caracteres. :RE

En serio, 48 bytes

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

En serio es muy malo en la manipulación de cuerdas.

Pruébalo en línea!

Explicación:

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

En pocas palabras, este programa crea una cadena con nespacios, donde nes la longitud mínima que la cadena puede basarse en la entrada. Determina el índice en la cadena de resultados de cada carácter en cada segmento, y establece el carácter en la cadena de resultados en ese índice para el carácter.

Python, 91 bytes.

Guardado 1 byte gracias al gato.

Es un poco largo Lo jugaré más en un rato.

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

CJam, 26 bytes

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

Pruébalo en línea! . Toma entrada en forma [["CG"2]["PP"0]["PC"1]].

Explicación:

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

Con saltos de línea:

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 en R Gui (una sola línea, o fuente para la de varias líneas) pero no en ideone, por ejemplo:

> 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 el método de entrada:

o simplemente una cadena que consiste en el número, un espacio y luego el corte.

Supongo que cumplo con esta parte de la especificación con este tipo de entrada, se puede dar en varias líneas, esto no tiene impacto siempre que haya una línea en blanco para finalizar la entrada.

Creo que se pueden guardar 2 caracteres eliminando el +1 y usando la indexación basada en 1, pero comencé con la entrada de desafío.

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 toma el segmento después de su índice en una línea de entrada cada uno.

Sin golf:

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

Prueba en 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 es probablemente uno de los códigos más seguros que he escrito. La idea es simple. El usuario ingresará una matriz con el siguiente formato: {{1, "1"}, {3, "3"}, {2, "2"}}y luego la tabla se ordenará por el primer índice y se imprimirá el segundo índice.