Dato un input di un elenco di sezioni di una stringa, genera la stringa originale.

Ogni sezione verrà fornita come un elenco di lunghezza 2, contenente la posizione iniziale della sezione (un numero intero ≥0) e la sezione stessa. Se la tua lingua non supporta matrici di tipi arbitrari, puoi anche prenderlo come una struttura o simile, o semplicemente una stringa composta dal numero, da uno spazio e quindi dalla sezione.

L'ordine dei due elementi di ogni sezione dipende da te. Inoltre, se si sceglie di utilizzare la rappresentazione di sezioni come matrice di lunghezza 2, è possibile accettare input come matrice bidimensionale o singola matrice piatta. Infine, il numero intero che rappresenta la posizione può essere indicizzato zero o indicizzato uno (tutti gli esempi qui sono indicizzati zero).

L'input sarà sempre sufficiente per determinare l'intera stringa fino alla posizione più alta indicata. Cioè, non ci saranno "buchi" o "lacune". Pertanto, l'output non deve contenere caratteri finali o finali aggiuntivi (tranne la nuova riga finale opzionale tipica). L'input sarà sempre coerente e nessuna sezione sarà in conflitto tra loro.

Dato che si tratta di code-golf , vincerà il codice più breve in byte.

Casi 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

Gelatina, 10 9 byte

Ḣ0ẋ;Fµ€o/

Provalo online!

Come funziona

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

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

Innanzitutto, allinea le stringhe riempiendo gli offset di spazi (indicati come caratteri di sottolineatura per maggiore chiarezza)

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

__CG
PP
_PC

Poi, usi mapa zipe prendere il massimo di ogni colonna, che ignora i valori più piccoli degli spazi (il più piccolo carattere stampabile) e Nones dove alcune stringhe erano troppo corte.

__CG
PP
_PC

PPCG

Infine, ''.joinad una stringa usando il [2::5]trucco.

Perl, 25 anni

Aggiunto +2 per -lp

Ricevi l'input da STDIN, ad es

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

(Chiudi con ^ D o ^ Z o qualsiasi altra cosa chiuda STDIN sul tuo sistema)

slices.pl:

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

JavaScript (ES6), 61 byte

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

Modifica: salvato 4 byte grazie a @ edc65.

Haskell, 57 byte

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

Esempio di utilizzo:

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

Come funziona: crea coppie (index,letter)per ogni lettera di ogni sezione, concatena in un unico elenco, rimuovi duplicati, ordina per indice, rimuovi indici.

MATL , 15 byte

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

Funziona con la versione corrente (13.0.0) della lingua / compilatore.

L'input è con parentesi graffe e virgolette singole. (Le parentesi graffe in MATLAB / MATL definiscono gli array di celle , che sono elenchi che possono avere contenuti di tipi arbitrari, possibilmente diversi.) I casi di test sono quindi:

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

Provalo 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 byte

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

Try it here.

Lambda anonimo. Uso:

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

NOTA: DUP non ha davvero array, quindi spero che questo formato di input sia corretto.

Spiegazione

Bene, la comprensione delle stringhe di DUP è ... interessante. Le stringhe sono memorizzate come una serie di variabili numeriche, ognuna delle quali contiene un codice di accesso alla stringa. Qualcosa del genere 2"CG"funziona come spingere 2 nello stack, quindi creare una stringa con indice a partire da 2.

Poiché questi indici sono in realtà variabili, possono essere sovrascritti. Ecco cosa sta realmente facendo l'input: ignorare! Prova a premere Stepsul sito dell'interprete per avere un'idea migliore. Dopo questo, otteniamo una stringa non affettata.

Qui entra in gioco l'output.

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

Nota: valutare l'input dell'utente è sempre una buona 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";

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

Si può vedere che sto solo scrivendo l'input in un array con la chiave specifica che ogni carattere ha e quindi l'output tutto.

test

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

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

php shorten.php unslice.php-> Script abbreviato di 107 caratteri. : D

Scherzi a parte, 48 byte

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

Scherzi a parte è seriamente dannoso per la manipolazione delle stringhe.

Provalo online!

Spiegazione:

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

Mappa 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

Mappa 2:

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

Mappa 3:

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

Mappa 4:

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

In breve, questo programma crea una stringa con nspazi, dove nè la lunghezza minima che la stringa può essere basata sull'input. Determina l'indice nella stringa del risultato di ciascun carattere in ciascuna sezione e imposta il carattere nella stringa del risultato su quell'indice sul carattere.

Python, 91 byte.

Salvato 1 byte grazie a cat.

È un po 'lungo. Lo golfò di più tra un po '.

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 byte

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

Casi test

CJam, 26 byte

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

Provalo online! . Accetta input nel modulo [["CG"2]["PP"0]["PC"1]].

Spiegazione:

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 byte

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 interruzioni di riga:

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

Funziona in R Gui (una riga singola o sourcing per quella a più righe) ma non in ideone, ad esempio:

> 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 sul metodo di input:

o semplicemente una stringa composta dal numero, da uno spazio e quindi dalla sezione.

Presumo di aderire a questa parte delle specifiche con questo tipo di input, può essere fornito su più righe, questo non ha alcun impatto finché esiste una riga vuota per terminare l'input.

Penso che 2 caratteri possano essere salvati rimuovendo il +1 e usando l'indicizzazione basata su 1 ma ho iniziato con l'input sfida.

C, 110 byte

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

Questo programma prende la sezione dopo il suo indice in una riga di input ciascuno.

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

Test su ideone.com

Lua, 113 byte

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

Questo è probabilmente il codice più sicuro che ho scritto. L'idea è semplice L'utente inserirà un array formattato in questo modo: {{1, "1"}, {3, "3"}, {2, "2"}}e quindi la tabella verrà ordinata in base al primo indice e verrà stampato il secondo indice.