Đưa ra một đầu vào của một danh sách các lát của một chuỗi, xuất ra chuỗi gốc.

Mỗi lát sẽ được đưa ra dưới dạng một danh sách có độ dài 2, chứa vị trí bắt đầu của lát (số nguyên ≥0) và chính lát đó. Nếu ngôn ngữ của bạn không hỗ trợ mảng các loại tùy ý, bạn cũng có thể coi đây là cấu trúc hoặc tương tự hoặc đơn giản là một chuỗi bao gồm số, khoảng trắng và sau đó là lát cắt.

Thứ tự của hai yếu tố của mỗi lát tùy thuộc vào bạn. Hơn nữa, nếu bạn chọn sử dụng biểu diễn các lát như một mảng có độ dài 2, bạn có thể lấy đầu vào là mảng 2 chiều hoặc mảng phẳng đơn. Cuối cùng, vị trí đại diện số nguyên có thể là chỉ mục 0 hoặc chỉ mục một (tất cả các ví dụ ở đây là không có chỉ mục).

Đầu vào sẽ luôn đủ để xác định toàn bộ chuỗi lên đến vị trí cao nhất được đưa ra. Đó là, sẽ không có "lỗ hổng" hay "khoảng trống". Do đó, đầu ra không được chứa bất kỳ ký tự kéo dài hoặc ký tự đứng đầu nào (ngoài dòng mới theo dõi tùy chọn điển hình). Đầu vào sẽ luôn nhất quán và không có lát cắt nào xung đột với nhau.

Vì đây là môn đánh gôn , mã ngắn nhất tính bằng byte sẽ thắng.

Các trường hợp thử nghiệm:

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

Thạch, 10 9 byte

Ḣ0ẋ;Fµ€o/

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Đầu tiên, sắp xếp các chuỗi bằng cách đệm phần bù của chúng bằng khoảng trắng (được hiển thị dưới dạng dấu gạch dưới cho rõ ràng)

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

__CG
PP
_PC

Sau đó, sử dụng mapđể zipvà lấy tối đa của mỗi cột, mà bỏ qua các giá trị nhỏ hơn của không gian (các nhân vật có thể in nhỏ nhất) và Nonelà nơi mà một số chuỗi là quá ngắn.

__CG
PP
_PC

PPCG

Cuối cùng, ''.joinđến một chuỗi bằng cách sử dụng [2::5]thủ thuật.

Perl, 25

Đã thêm +2 cho -lp

Lấy đầu vào từ STDIN, vd

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

(Đóng với ^ D hoặc ^ Z hoặc bất cứ thứ gì đóng STDIN trên hệ thống của bạn)

slices.pl:

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

JavaScript (ES6), 61 byte

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

Chỉnh sửa: Đã lưu 4 byte nhờ @ edc65.

Haskell, 57 byte

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

Ví dụ sử dụng:

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

Cách thức hoạt động: tạo các cặp (index,letter)cho mỗi chữ cái của mỗi lát, ghép thành một danh sách duy nhất, loại bỏ trùng lặp, sắp xếp theo chỉ mục, xóa chỉ mục.

MATL , 15 byte

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

Hoạt động với phiên bản hiện tại (13.0.0) của ngôn ngữ / trình biên dịch.

Đầu vào là với dấu ngoặc nhọn và dấu ngoặc đơn. (Dấu ngoặc nhọn trong MATLAB / MATL xác định mảng ô , là danh sách có thể có nội dung tùy ý, có thể là các loại khác nhau.) Các trường hợp thử nghiệm là như vậy:

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

Hãy thử trực tuyến!

''      % 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 ẩn danh. Sử dụng:

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

LƯU Ý: DUP không thực sự có mảng, vì vậy tôi hy vọng định dạng đầu vào này là ổn.

Giải trình

Chà, hiểu chuỗi của DUP là ... thú vị. Các chuỗi được lưu trữ dưới dạng một chuỗi các biến số, mỗi biến chứa một mã số từ chuỗi. Một cái gì đó giống như 2"CG"hoạt động như đẩy 2 lên ngăn xếp, sau đó tạo một chuỗi với chỉ mục bắt đầu từ 2.

Bởi vì các chỉ mục này thực sự là các biến, chúng có thể được ghi đè. Đó là những gì đầu vào đang thực sự làm: ghi đè! Hãy thử nhấn Stepvào trang thông dịch để có ý tưởng tốt hơn cho việc này. Sau này, chúng tôi nhận được một chuỗi không có giấy phép.

Đây là nơi đầu ra đến.

[            ] {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 ký tự

Lưu ý: Đánh giá đầu vào của người dùng luôn là một ý tưởng tốt.

Chơi gôn

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

Bị đánh cắp

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

Bạn có thể thấy rằng tôi chỉ viết đầu vào thành một mảng với khóa cụ thể mà mỗi char có và sau đó xuất tất cả.

Xét nghiệm

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

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

php shorten.php unslice.php-> Tập lệnh rút ngắn bằng 107 ký tự. : D

Nghiêm túc, 48 byte

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

Nghiêm túc là nghiêm trọng xấu trong thao tác chuỗi.

Hãy thử trực tuyến!

Giải trình:

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

Bản đồ 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

Bản đồ 2:

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

Bản đồ 3:

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

Bản đồ 4:

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

Tóm lại, chương trình này tạo ra một chuỗi có nkhoảng trắng, trong đó nđộ dài tối thiểu mà chuỗi có thể dựa trên đầu vào. Nó xác định chỉ mục trong chuỗi kết quả của từng ký tự trong mỗi lát và đặt ký tự trong chuỗi kết quả tại chỉ mục đó thành ký tự.

Python, 91 byte.

Lưu được 1 byte nhờ mèo.

Nó hơi dài. Tôi sẽ đánh nó xuống nhiều hơn một chút.

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

Các trường hợp thử nghiệm

CJam, 26 byte

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

Hãy thử trực tuyến! . Đưa đầu vào dưới dạng [["CG"2]["PP"0]["PC"1]].

Giải trình:

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

Với ngắt dòng:

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

Hoạt động trong R Gui (một dòng một hoặc tìm nguồn cung ứng cho nhiều dòng) nhưng không hoạt động trong ideone, ví dụ:

> 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

Lưu ý về phương thức nhập liệu:

hoặc đơn giản là một chuỗi bao gồm số, một khoảng trắng và sau đó là lát cắt.

Tôi giả sử tôi tuân thủ phần này của thông số kỹ thuật với loại đầu vào này, nó có thể được cung cấp trên nhiều dòng, điều này không có tác động miễn là có một dòng trống để kết thúc đầu vào.

Tôi nghĩ có thể lưu 2 ký tự bằng cách xóa +1 và sử dụng lập chỉ mục dựa trên 1 nhưng tôi đã bắt đầu với thử thách đầu vào.

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

Chương trình này lấy lát cắt sau chỉ mục của nó trong một dòng đầu vào.

Ung dung:

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

Kiểm tra trên 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

Đây có lẽ là một số mã an toàn hơn tôi đã viết. Ý tưởng rất đơn giản. Người dùng sẽ nhập một mảng được định dạng như vậy: {{1, "1"}, {3, "3"}, {2, "2"}}và sau đó bảng sẽ được sắp xếp theo chỉ mục đầu tiên và chỉ mục thứ hai sẽ được in.