Étant donné l'entrée d'une liste de tranches d'une chaîne, sortez la chaîne d'origine.

Chaque tranche sera donnée sous la forme d'une liste de longueur 2, contenant la position de départ de la tranche (un entier ≥0) et la tranche elle-même. Si votre langue ne prend pas en charge les tableaux de types arbitraires, vous pouvez également prendre cela comme une structure ou similaire, ou simplement une chaîne composée du nombre, d'un espace, puis de la tranche.

L'ordre des deux éléments de chaque tranche dépend de vous. En outre, si vous choisissez d'utiliser la représentation des tranches comme un tableau de longueur 2, vous pouvez prendre l'entrée comme un tableau bidimensionnel ou un tableau plat unique. Enfin, l'entier représentant la position peut être indexé zéro ou indexé un (tous les exemples ici sont indexés zéro).

L'entrée sera toujours suffisante pour déterminer la chaîne entière jusqu'à la position la plus élevée donnée. Autrement dit, il n'y aura pas de "trous" ou "lacunes". Par conséquent, la sortie ne doit contenir aucun caractère de fin ou de début supplémentaire (autre que la nouvelle ligne de fin facultative typique). L'entrée sera toujours cohérente et aucune tranche n'entrera en conflit les unes avec les autres.

Puisqu'il s'agit de code-golf , le code le plus court en octets gagnera.

Cas de test:

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ée, 10 9 octets

Ḣ0ẋ;Fµ€o/

Essayez-le en ligne!

Comment ça marche

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

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

Tout d'abord, aligne les cordes en remplissant leurs décalages avec des espaces (représentés comme des traits de soulignement pour plus de clarté)

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

__CG
PP
_PC

Ensuite, utilise mapto zipet prend le maximum de chaque colonne, ce qui ignore les plus petites valeurs d'espaces (le plus petit caractère imprimable) et Nones où certaines chaînes étaient trop courtes.

__CG
PP
_PC

PPCG

Enfin, ''.joinà une chaîne en utilisant l' [2::5]astuce.

Perl, 25

+2 ajouté pour -lp

Obtenez l'entrée de STDIN, par exemple

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

(Fermez avec ^ D ou ^ Z ou tout ce qui ferme STDIN sur votre système)

slices.pl:

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

JavaScript (ES6), 61 octets

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

Edit: 4 octets enregistrés grâce à @ edc65.

Haskell, 57 octets

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

Exemple d'utilisation:

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

Comment ça marche: faire des paires de (index,letter)pour chaque lettre de chaque tranche, concaténer en une seule liste, supprimer les doublons, trier par index, supprimer les index.

MATL , 15 octets

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

Fonctionne avec la version actuelle (13.0.0) du langage / compilateur.

L'entrée se fait avec des accolades et des guillemets simples. (Les accolades dans MATLAB / MATL définissent des tableaux de cellules , qui sont des listes qui peuvent avoir des contenus de types arbitraires, éventuellement différents.) Les cas de test sont donc:

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

Essayez-le en ligne!

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

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

Try it here.

Lambda anonyme. Usage:

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

REMARQUE: DUP n'a pas vraiment de tableaux, donc j'espère que ce format d'entrée est correct.

Explication

Eh bien, la compréhension des cordes de DUP est ... intéressante. Les chaînes sont stockées sous la forme d'une série de variables numériques, chacune contenant un code de char de la chaîne. Quelque chose comme 2"CG"fonctionne en poussant 2 vers la pile, puis en créant une chaîne avec un index à partir de 2.

Parce que ces index sont vraiment des variables, ils peuvent être remplacés. C'est ce que fait réellement l'entrée: passer outre! Essayez d'appuyer Stepsur le site de l'interprète pour vous faire une meilleure idée. Après cela, nous obtenons une chaîne non découpée en tranches.

C'est là qu'intervient la sortie.

[            ] {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 caractères

Remarque: L'évaluation de l'entrée utilisateur est toujours une bonne idée.

Golfé

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

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

Vous pouvez voir que j'écris simplement l'entrée dans un tableau avec la clé spécifique de chaque caractère, puis que je la renvoie tout.

Les tests

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

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

php shorten.php unslice.php-> Script raccourci de 107 caractères. :RÉ

Sérieusement, 48 octets

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

Sérieusement est sérieusement mauvais à la manipulation de chaînes.

Essayez-le en ligne!

Explication:

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

Carte 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

Carte 2:

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

Carte 3:

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

Carte 4:

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

En un mot, ce programme crée une chaîne avec des nespaces, où nest la longueur minimale à laquelle la chaîne peut être basée sur l'entrée. Il détermine l'index dans la chaîne de résultat de chaque caractère dans chaque tranche et définit le caractère dans la chaîne de résultat à cet index sur le caractère.

Python, 91 octets.

1 octet enregistré grâce au chat.

C'est un peu long. Je vais le jouer plus bas dans un peu.

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 octets

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

Cas de test

CJam, 26 octets

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

Essayez-le en ligne! . Prend la saisie sous forme [["CG"2]["PP"0]["PC"1]].

Explication:

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 octets

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

Avec des sauts de ligne:

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

Fonctionne en R Gui (ligne unique ou sourcing pour la ligne multiple) mais pas en ideone, exemple:

> 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

Remarque sur la méthode de saisie:

ou simplement une chaîne composée du nombre, d'un espace, puis de la tranche.

Je suppose que je suis conforme à cette partie de la spécification avec ce type d'entrée, elle peut être donnée sur plusieurs lignes, cela n'a aucun impact tant qu'il y a une ligne vierge pour terminer l'entrée.

Je pense que 2 caractères peuvent être enregistrés en supprimant le +1 et en utilisant l'indexation basée sur 1, mais j'ai commencé avec la saisie du défi.

C, 110 octets

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

Ce programme prend la tranche après son index dans une ligne d'entrée chacun.

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

Testez sur ideone.com

Lua, 113 octets

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

Il s'agit probablement du code le plus sécurisé que j'ai écrit. L'idée est simple. L'utilisateur entrera un tableau formaté comme suit: {{1, "1"}, {3, "3"}, {2, "2"}}puis le tableau sera trié par le premier index et le deuxième index sera imprimé.