Nếu bạn đã từng thử thêm nhãn vào một cốt truyện thực sự dày đặc, thì bạn sẽ nhận ra rằng đôi khi các nhãn sẽ chồng chéo lên nhau, khiến chúng khó đọc. Chúng ta sẽ làm một cái gì đó tương tự nhưng trong 1D.

Đầu vào sẽ là một chuỗi các (label, x-coordinate)cặp và đầu ra sẽ là kết quả của việc vẽ từng điểm và nhãn theo thứ tự đã cho. Một dấu hoa thị *đại diện cho điểm nên được đặt tại tọa độ x đã cho và nhãn phải tuân theo. Bất kỳ nhân vật hiện có sẽ được ghi đè.

Ví dụ, nếu đầu vào là

Hello  0
World  8
Fizz   3
Buzz   5
PPCG   16
X      9

Sau đó, những điều sau đây sẽ xảy ra:

*Hello
*Hello  *World
*He*Fizz*World
*He*F*Buzzorld
*He*F*Buzzorld  *PPCG  
*He*F*Buz*Xrld  *PPCG

Dòng cuối cùng nên được xuất ra.

Quy tắc I / O

• Đầu vào có thể bao gồm bất kỳ số lượng các cặp. Mỗi nhãn sẽ chỉ bao gồm chữ hoa và chữ thường và độ dài nhãn sẽ nhiều nhất là 127 ký tự. Mỗi tọa độ x sẽ nằm trong khoảng từ 0 đến 127.

• Đầu vào có thể ở bất kỳ danh sách thuận tiện hoặc định dạng chuỗi sao cho các cặp không rõ ràng và các nhãn / tọa độ x thay thế trong đầu vào. Ví dụ, một định dạng như [("Hello", 0), ("World", 8) ...]hoặc [0 "Hello" 8 "World" ...]là tốt. Tuy nhiên, bạn không được giả sử hai danh sách nhãn và tọa độ x riêng biệt.

• Chức năng và chương trình đầy đủ đều ổn.

• Bất kỳ điểm nào không được bao phủ bởi một nhãn phải được thể hiện bằng một khoảng trắng. Tuy nhiên, có thể không có bất kỳ khoảng trắng dẫn đầu hoặc dấu vết ngoại lai nào ngoài một dòng mới tùy chọn duy nhất.

Ví dụ

Đầu vào:

OneLabel   10

Đầu ra:

          *OneLabel

Đầu vào:

Heathrow   0
Edinburgh  2
London     4
Liverpool  6
Oxford     8

Đầu ra:

*H*E*L*L*Oxfordl

Đầu vào:

alpha     20
beta       4
gamma     57
delta      3
epsilon   22
zeta      32
eta       53
theta     27

Đầu ra:

   *delta           *a*epsi*thetazeta                *eta*gamma

Đầu vào:

abc  5
d    5
abc  10
ABCDEFGHIJKLMNOPQRSTUVWXYZ 127

Đầu ra:

     *dbc *abc                                                                                                                 *ABCDEFGHIJKLMNOPQRSTUVWXYZ

Lưu ý rằng nhãn và / hoặc tọa độ x có thể được lặp lại.

CJam, 24 23 19 byte

l~Sf.*'*f*:.{S^+1=}

Cái này đọc đầu vào dưới dạng một mảng CJam của các cặp nhãn tọa độ.

Hãy thử fiddle này trong trình thông dịch CJam hoặc xác minh tất cả các trường hợp thử nghiệm cùng một lúc.

Cảm ơn @ MartinBüttner đã giúp tôi tiết kiệm 4 byte!

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

l~                   Read a line from STDIN and evaluate it.
  Sf                 For each pair, push the pair and " "; then:
    .*                 Perform vectorized repetition.
                         [X "label"] " " .* -> [(X spaces) "label"]
      '*f*           Join each resulting pair, using '*' as separator.
          :.{     }  Reduce by the following vectorized operator:
                       Push two characters (A and B).
             S^        Compute the symmetric difference of B and " ".
                       This pushes "B " for a non-space B and "" otherwise.
                +1=    Append and select the second character (with wrap).
                       This selects B for "AB " and A for "A".

Bình thường, 20 byte

V.Tmrj" *"d9Qpe+d-Nd

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

Giải trình

V.Tmrj" *"d9Qpe+d-Nd
   m        Q         map each pair d of the input to:
     j" *"d             join d by the string " *"
    r      9            range-length encode 
                        (this gives x-coordinate spaces, a star and the label)
 .T                   transpose this table 
V                     for N in ^:
                 -Nd    remove spaces from N
               +d       add a space at the beginning
              e         take the last character
             p          and print it (without newline)

JavaScript ES6, 104 byte

c=>(a=Array(255).fill(" "))&&c.map(([u,v])=>a.splice(u,v.length+1,..."*"+v))&&a.join``.replace(/ +$/,"")

Cách sử dụng ví dụ

Nhập vào bảng điều khiển tuân thủ:

t = [[0,"Hello"],[8,"World"],[3,"Fizz"],[5,"Buzz"],[16,"PPCG"],[9,"X"]];
(c=>(a=Array(255).fill(" "))&&c.map(([u,v])=>a.splice(u,v.length+1,..."*"+v))&&a.join``.replace(/ +$/,""))(t);

Đầu ra từ câu lệnh cuối cùng:

"*He*F*Buz*Xrld  *PPCG"

Giải trình

Điều này tạo ra một hàm ẩn danh từ cba biểu thức đã được AND-logic cùng nhau. Hai câu lệnh đầu tiên luôn luôn là sự thật và các quy tắc ngắn mạch của JS nói rằng bất cứ khi nào câu lệnh đầu tiên là sự thật, hãy trả lại toàn bộ giá trị ở phía bên tay phải (không ép buộc với boolean): vì vậy điều này chính thức tương đương với

(function (c) {
    a = Array(255).fill(" ");                    // global variable `a` overwritten
    c.map(function (x) {                         // only side-effects are used here.
       var u = x[0], v = x[1];                   // ES6 destructuring
       a.splice(u, v.length + 1, ..."*" + v));   // main logic
    });
    return a.join("").replace(/ +$/, "");        // postprocessing and trim
})

Câu lệnh đầu tiên phải được gói trong ngoặc đơn ở trên vì toán tử gán =có độ ưu tiên thấp hơn toán tử AND-logic&& .

Việc lắp ráp "tham số phần còn lại" ..."*"+vcũng là một phần của ES6; nó nối một *chuỗi dẫn đến chuỗi và sau đó diễn giải nó thành một tham số giống như danh sách, chia nó thành một loạt các đối số được cung cấp Array.prototype.splice, lấy (m, n, ...rest)và sửa đổi mảng của nó tại vị trí mđể loại bỏ ncác phần tử và sau đó chèn tất cả các restđối số. Để thực hiện điều này trước ES6, bạn sẽ sử dụng nhiều thứ cồng kềnh hơn:

[].slice.apply(a, [u, v.length + 1].concat(("*" + v).split("")))

Mảng sau đó được nối với chuỗi rỗng và khoảng trắng ở cuối bị xóa.

Python 2, 67 byte

z=''
for a,b in input():z=(z+' '*b)[:b]+'*'+a+z[len(a)-~b:]
print z

Có đầu vào như [('Heathrow', 0), ('Edinburgh', 2), ('London', 4), ('Liverpool', 6), ('Oxford', 8)] và in kết quả.

Python không cho phép các chuỗi được sửa đổi và chuyển đổi sang và từ một danh sách rất tốn kém. Vì vậy, điều này tạo lại chuỗi zđể thêm vào một từ mới. Chúng tôi lấy các bký tự trước từ, đệm bằng khoảng trắng nếu cần, sau đó văn bản mới có dấu hoa thị, sau đó là phần zsau từ mới. Lưu ý rằng dấu cách không bao giờ được thêm vào.

Các reducephiên bản là 3 ký tự dài hơn (70):

lambda I:reduce(lambda z,(a,b):(z+' '*b)[:b]+'*'+a+z[len(a)-~b:],I,"")

Ruby, 94 81 75 byte

Chơi gôn

s=" "*128;$<.map{|l|w,p=l.split;p=p.to_i;s[p..w.size+p]="*"+w};$><<s.rstrip

Đây là mã không được mã hóa:

s = " "*128
$<.map{|l|                 # for each line entered via stdin, ctrl+D to stop
  w,p = l.split            # had to move the chomp down here
  p = p.to_i               # there's no 'to_i!'...
  s[p..w.size+p] = "*"+w   # in the range of *foobar, replace the string
}
$><<s.rstrip               # output suggested by w0lf

Cảm ơn @ w0lf về các đề xuất về ánh xạ đầu vào!

Cảm ơn @ w0lf và @ Không biết Charles đã nghĩ đến việc loại bỏ một biến.

Javascript ký tự 121

Sử dụng các tính năng không chuẩn, hoạt động trên Firefox.
x=Array(255).fill(" ");eval(prompt()).map(s=>{s[0].split``.map((n,i)=>x[s[1]+i+1]=n);x[s[1]]="*"});x=x.join``.trimRight()

Phiên bản cũ hơn: x=Array(255).fill(" ");eval(prompt()).map(s=>{s[0].split``.map((n,i)=>x[s[1]+i+1]=n);x[s[1]]="*"});x=x.join``.replace(/ +$/,"")

x=Array(255).fill(" ");      //Creates an array with spaces
eval(prompt())               //Gets some input, has to look like [["Hello",4],["Hi",14],["Oi",0]]
.map(s=>{s[0].split``.map((n,i)=>x[s[1]+i+1]=n);x[s[1]]="*"}); //Main "logic"
x=x.join``.replace(/ +$/,"") //Gets rid of the trailing spaces

Python, 85 byte

def g(p):
 z=[' ']*256
 for a,b in p:z[b:b+len(a)+1]='*'+a
 return''.join(z).rstrip()

Dùng thử trực tuyến

Perl, 66 byte

Tập lệnh 63 byte + 3 byte cho -p

$}||=$"x128;/\s+/,substr$},$',1+length$`,"*$`"}{$_=$};s/\s+$/
/

Không có gì quá đặc biệt, sử dụng các biến $`và lần lượt $'là 'trước trận đấu' và 'sau trận đấu', thay vì chia chuỗi. Tôi đã sử dụng một biến $}cho chuỗi như ban đầu nó tiết kiệm cho tôi một byte, nhưng không còn nữa!

Chạy ví dụ:

$perl -p overwritlabels.pl <<< 'Hello  0
World  8
Fizz   3
Buzz   5
PPCG   16
X      9'
*He*F*Buz*Xrld  *PPCG

Perl, 65 byte

Tập lệnh 62 byte + 3 byte cho -p

Một phiên bản khác in ra từng dòng (cho một byte ít hơn!). (Vâng, tôi đã làm điều này bởi vì tôi đã không đọc câu hỏi đúng cách ...)

$}||=$"x128;/\s+/;substr$},$',1+length$`,"*$`";$_=$};s/\s+$/
/

Chạy ví dụ:

$perl -p overwritlabels.pl <<< 'Hello  0
World  8
Fizz   3
Buzz   5
PPCG   16
X      9'
*Hello
*Hello  *World
*He*Fizz*World
*He*F*Buzzorld
*He*F*Buzzorld  *PPCG
*He*F*Buz*Xrld  *PPCG

PHP - 84 byte

<? foreach(array_chunk(array_slice($argv,1),2) as $p) echo "␣[".($p[1]+1)."G*$p[0]";
                                                            ^ ESC character (\x1b)

Sử dụng mã thoát ANSI để định vị con trỏ ( \x1b[XG, có ký tự Escape và X là tọa độ dựa trên 1), theo *sau là chuỗi đầu vào cho hàng đó. Chấp nhận đầu vào trên dòng lệnh của biểu mẫu:

php filename.php Heathrow 0 Edinburgh 2 London 4 Liverpool 6 Oxford 8
php filename.php abc 5 d 5 abc 10 ABCDEFGHIJKLMNOPQRSTUVWXYZ 127

Chấp nhận các mục nhập nhiều từ nếu chúng nằm trong dấu ngoặc kép, vì chúng là đối số dòng lệnh.

C ++ 11, 95 byte

Tại sao không?

Là một hàm, nhận đầu vào dưới dạng có map<int, string>tên vchứa vị trí và chuỗi.

string t(255,' ');for(auto&m:v){int i=m.first;t[i++]='*';for(auto&c:m.second)t[i++]=c;}cout<<t;

Sử dụng

#include <iostream>
#include <map>
using namespace std;
int main(){
    map<int,string> v{{0,"Heathrow"},{2,"Edinburgh"},{4,"London"},{6,"Liverpool"},{8,"Oxford"}};
    string t(255,' ');for(auto&m:v){int i=m.first;t[i++]='*';for(auto&c:m.second)t[i++]=c;}cout<<t;
}

Kiểm tra nó đang chạy ở đây