Geben Sie bei einer Eingabe einer Liste von Segmenten einer Zeichenfolge die ursprüngliche Zeichenfolge aus.

Jedes Slice wird als Liste mit der Länge 2 angegeben, die die Startposition des Slice (eine Ganzzahl ≥0) und das Slice selbst enthält. Wenn Ihre Sprache keine Arrays beliebigen Typs unterstützt, können Sie dies auch als eine Struktur oder Ähnliches oder einfach als eine Zeichenfolge aus der Zahl, einem Leerzeichen und dann dem Slice verwenden.

Die Reihenfolge der beiden Elemente eines jeden Slice liegt bei Ihnen. Wenn Sie die Darstellung von Slices als Array der Länge 2 verwenden, können Sie Eingaben entweder als zweidimensionales Array oder als einzelnes flaches Array annehmen. Schließlich kann die Ganzzahl, die die Position darstellt, entweder nullindexiert oder einsindexiert sein (alle Beispiele hier sind nullindexiert).

Die Eingabe ist immer ausreichend, um die gesamte Zeichenfolge bis zur höchsten angegebenen Position zu bestimmen. Das heißt, es wird keine "Löcher" oder "Lücken" geben. Daher darf die Ausgabe keine zusätzlichen nachgestellten oder führenden Zeichen enthalten (außer den typischen optionalen nachgestellten Zeilenumbrüchen). Die Eingabe ist immer konsistent und es treten keine Konflikte zwischen den Slices auf.

Da es sich um Code-Golf , wird der kürzeste Code in Bytes gewinnen.

Testfälle:

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

Gelee, 10 9 Bytes

Ḣ0ẋ;Fµ€o/

Probieren Sie es online!

Wie es funktioniert

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

Richten Sie zuerst die Zeichenfolgen aus, indem Sie ihre Offsets mit Leerzeichen auffüllen (zur Verdeutlichung als Unterstriche dargestellt).

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

__CG
PP
_PC

Verwenden Sie anschließend mapto zipund take für jede Spalte das Maximum. Dabei werden die kleineren Werte für Leerzeichen (das kleinste druckbare Zeichen) und Nones, bei denen einige Zeichenfolgen zu kurz waren , ignoriert .

__CG
PP
_PC

PPCG

Schließlich ''.joinzu einer Zeichenfolge mit dem [2::5]Trick.

Perl, 25

+2 für hinzugefügt -lp

Holen Sie sich die Eingabe von STDIN, z

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

(Schließen mit ^ D oder ^ Z oder was auch immer STDIN auf Ihrem System schließt)

slices.pl:

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

JavaScript (ES6), 61 Byte

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

Bearbeiten: 4 Bytes dank @ edc65 gespeichert.

Haskell, 57 Bytes

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

Anwendungsbeispiel:

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

So funktioniert es: (index,letter)Für jeden Buchstaben eines jeden Slice ein Paar bilden , zu einer einzigen Liste verketten, Duplikate entfernen, nach Index sortieren, Indizes entfernen.

MATL , 15 Bytes

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

Funktioniert mit der aktuellen Version (13.0.0) der Sprache / des Compilers.

Die Eingabe erfolgt in geschweiften Klammern und einfachen Anführungszeichen. (Geschweifte Klammern in MATLAB / MATL definieren Zellenanordnungen , die Listen sind , die Inhalte von beliebigen, möglicherweise unterschiedlichen Typen haben kann.) Die Testfälle sind somit:

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

Probieren Sie es 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.

Anonymes Lambda. Verwendung:

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

HINWEIS: DUP verfügt nicht wirklich über Arrays, daher hoffe ich, dass dieses Eingabeformat in Ordnung ist.

Erläuterung

Nun, das String-Verständnis von DUP ist ... interessant. Zeichenfolgen werden als eine Reihe von Zahlenvariablen gespeichert, von denen jede einen Zeichencode aus der Zeichenfolge enthält. Etwa so, 2"CG"als würde man 2 auf den Stack schieben und dann eine Zeichenkette mit Index ab 2 erstellen.

Da diese Indizes wirklich Variablen sind, können sie überschrieben werden. Das ist, was die Eingabe wirklich tut: Überschreiben! Klicken Sie Stepauf der Dolmetscherseite auf, um eine bessere Vorstellung davon zu erhalten. Danach erhalten wir eine ungeschnittene Zeichenfolge.

Hier kommt die Ausgabe ins Spiel.

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

Hinweis: Die Auswertung von Benutzereingaben ist immer eine gute Idee.

Golf gespielt

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

Sie können sehen, dass ich die Eingabe nur mit dem spezifischen Schlüssel, den jedes Zeichen hat, in ein Array schreibe und sie dann alle ausgebe.

Tests

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

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

php shorten.php unslice.php-> Verkürzte Schrift um 107 Zeichen. : D

Im Ernst, 48 Bytes

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

Ernst ist ernsthaft schlecht bei der Manipulation von Saiten.

Probieren Sie es online!

Erläuterung:

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

Karte 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

Karte 2:

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

Karte 3:

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

Karte 4:

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

Kurz gesagt, dieses Programm erstellt eine Zeichenfolge mit nLeerzeichen. Dabei nhandelt es sich um die Mindestlänge, die die Zeichenfolge auf der Eingabe basieren kann. Es bestimmt den Index in der Ergebniszeichenfolge jedes Zeichens in jedem Segment und setzt das Zeichen in der Ergebniszeichenfolge an diesem Index auf das Zeichen.

Python, 91 Bytes.

1 Byte dank cat gespeichert.

Es ist ein bisschen lang. Ich werde es in Kürze noch weiter ausbauen.

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

Testfälle

CJam, 26 Bytes

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

Probieren Sie es online! . Übernimmt die Eingabe in Form [["CG"2]["PP"0]["PC"1]].

Erläuterung:

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

Mit Zeilenumbrüchen:

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

Funktioniert in R Gui (Single Line One oder Sourcing für Multi Line One), aber nicht in Ideone, Beispiel:

> 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

Hinweis zur Eingabemethode:

oder einfach eine Zeichenfolge, die aus der Zahl, einem Leerzeichen und dem Slice besteht.

Ich gehe davon aus, dass ich diesen Teil der Spezifikation mit dieser Art von Eingabe einhalte. Sie kann in mehreren Zeilen angegeben werden. Dies hat keine Auswirkung, solange eine leere Zeile zum Beenden der Eingabe vorhanden ist.

Ich denke, 2 Zeichen können durch Entfernen der +1 und Verwendung der 1-basierten Indizierung gespeichert werden, aber ich habe mit der Challenge-Eingabe begonnen.

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

Dieses Programm nimmt das Slice nach seinem Index in jeweils eine Eingabezeile.

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

Dies ist wahrscheinlich einer der sichereren Codes, die ich geschrieben habe. Die Idee ist einfach. Der Benutzer gibt ein Array ein, das wie folgt formatiert ist: {{1, "1"}, {3, "3"}, {2, "2"}}Anschließend wird die Tabelle nach dem ersten Index sortiert und der zweite Index gedruckt.