लंबाई-एनकोड एक स्ट्रिंग

Question

मान लीजिए कि हम एक स्ट्रिंग को दूसरे स्ट्रिंग से खींचने के लिए निम्नलिखित नियमों का उपयोग करते हैं, एक जिसमें केवल ASCII प्रिंट करने योग्य अक्षर हैं और जिन्हें *-string कहा जाता है । यदि प्रक्रिया रुकने से पहले स्ट्रिंग बाहर निकल जाती है, तो यह एक त्रुटि है, और प्रक्रिया का परिणाम उस मामले में अपरिभाषित है:

1. के साथ शुरू d=1, s=""
2. जब भी आप एक मुठभेड़ करते हैं *, तो d2. से गुणा करें । जब भी आप किसी अन्य चरित्र का सामना करते हैं, तो इसे समाप्त करें sऔर 1 से घटाएं d। यदि अब d=0, रुकें और वापस लौटेंs

परिभाषित उदाहरण :

d->d
769->7
abcd56->a
*abcd56->ab
**abcd56->abcd
*7*690->769
***abcdefghij->abcdefgh

अपरिभाषित उदाहरण : (ध्यान दें कि खाली स्ट्रिंग इनमें से एक भी होगी)

*7
**769
*7*
*a*b
*

आपका काम एक स्ट्रिंग लेना है और *उस स्ट्रिंग को पैदा करने वाले सबसे छोटे-छोटे रिटर्न को वापस करना है ।

कार्यक्रम के उदाहरण :

7->7
a->a
ab->*ab
abcd->**abcd
769->*7*69

आपके प्रोग्राम को किसी भी स्ट्रिंग को संभालना चाहिए जिसमें कम से कम एक वर्ण और केवल गैर- *ASCII प्रिंट करने योग्य अक्षर हों। आप स्ट्रिंग्स को कभी नहीं लौटा सकते हैं जिसके लिए प्रक्रिया अपरिभाषित है, क्योंकि परिभाषा के अनुसार वे किसी भी तार का उत्पादन नहीं कर सकते हैं।

मानक कमियां और I / O नियम लागू होते हैं।

Comments

क्या हम मान सकते हैं कि इनपुट शामिल नहीं है *?

— लुइस मेन्डो

@DonMuesli "केवल गैर- * ASCII मुद्रण योग्य पात्र"

— FryAmTheEggman

Answer 1

पायथ ( 36 27 बाइट्स)

9 बाइट सुधार के लिए जकुबे का धन्यवाद! वर्तमान में कीचड़ वाली मछली का जवाब उतना अच्छा नहीं है , लेकिन जो भी हो

KlzJ1VzWgKyJp\*=yJ)pN=tK=tJ

परीक्षण सूट

अजगर का अनुवाद:

                            | z=input() #occurs by default
Klz                         | K=len(z)
   J1                       | J=1
     Vz                     | for N in z:
       WgKyJ                |   while K >= J*2:
            p\*             |     print("*", end="")
               =yJ          |     J=J*2
                  )         |     #end inside while
                   pN       |   print(N, end="")
                     =tK    |   K=K-1
                        =tJ |   J=J-1

Comments

लगता है कि मुडफिश की मौत हो गई है ...

— Rfish

Answer 2

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

f=(s,d=2)=>s?d>s.length?s[0]+f(s.slice(1),d-2):'*'+f(s,d*2):s

पुनरावर्ती कार्य जो निम्न कार्य करता है:

• यदि d2 से विभाजित स्ट्रिंग स्ट्रिंग लंबाई से कम या बराबर है:

  *आउटपुट में जोड़ें और d2 से गुणा करें

• अन्य:

  स्ट्रिंग को शिफ्ट करें और आउटपुट में जोड़ें, 1 से घटाएं d।

इसे कार्रवाई में देखें:

f=(s,d=2)=>s?d>s.length?s[0]+f(s.slice(1),d-2):'*'+f(s,d*2):s

input.oninput = e => output.innerHTML = f(input.value);

<input id="input" type="text"/>
<p id="output"></p>

Comments

हालत को उल्टा करके d plus a futher बाइट के दोगुने मूल्य के साथ काम करके 2 बाइट्स बचाएं:f=(s,d=2)=>s?d>s.length?s[0]+f(s.slice(1),d-2):'*'+f(s,d*2):s

— नील

Answer 3

पायथ, 29 27 ( नोटा टूटा हुआ) 27 26 25 बाइट्स

+*\*sKllzXJ-^2.EKlzz?J\*k

आने की व्याख्या।

परीक्षण सूट

Answer 4

सी, 125 बाइट्स

main(int q,char**v){++v;int i=1,n=strlen(*v);while(n>(i*=2))putchar(42);for(i-=n;**v;--i,++*v)!i&&putchar(42),putchar(**v);}

यह सही एन्कोडिंग का उत्पादन करने के लिए स्टार पदों के बहुत नियमित पैटर्न का लाभ उठाता है। प्रारंभ में मैंने एक शानदार पुनरावर्ती समाधान की कोशिश की, लेकिन पूर्वव्यापी में यह स्पष्ट होना चाहिए था कि एक सरल गणितीय समाधान था।

अनिवार्य रूप से आपके पास हमेशा 2^floor(log_2(length))अपने आउटपुट की शुरुआत में सितारे होंगे , और 2^ceil(log_2(length)) - lengthवर्णों के बाद एक अंतिम स्टार (यदि वह कम से कम 1 वर्ण के लिए काम करता है)।

निम्न (थोड़ा) ungolfed संस्करण इस प्रकार है

main(int q,char**v){
   ++v;                         // refer to the first command line argument
   int i=1, n=strlen(*v);       // set up iteration variables

   while(n > (i*=2))            // print the first floor(log2(n)) '*'s
      putchar(42);

   for(i-=n;  **v;  --i, ++*v)  // print the string, and the final '*'
      !i&&putchar(42),putchar(**v);
}

Answer 5

जावास्क्रिप्ट (ईएस 6), 88 77 बाइट्स

f=(s,l=s.length,p=2)=>l<2?s:p<l?"*"+f(s,l,p*2):s.slice(0,p-=l)+"*"+s.slice(p)

पहले मैंने सोचा था कि यह abcdeहोना चाहिए *a**bcdeलेकिन यह पता चला है कि **abc*deकाम भी करता है। इसका मतलब है कि उत्पादन आसानी से फर्श (log. (s.length)) अग्रणी सितारों का उपयोग करके बनाया गया है, साथ ही तारों के लिए एक अतिरिक्त स्टार है जिसकी लंबाई दो की शक्ति नहीं है।

संपादित करें: प्रमुख सितारों की संख्या की गणना करके 8 बाइट्स सहेजे गए। लंबाई 1 के विशेष आवरण तारों द्वारा एक और 3 बाइट्स को बचाया, ताकि मैं उन तारों का इलाज कर सकूं जिनकी लंबाई एक अतिरिक्त अग्रणी स्टार होने के रूप में 2 की शक्ति है।

Answer 6

हास्केल, 68 बाइट्स

f d[]=""
f d xs|length xs>=d*2='*':f(d*2)xs
f d(x:xs)=x:f(d-1)xs

अन्य उत्तरों के रूप में भी, वास्तव में। यदि ईओएफ, एक खाली स्ट्रिंग आउटपुट करता है। यदि शेष लंबाई दो बार से अधिक है d, तो एक स्टार और डबल आउटपुट करें d। अन्यथा, अगले चरित्र का उत्पादन और एक से घटाना d।

Ungolfed:

f d (  [])                    = ""
f d (  xs) | length xs >= d*2 = '*' : f (d*2) xs
f d (x:xs)                    =  x  : f (d-1) xs