Gerçekten yoğun bir arsaya etiket eklemeye çalıştıysanız, bazen etiketlerin birbirleriyle çakışacağını ve bunları okumayı zorlaştıracağını fark edersiniz. Benzer bir şey yapacağız ama 1D içinde.

Girdi bir (label, x-coordinate)çiftler dizisi olacak ve verim verilen sırayla her noktanın ve etiketin çizilmesinin sonucu olacaktır. *Noktayı temsil eden bir yıldız işareti , verilen x-koordinatına yerleştirilmeli ve etiket takip etmelidir. Mevcut karakterlerin üzerine yazılacaktır.

Örneğin, giriş yapıldıysa

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

Sonra aşağıdaki olur:

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

Son satır daha sonra çıkarılmalıdır.

G / Ç kuralları

• Giriş herhangi bir sayıda çiftten oluşabilir. Her etiket yalnızca büyük ve küçük harflerden oluşacak ve etiket uzunlukları en fazla 127 karakterden oluşacaktır. Her x koordinatı 0 ile 127 arasında olacaktır.

• Giriş, çiftlerin net olmaları ve girişlerde etiketlerin / x koordinatlarının değişmesi için uygun bir listede veya dize biçiminde olabilir. Örneğin, gibi [("Hello", 0), ("World", 8) ...]veya [0 "Hello" 8 "World" ...]iyi bir biçim . Ancak, iki ayrı etiket ve x koordinatı listesi kabul edemezsiniz.

• İşlevler ve tam programlar hem tamamdır.

• Bir etiket ile kaplanmayan noktalar bir boşlukla temsil edilmelidir. Bununla birlikte, isteğe bağlı tek bir takip eden yeni hattın dışında herhangi bir yabancı lider veya takip eden boşluk olmayabilir.

Örnekler

Giriş:

OneLabel   10

Çıktı:

          *OneLabel

Giriş:

Heathrow   0
Edinburgh  2
London     4
Liverpool  6
Oxford     8

Çıktı:

*H*E*L*L*Oxfordl

Giriş:

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

Çıktı:

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

Giriş:

abc  5
d    5
abc  10
ABCDEFGHIJKLMNOPQRSTUVWXYZ 127

Çıktı:

     *dbc *abc                                                                                                                 *ABCDEFGHIJKLMNOPQRSTUVWXYZ

Etiketlerin ve / veya x koordinatlarının tekrarlanabileceğini unutmayın.

CJam, 24 23 19 bayt

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

Bu girdiyi bir CJam koordinat etiketi çifti dizisi olarak okur.

Bu kemanı CJam yorumlayıcısında deneyin veya tüm test durumlarını bir kerede doğrulayın.

4 byte tasarruf etmeme yardım ettiğin için @ MartinBüttner'e teşekkürler!

Nasıl çalışır

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".

Pyth, 20 bayt

V.Tmrj" *"d9Qpe+d-Nd

Çevrimiçi deneyin: Gösteri veya Test Paketi

açıklama

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 bayt

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

Örnek Kullanım

Uyumlu bir konsola giriş:

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);

Son ifadeden çıktı:

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

açıklama

Bu, cbirlikte mantıksal olarak ANDED olan üç ifadeden adsız bir işlev oluşturur . İlk iki ifade her zaman trütttir ve JS kısa devre kuralları, ilk doğruysa, tüm değeri sağ tarafa döndürür der (boolene zorlamadan): bu resmen eşdeğerdir

(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
})

İlk ifadenin yukarıdaki parantez içine alınması gerekir, çünkü atama işleci =mantıksal VE işleçten daha düşük önceliğe sahiptir &&.

" ..."*"+vRest parametresi" montajı ayrıca ES6'nın bir parçasıdır; *dizgiye giden bir ipucunu birleştirir ve daha sonra onu listedeki bir parametre olarak yorumlar, onu elemanların çıkarılması için dizisini Array.prototype.splicealır (m, n, ...rest)ve değiştirir ve ardından tüm argümanları ekler . ES6'dan önce bunu başarmak için daha hantal kullanacaksınız:mnrest

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

Daha sonra dizi boş dizeyle birleştirilir ve arkadaki boşluk silinir.

Python 2,67 bayt

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

Gibi girdi alır [('Heathrow', 0), ('Edinburgh', 2), ('London', 4), ('Liverpool', 6), ('Oxford', 8)]ve sonucu yazdırır.

Python, dizelerin değiştirilmesine izin vermez ve bir listeye ve bir listeye dönüştürmek pahalıdır. Böylece, bu zyeni bir sözcük eklemek için dizgiyi yeniden oluşturur . Biz almak b, yıldız ile daha sonra yeni metin, daha sonra bir kısmını gerekirse boşluklarla doldurma, kelimenin önceki karakterleri zyeni sözcükten sonra. Sondaki boşlukların hiçbir zaman eklenmediğini unutmayın.

reduceSürümü daha 3 karakter (70) 'dir:

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

Ruby, 94 81 75 bayt

golfed:

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

İşte kodlanmamış kod:

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

Girdiyi eşleştirme konusundaki önerileriniz için teşekkürler @ w0lf!

Thanks @ w0lf ve @Not Bu değişkeni kaldırma düşüncesi için Charles.

Javascript 121 karakter

Standart olmayan özellikleri kullanarak, Firefox'ta çalışır.
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()

Eski versiyon: 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 bayt

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

Çevrimiçi deneyin

Perl, 66 bayt

63 baytlık komut dosyası + 3 baytlık -p

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

Dizeyi bölmek yerine değişkenleri kullanan $`ve $'sırasıyla 'eşleşmeden önce' ve 'eşleşmeden sonra' olan çok özel bir şey yoktur . $}Dize değişkeni için aslen bir bayt kurtarıyormuş gibi kullandım ama artık yok!

Örnek çalışma:

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

Perl, 65 bayt

62 bayt komut dosyası + 3 bayt -p

Her satırı basan başka bir sürüm (bir az bayt için!). (Evet, bunu doğru bir şekilde okumadım çünkü yaptım ...)

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

Örnek çalışma:

$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 bayt

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

İmleci konumlandırmak için ANSI çıkış kodlarını kullanır ( \x1b[XGEscape karakterinin ve X'in 1 tabanlı koordinat olması) ve ardından *bu satır için giriş dizesinin kullanılması. Formun komut satırındaki girişi kabul eder:

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

Komut satırı argümanları olduklarından, tırnak içinde oldukları takdirde çok kelimeli girişleri kabul eder.

C ++ 11, 95 bayt

Neden olmasın?

Bir işlev olarak , konumu ve dizeyi içeren bir map<int, string>ad olarak girdi alırsınız v.

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

kullanım

#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;
}

İşte Çalışıyor kontrol edin