* Overwrit * लेबल

Question

यदि आपने कभी लेबल को वास्तव में घने प्लॉट में जोड़ने की कोशिश की है, तो आपको एहसास होगा कि कभी-कभी लेबल एक दूसरे को ओवरलैप करेंगे, जिससे उन्हें पढ़ना मुश्किल हो जाएगा। हम ऐसा ही कुछ करने जा रहे हैं लेकिन 1D में।

इनपुट (label, x-coordinate)जोड़े का एक क्रम होगा , और आउटपुट दिए गए क्रम में प्रत्येक बिंदु और लेबल को खींचने का परिणाम होगा। *बिंदु का प्रतिनिधित्व करने वाला तारांकन दिए गए एक्स-समन्वय पर रखा जाना चाहिए और लेबल का पालन करना चाहिए। कोई भी मौजूदा वर्ण अधिलेखित कर दिया जाएगा।

उदाहरण के लिए, यदि इनपुट था

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

अंतिम पंक्ति को तब आउटपुट किया जाना चाहिए।

I / O नियम

• इनपुट में किसी भी संख्या में जोड़े शामिल हो सकते हैं। प्रत्येक लेबल में केवल अपरकेस और लोअरकेस अक्षर होंगे, और लेबल की लंबाई अधिकतम 127 वर्णों पर होगी। प्रत्येक एक्स-कोऑर्डिनेट 0 से 127 के बीच होगा।

• इनपुट किसी भी सुविधाजनक सूची या स्ट्रिंग प्रारूप में हो सकता है जैसे कि जोड़े अस्पष्ट हैं और इनपुट में लेबल / x-निर्देशांक वैकल्पिक हैं। उदाहरण के लिए, एक प्रारूप जैसा [("Hello", 0), ("World", 8) ...]या [0 "Hello" 8 "World" ...]ठीक है। हालाँकि, आप लेबल और x- निर्देशांक की दो अलग-अलग सूचियों को नहीं मान सकते हैं।

• कार्य और पूर्ण कार्यक्रम दोनों ठीक हैं।

• एक लेबल द्वारा कवर नहीं किए गए किसी भी स्पॉट को एक स्थान के साथ दर्शाया जाना चाहिए। हालाँकि, एकल वैकल्पिक अनुगामी न्यूलाइन से अलग कोई विलुप्त अग्रणी या अनुगामी व्हाट्सएप नहीं हो सकता है।

उदाहरण

इनपुट:

OneLabel   10

आउटपुट:

          *OneLabel

इनपुट:

Heathrow   0
Edinburgh  2
London     4
Liverpool  6
Oxford     8

आउटपुट:

*H*E*L*L*Oxfordl

इनपुट:

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

आउटपुट:

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

इनपुट:

abc  5
d    5
abc  10
ABCDEFGHIJKLMNOPQRSTUVWXYZ 127

आउटपुट:

     *dbc *abc                                                                                                                 *ABCDEFGHIJKLMNOPQRSTUVWXYZ

ध्यान दें कि लेबल और / या x- निर्देशांक दोहराया जा सकता है।

Comments

यदि x कोर्ड्स [0,127] हैं और स्ट्रिंग्स (0,127) हैं, तो क्या कोई लेबल लाइन के दायें छोर पर चल सकता है, या यह सुरक्षित है? "," Foo 127 "लाइन को" "" के साथ समाप्त करता है या नहीं? * "foo"। बस जाँच की जा रही है कि क्या स्ट्रिंग में नरम या कठोर अंत होना चाहिए।

— आलूऑमलेट्सविच

@PotatoOmeletteSandwich मेरा इरादा ऐसा था कि कुल लंबाई 255 के भीतर फिट होती है, इसलिए अधिकतम आउटपुट लंबाई तब होगी जब x-समन्वित 127 पर लंबाई 127 लेबल होगी। अंतिम आउटपुट को किसी भी तरह से छोटा नहीं किया जाना चाहिए, सिवाय ट्रेलिंग व्हाट्सएप को हटाने के ।

— Sp3000

Answer 1

CJam, 24 23 19 बाइट्स

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

यह इनपुट को समन्वय-लेबल जोड़े के सीजेएम सरणी के रूप में पढ़ता है।

प्रयास करें इस बेला CJam दुभाषिया में या एक ही बार में सभी प्रकार के परीक्षण की पुष्टि करें।

4 बाइट बचाने में मेरी मदद करने के लिए @ MartinButner को धन्यवाद!

यह काम किस प्रकार करता है

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

Comments

मैंने सिर्फ एक टेस्ट केस जोड़ा और सोचा कि मैं यह कहते हुए एक टिप्पणी छोड़ दूंगा कि नहीं, यह इस सबमिशन को नहीं तोड़ता - सीजेएम के दुभाषिए का आउटपुट सिर्फ वर्ड रैप होता है। बस किसी भी मामले में भ्रमित हो जाता है।

— Sp3000

Answer 2

अजगर, 20 बाइट्स

V.Tmrj" *"d9Qpe+d-Nd

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

व्याख्या

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)

Comments

यह मेरे द्वारा की गई तुलना में बेहतर है।

— isaacg

Answer 3

जावास्क्रिप्ट ईएस 6, 104 बाइट्स

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

उदाहरण उपयोग

एक अनुरूप कंसोल में इनपुट:

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

अंतिम विवरण से आउटपुट:

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

व्याख्या

यह cतीन अभिव्यक्तियों से एक अनाम फ़ंक्शन बनाता है जो तार्किक रूप से-एंडेड एक साथ किया गया है। पहले दो कथन हमेशा सत्य होते हैं, और जेएस शॉर्ट-सर्किट नियम कहते हैं कि जब भी पहला सत्य हो, तो पूरे मूल्य को दाहिने हाथ की तरफ (बिना बूलियन के लिए) वापस लौटाएं: इसलिए यह औपचारिक रूप से इसके बराबर है

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

पहले बयान को ऊपर के कोष्ठकों में लपेटना पड़ता है क्योंकि असाइनमेंट ऑपरेटर =की तार्किक-और ऑपरेटर की तुलना में कम पूर्वता होती है &&।

"बाकी पैरामीटर" विधानसभा ..."*"+vभी ES6 का हिस्सा है; यह *स्ट्रिंग के लिए एक अग्रणी को समेटता है और फिर इसे सूची-जैसे पैरामीटर के रूप में व्याख्या करता है, इसे तर्कों के एक समूह में विभाजित करता है Array.prototype.splice, जो तत्वों को हटाने के लिए (m, n, ...rest)स्थिति पर अपनी सरणी को लेता और संशोधित करता है और फिर सभी तर्कों को सम्मिलित करता है। ES6 से पहले इसे पूरा करने के लिए आप अधिक बोझिल का उपयोग करेंगे:mnrest

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

इसके बाद खाली स्ट्रिंग के साथ ऐरे को समतल कर दिया जाता है और व्‍हाइटिंग व्‍हाट्सएप को हटा दिया जाता है।

Answer 4

पायथन 2, 67 बाइट्स

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

इनपुट को पसंद करता है [('Heathrow', 0), ('Edinburgh', 2), ('London', 4), ('Liverpool', 6), ('Oxford', 8)]और परिणाम को प्रिंट करता है।

पायथन स्ट्रिंग्स को संशोधित करने की अनुमति नहीं देता है, और सूची से और इससे परिवर्तित करना महंगा है। तो, यह zएक नए शब्द में जोड़ने के लिए स्ट्रिंग को फिर से बनाता है । हम bवर्णों को शब्द से पहले लेते हैं , यदि आवश्यक हो तो रिक्त स्थान के साथ पैडिंग, फिर तारांकन के साथ नया पाठ, फिर zनए शब्द के बाद का भाग । ध्यान दें कि अनुगामी रिक्त स्थान कभी नहीं जोड़े जाते हैं।

reduceसंस्करण 3 वर्ण लंबे समय तक (70) है:

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

Answer 5

रूबी, 94 81 75 बाइट्स

golfed:

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

यहाँ अन-कोडित कोड है:

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

धन्यवाद @ w0lf इनपुट मानचित्रण पर सुझाव के लिए!

धन्यवाद @ w0lf और @ नहीं है कि एक चर को हटाने पर विचार के लिए चार्ल्स।

Comments

रूबी गोल्फ युक्तियाँ देखें । इस मामले में आप आवेदन कर सकता है $ <नक्शा {| एल | ...} जबकि एल तुलना में कम है = हो जाता है;। ...; अंत टिप और शायद की जगह puts के साथ $><<(जो अतिरिक्त स्थान की आवश्यकता नहीं है)।

— क्रिस्चियन लुपस्कु

इसके अलावा, मुझे लगता है कि .chompहटाया जा सकता है।

— क्रिश्चियन लुपस्क्यू

इस मामले में, अब जब आप इसका उल्लेख करते हैं, तो मुझे लगता है कि इसे हटाने के लिए बहुत सुरक्षित है, क्योंकि .to_iयह पकड़ लेगा। अच्छा विचार। धन्यवाद @ w0lf!

— आलू ३.३४

आपका स्वागत है! यहां एक छोटा संस्करण है जिसमें मैंने ऊपर दिए गए सुझावों को लागू किया है और कुछ और: ideone.com/BiOvV5 । यदि आप इसे पसंद करते हैं तो अपने उत्तर में इसे पोस्ट करने के लिए स्वतंत्र महसूस करें।

— क्रिश्चियन लुपस्क्यू

@PotatoOmeletteSandwich अपनी रूबी को अपग्रेड करें। १. -. जीवन-अंत है! इसके अलावा, आपको 1 चार बचत के s[int, int]बदले फॉर्म का उपयोग करने में सक्षम होना चाहिए s[range]।

— नहीं कि चार्ल्स

Answer 6

जावास्क्रिप्ट 121 वर्ण

गैर-मानक सुविधाओं का उपयोग करना, फ़ायरफ़ॉक्स पर काम करता है।
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()

पुराना संस्करण: 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

Comments

/ +/ बहुत ज्यादा समझ में आता है \sनिराश मैं याद किया! क्या आप बाइट का उपयोग करके x=' '.repeat(255);और उससे बच सकते हैं .join?

— डोम हेस्टिंग्स

@DomHastings: JS स्ट्रिंग्स अपरिवर्तनीय हैं, इसलिए आपको .split('')इसे एक परिवर्तनशील डेटा संरचना में बदलना होगा , लेकिन उस समय Array(255).fill(' ')यह कम है। मेरे संस्करण में मेरी अधिकांश बचत (ए) "आप या तो एक फ़ंक्शन या प्रोग्राम दे सकते हैं" नियम का उपयोग करते हैं और लॉजिक पार्ट को थोड़ा छोटा करने के लिए बाकी पैरामीटर के साथ अंतर्निहित विधि का उपयोग करके (बी) के eval(prompt())बदले में हटाने का नियम है। । c=>Array.prototype.slice

— सीआर ड्रॉस्ट

@ChrisDrost आह ... मैं भूल गया कि यह सिर्फ एक सहायक है! शर्म [].map.call(s[0],नहीं किसी को बचाती है ...

— डोम हेस्टिंग्स

Answer 7

पायथन, 85 बाइट्स

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

इसे ऑनलाइन आज़माएं

Comments

आपको एक बाइट बचाने 'z'[2::5]के ''.join(z)लिए (एपोस्ट्रोफिस के बजाय बैकटिक्स) करने में सक्षम होना चाहिए , और z=[' ']*256मापदंडों पर जाने से दूसरे को बचाया जा सकता है। इसके अलावा, मुझे लगता है कि आप बदल सकते हैं returnकरने के लिए print।

— काडे

मुझे लगता है कि आप p=input()एक समारोह के बजाय (पायथन 2) के साथ एक कार्यक्रम लिखकर चार्ट को बचा सकते हैं , जो इंडेंटेशन से बचा जाता है। इसके अलावा, b+len(a)+1हो सकता हैb-~len(a)

— xnor

दरअसल, एक प्रोग्राम आपको बस करने देता है for a,b in input():।

— xnor

Answer 8

पर्ल, 66 बाइट्स

63 बाइट्स स्क्रिप्ट + 3 बाइट्स के लिए -p

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

कुछ भी विशेष नहीं, चर का उपयोग करना $`और $'जो 'बराबरी से पहले' और 'मैच के बाद' क्रमशः स्ट्रिंग को विभाजित करने के बजाय हैं। मैं $}स्ट्रिंग चर के लिए इस्तेमाल करता था क्योंकि मूल रूप से यह मुझे एक बाइट बचा रहा था, लेकिन अब और नहीं!

उदाहरण रन:

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

---

पर्ल, 65 बाइट्स

62 बाइट्स स्क्रिप्ट + 3 बाइट्स के लिए -p

एक और संस्करण जो प्रत्येक पंक्ति को प्रिंट करता है (एक कम बाइट के लिए!)। (हां, मैंने इसे बनाया क्योंकि मैंने प्रश्न को ठीक से नहीं पढ़ा था ...)

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

उदाहरण रन:

$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

Answer 9

PHP - 84 बाइट्स

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

कर्सर की स्थिति के लिए ANSI एस्केप कोड का उपयोग करता है ( \x1b[XG, एस्केप कैरेक्टर और X को 1-आधारित कोऑर्डिनेट करते हुए), इसके बाद* उस पंक्ति के लिए इनपुट स्ट्रिंग। प्रपत्र की कमांड लाइन पर इनपुट स्वीकार करता है:

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

बहु-शब्द प्रविष्टियों को स्वीकार करता है अगर वे उद्धरण में हैं, क्योंकि वे कमांड लाइन तर्क हैं।

Answer 10

सी ++ 11, 95 बाइट्स

क्यों नहीं?

एक फ़ंक्शन के रूप में, स्थिति और स्ट्रिंग वाले map<int, string>नाम के रूप में इनपुट प्राप्त करें v।

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

प्रयोग

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

यहाँ चल रहा है की जाँच करें