रिक्त स्थान भरें

14

इनपुट

एक nonnegative पूर्णांक n, और एक गैर-रिक्त स्ट्रिंग sजिसमें केवल अल्फ़ान्यूमेरिक वर्ण और अंडरस्कोर होते हैं _। का पहला चरित्र sनहीं है _। अंडरस्कोर sको रिक्त स्थान के रूप में व्याख्या की जाती है जिसे अन्य पात्रों से भरा जा सकता है।

हम "अनंत तार" के एक अनंत अनुक्रम को निम्नानुसार परिभाषित करते हैं। स्ट्रिंग को कई बार अनंत बार दोहराया जाता है । सभी के लिए , स्ट्रिंग को रिक्त स्थानों को भरने से प्राप्त किया जाता है , जिसके पात्रों को पहले से बदल दिया जाता है , दूसरे के साथ , और इसी तरह। चूंकि पहला अक्षर नहीं है , हर रिक्त स्थान अंततः भर जाता है, और हम अनंत स्ट्रिंग द्वारा निरूपित करते हैं जहां हर को इसके अंतिम मूल्य से बदल दिया गया है।s1 = s s s...sk > 1sk+1sks1_sks1[0]s1[1]s_s∞_

उत्पादन

एक स्ट्रिंग nके रूप में पहले अक्षर ।s∞

उदाहरण

इनपुट पर विचार करें n = 30और s = ab_c_। हमारे पास है

s1 = ab_c_ab_c_ab_c_ab_c_ab_c_ab_c_ab_c_...

के रिक्त स्थान पर प्रतिस्थापित , हमारे पास हैs1s1

s2 = abacbab_ccab_caabbc_abcc_abacbab_cc...

हम फिर से रिक्त स्थान का विकल्प देते हैं, जिसके परिणामस्वरूपs1

s3 = abacbabaccabbcaabbc_abcccabacbab_cc...

एक और प्रतिस्थापन:

s4 = abacbabaccabbcaabbcaabcccabacbabbcc...

इससे हम पहले से ही के 30 अक्षरों को घटा सकते हैं, जो हैंs∞

abacbabaccabbcaabbcaabcccabacb

यह सही आउटपुट है।

नियम

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

परीक्षण के मामलों

0  "ab__"    -> ""
1  "ab__"    -> "a"
3  "ab__"    -> "aba"
20 "ab"      -> "abababababababababab"
20 "ab__"    -> "abababababababababab"
20 "ab_"     -> "abaabbabaabaabbabbab"
30 "ab_c_"   -> "abacbabaccabbcaabbcaabcccabacb"
50 "ab_a_cc" -> "abaabccabaaaccabbacccabcaaccabbaaccabaaaccabcaccca"
50 "abc____" -> "abcabcaabcbcaaabcbcbcabcaaababccbcbabccabcabcaaaba"
code-golf  string 
— Zgarb
स्रोत
क्या हम विपरीत क्रम में इनपुट ले सकते हैं (उन भाषाओं में जहां ऑर्डर मायने रखता है)?
— मार्टिन एंडर
@ मार्टिनबटनर श्योर, मैं इसकी अनुमति दूंगा।
— जर्ग्बेल

जवाबों:

4

अजगर, १,

<ussC,cG\_GUQ*zQQ

पहली पंक्ति पर स्ट्रिंग के साथ इनपुट दिया जाना चाहिए, और दूसरे पर लंबाई, एसटीडीआईएन पर। उदाहरण के लिए:

abc____
50

इसे यहाँ आज़माएँ।

स्पष्टीकरण:

                             Implicit:
                             z = input()              z is the string.
                             Q = eval(input())        Q is the length.

<               Q            First Q characters of
 u         UQ*zQ             Reduce, with an initial value of z repeated Q times, 
                             on the list range(len(Q)).
                             Since the reduce function doesn't use the sequence variable H
                             this function amounts to applying the inner code Q times to
                             the initial value, where the working variable is G.
  ss                         Sum from list of tuples of strings, to tuple of strings,
                             to string.
    C,                       Zip together
      cG\_                   G split on underscores
          G                  with G.
                             This inserts a character of G between every underscore
                             separated group of G, which amounts to replacing the
                             underscores with characters of G, after summation.
— isaacg
स्रोत
7

एपीएल २ ९ २ 29

{a⊣(b/a)←a↑⍨+/b←'_'=a←⍺⍴⍵}⍣≡

यह इस तरह प्रयोग किया जाता है:

fun←{a⊣(b/a)←a↑⍨+/b←'_'=a←⍺⍴⍵}⍣≡
20 fun 'ab_c_'
abacbabaccabbcaabbca

स्पष्टीकरण:

a←⍺⍴⍵           makes vector long as left argument using repeated chars in right argument
a↑⍨+/b←'_'=a   takes a string from the beginning of string a (a↑⍨), long as the number of _'s in a (+/b←'_'=a)
(b/a)←          puts those chars in place of the _'s in the original vector
a⊣             and returns a
{}⍣≡            repeats function ( {} ) until results doesn't change anymore

Tryapl.org

— मोरिस ज़ुक्का
स्रोत
⍣≡एक शून्य विचार है। हो सकता है कि मैं इसे J ...
— FUZxxl
7

CJam, 26 24 20 बाइट्स

4 बाइट्स ने पीटर को धन्यवाद दिया।

l~:I*{_'_/[\]zsI<}I*

इसका परीक्षण यहां करें। nSTDIN पर स्ट्रिंग को पहले और दूसरे स्थान पर ले जाता है ।

आप सभी परीक्षण मामलों को इनपुट में चिपकाकर चला सकते हैं जैसे वे हैं ( -> outputयदि आप चाहें तो शामिल करें ), और निम्नलिखित परीक्षण दोहन का उपयोग करके (जो कोड के लिए आदेश को उलट देता है):

qN/{"->"/0=S/W%S*

~:I*{_'_/[\]zsI<}I*

]oNo}/

व्याख्या

l~:I*{_'_/[\]zsI<}I*
l~                       "Read the input and evaluate.";
  :I                     "Store n in I for future use.";
    *                    "Repeat s n times to ensure it's long enough for the output.";
     {           }I*     "Repeat this block n times. This will always be enough passes.";
      _                  "Duplicate the string.";
       '_/               "Split the string on underscores.";
          [\]            "Swap with the other copy, putting both in an array.";
             z           "Zip the two arrays together, interleaving substrings from the split
                          copy with characters from the unsplit copy. Extraneous
                          characters from the unsplit copy just go at the end and
                          can be ignored.";
              s          "Convert the result into a string, flattening the array in the
                          process. This basically joins the two interleaved strings together.";
               I<        "Truncate to n characters.";

परिणाम कार्यक्रम के अंत में स्वचालित रूप से मुद्रित होता है।

इस पर ध्यान दें [\]: सिद्धांत रूप में, [स्टैक के वर्तमान आकार को याद ]करता है और एक सरणी में अंतिम याद किए गए आकार के लिए सब कुछ एकत्र करता है। हालाँकि, यदि बीच में याद किए गए आकार के नीचे सरणी आकार गिरता है, तो सरणी की शुरुआत तदनुसार समायोजित हो जाती है। अब आप सोच सकते हैं कि शीर्ष दो सरणी तत्वों को स्वैप करना सरणी आकार को बिल्कुल भी प्रभावित नहीं करता है, लेकिन \वास्तव में दो मानों को पॉप करता है और फिर उन्हें रिवर्स ऑर्डर में धकेल देता है। यह वह है जो सरणी की शुरुआत को दो से नीचे धकेलता है। इसलिए, [\]एक सरणी में शीर्ष दो स्टैक तत्वों को लपेटने का सबसे छोटा तरीका है। कभी-कभी, उन्हें रिवर्स ऑर्डर में इकट्ठा करने का साइड इफेक्ट काफी कष्टप्रद होता है, लेकिन इस मामले में, यह वास्तव में मेरी जरूरत है।

— मार्टिन एंडर
स्रोत
मुझे लगता है कि आप के _'_#) gसाथ बदल सकते हैं I*। मेरे लिए GolfScript में काम करता है।
— पीटर टेलर
@PeterTaylor ओह, बहुत अच्छा विचार, धन्यवाद!
— मार्टिन एंडर
6

पायथन 3, 110 बाइट्स

n=int(input())
*b,=input()*n
a=b[:n]
while"_"in a:b,a=b[:],[x*(x!="_")or b.pop(0)for x in a]
print("".join(a))

थोड़ा और अधिक गोल्फ की जरूरत है, लेकिन यहाँ कुछ सरासर पागलपन है। nतब sएसटीडीआईएन से पढ़ता है ।

मज़ेदार हिस्सा यह है कि लूप के असाइनमेंट में हम कॉपी करते हैं b, फिर bएक सूची समझ के दौरान पॉपिंग शुरू करते हैं । यदि असाइनमेंट दूसरे तरीके से होता तो यह काम नहीं करता!

— Sp3000
स्रोत
4

जावा - 162 174

यह हर दिन नहीं है जब मुझे जावा में डी: गोल्फिंग करते समय लूप का उपयोग करना पड़ता है

यह सिर्फ पुनरावृत्ति करता है और आते ही रिक्त स्थान को भर देता है। यह बस तब तक चलता रहता है जब तक _कि परिणाम में कोई अधिक न हो ।

char[]a(int n,char[]s){char[]o=new char[n];if(n>0)do for(int i=0,j=0;i<n;i++)if(o[i]==95|o[i]<1)o[i]=s[j++%s.length];while(new String(o).contains("_"));return o;}

लाइन ब्रेक के साथ:

char[]a(int n,char[]s){
    char[]o=new char[n];
    if(n>0)
        do
            for(int i=0,j=0;i<n;i++)
                if(o[i]==95|o[i]<1)
                    o[i]=s[j++%s.length];
        while(new String(o).contains("_"));
    return o;
}
— Geobits
स्रोत
मैं इसका जवाब देने वाला नहीं था, लेकिन दूसरे जावा का जवाब बहुत लंबा था।)
— जियोबिट्स
3

जावा 8, 238

(n,s)->{int i=0,j=0;for(s=String.join("",java.util.Collections.nCopies(n,new String(s))).toCharArray();j<1;){for(i=0;i<n;i++){for(;s[++j]!=95&j<n;);if(j<n)s[j]=s[i];}for(j=1,i=0;i<n;)j=s[++i]==95?0:1;}return java.util.Arrays.copyOf(s,n);}

कम गोल्फ वाला:

(Integer n, char[] s) -> {
    int i = 0, j = 0;
    for (s = String.join("", java.util.Collections.nCopies(n, new String(s))).toCharArray(); j < 1;) {
        for (i = 0; i < n; i++) {
            for (; s[j] != 95 & j < n; j++);
            if (j < n) {
                s[j] = s[i];
            }
        }
        for (j = 1, i = 0; i < n;) {
            j = s[++i] == 95 ? 0 : 1;
        }
    }
    return java.util.Arrays.copyOf(s, n);
}
— Ypnypn
स्रोत
3

रूबी, ६०

->n,s{eval"r=%1$p.chars;s.gsub!(?_){r.next};"*n%s*=n;s[0,n]}

Concatenates sही nबार, तो उत्पन्न nकोड की प्रतियां कि के साथ की जगह अंडरस्कोर s, उन प्रतियों का मूल्यांकन करता है, और पहली रिटर्न nपरिणाम के पात्रों। चूंकि प्रत्येक लूप में कम से कम एक अंडरस्कोर हटाया जाता है, इसलिए हमें nअंडरस्कोर-मुक्त वर्ण देने की गारंटी है ।

— histocrat
स्रोत
इसे चलाने के लिए सही सिंटैक्स क्या है? जब मैं इसे कॉल करता हूं fऔर चलाता puts f[10,"ab_"]हूं, तो मुझे निम्नलिखित त्रुटि मिलती है in 'eval': undefined method 'next' for #<Array:...:। यह तब प्रतीत होता है जब स्ट्रिंग में कोई अंडरस्कोर नहीं होता है।
— थियोफाइल
ओह, दिलचस्प है, यह String#charsरूबी 1.9.3 और रूबी 2.0 के बीच बदले हुए व्यवहार की तरह दिखता है ; रूबी 1 में यह एक एन्यूमरेटर देता है जब रूबी 2 में कोई ब्लॉक नहीं होता है। यह बदलकर संस्करण-संवेदी बनाया जा सकता है charsके लिए each_char, कोड के 4 अधिक शुद्ध बाइट्स की क्षति उठानी पड़ी।
— हिस्टोक्रेट
3

अजगर 2, 75

n,s=input()
S='';c=0
for x in s*n:b=x=='_';S+=S[c:c+b]or x;c+=b
print S[:n]

यह इनपुट की तरह की उम्मीद है (30,"ab_c_")।

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

निर्मित किया जा रहा उत्पादन है S, जो खाली शुरू होता है। हम sसर्कल के अनुकरण के लिए कई बार कॉपी किए गए इनपुट के पात्रों के माध्यम से लूप करते हैं । हम जाँचते हैं कि यह बूलियन के माध्यम से रिक्त है या नहीं b। हम x=='_'तुलना के बजाय समानता की जांच करते हैं क्योंकि अंडरस्कोर पूंजी और लोअरकेस अक्षरों के बीच स्थित है।

यदि चरित्र रिक्त नहीं है, तो हम इसे बस जोड़ते हैं S। यदि यह रिक्त है, तो हम आउटपुट-अब तक के अगले अप्रयुक्त पत्र को जोड़ते हैं S। हम एक इंडेक्स पॉइंटर द्वारा उपयोग किए गए अक्षरों को ट्रैक करते हैं cजो 0 से शुरू होता है और हर बार जब हम रिक्त होते हैं तो वेतन वृद्धि होती है।

अंत में, हम nपरिणामस्वरूप स्ट्रिंग के पहले अक्षर प्रिंट करते हैं S।

हमें S[c:c+b]छोटे के स्थान पर उपयोग करना होगा b*S[c]क्योंकि उत्तरार्द्ध Sखाली होने पर आउट-ऑफ-बाउंड त्रुटि देता है और c0. है। यह कभी मायने नहीं रखता क्योंकि हम गारंटी देते हैं कि पहला चरित्र sगैर-रिक्त है, इसलिए S[c]इसकी कभी आवश्यकता नहीं है, लेकिन कोड यह नहीं जानता। orशॉर्ट-सर्किट पर फ़्लिप करना भी इसे हल कर सकता है, लेकिन अधिक पात्रों की लागत।

पायथन 2, 83

इसहाक के समाधान का एक पायथ टू पायथन पोर्ट , जो प्रतिस्थापन का उपयोग करता है splitऔर करता है zip:

n,s=input()
s*=n
exec"s=''.join(a+b for a,b in zip(s.split('_'),s));"*n
print s[:n]

यह अधिक लंबा निकला, क्योंकि सुपरथॉन नाम के तरीके अजगर में लंबे होते हैं। लेकिन इसे शायद रिफ़्लिंग sऔर s.split('_')एक साथ एक छोटे तरीके से सुधार किया जा सकता है ।

— XNOR
स्रोत
अच्छा! इतनी छोटी होने के लिए स्ट्रिंग को फिर से संगठित करने की उम्मीद नहीं थी!
— Sp3000
3

हास्केल (93) 67

मैंने थोड़ी देर में कोई हास्केल नहीं लिखा है, इसलिए यह शायद बहुत कम हो सकता है। लेकिन यह बहुत अच्छा था, हमें इसे छोटा करना और बेहतर बनाना था!

('_':b)&(d:e)=d:b&e;(a:b)&c=a:b&c
f n s=take n$q where q=cycle s&q

उपयोग:

*Main> f 50 "ab_a_cc"
"abaabccabaaaccabbacccabcaaccabbaaccabaaaccabcaccca"
— मारीनस
स्रोत
2

बैच - 425

क्या मैं हार गया?

@echo off&setLocal enableDelayedExpansion&set s=%2
if "%3"=="" (for /l %%a in (1,1,%1)do set o=!o!%s%)else set o=%3
set o=!o:~0,%1!&set l=0
:c
if defined s set/al+=1&set "s=%s:~1%"&goto c
set s=%2&set/ap=%1-1
set y=&set c=0&for /l %%a in (0,1,%p%)do set x=!o:~%%a,1!&if !x!==_ (for %%b in (!c!)do set y=!y!!s:~%%b,1!&set/ac+=1)else (set y=!y!!x!)&if !c!==%l% set c=0
if "!y:_=!"=="!y!" echo !y!&goto :EOF
%0 %1 %2 !y!

बैच की सीमाएं हैं - मैं इसे स्वीकार करता हूं। उदाहरण के लिए; मुझे चर पार्सिंग सिंटैक्स की सीमाओं के कारण प्रयोग करने योग्य प्रारूप में एक एकल चर प्राप्त करने के लिए लूप के लिए उपयोग करना था। for %%b in (!c!)do... बस मौजूद है इसलिए मैं %%bइसके बजाय उपयोग कर सकता हूं !c!इसलिए मैं वास्तव में स्ट्रिंग हेरफेर कर सकता हूं !s:~%%b,1!और सही समय पर चर का विस्तार कर सकता हूं ।

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

— unclemeat
स्रोत
3
जब तक कोई और बेहतर बैच जवाब नहीं देता, मैं इसे खोना नहीं कहूंगा :)
— Sp3000
@ Sp3000 यदि केवल कोई होगा।
— चाचा
2

ईसीएमएस्क्रिप्ट 6, 78

f=(s,n,i=0)=>[...s.repeat(n)].reduce((s,x)=>s+(x=='_'?s[i++]:x),'').slice(0,n)

एक खाली स्ट्रिंग के साथ शुरू होता है और अंडरस्कोर की प्रत्येक घटना के लिए, इसे वर्तमान स्ट्रिंग के अगले सूचकांक में चरित्र के साथ बदल देता है।

— CPU1
स्रोत
1

पायथन 2 - 99 97 बाइट्स

क्योंकि 4 अजगर आधारित सबमिशन पर्याप्त नहीं हैं ...

n,s=input();S=s=s*n
while"_"in S:x=iter(s);S="".join(j>"_"and j or next(x)for j in S)
print S[:n]

उदाहरण:

$ python2 t.py 
(50, "ab_a_cc")
abaabccabaaaccabbacccabcaaccabbaaccabaaaccabcaccca
— matsjoyce
स्रोत
0

ईसीएमएस्क्रिप्ट 6, 93 91

(n,s)=>{for(x="_".repeat(n);n=0,/_/.test(x);)x=x.replace(/_/g,a=>s[n++%s.length]);return x}

पहले संस्करण से 2 पात्रों को शेव किया।

(n,s)=>{x="_".repeat(n);while(/_/.test(x)){n=0,x=x.replace(/_/g,a=>s[n++%s.length])}return x}
— n̴̖̋h̷͉a̷̭̿h̸̡̅ẗ̵̨d̷̰ĥ̷̳
स्रोत
0

सी # - 162

मैंने Geobits समाधान चुराया और इसे C # में बदल दिया

char[]p(int n,string s){var r=new char[n];if(n>0)do for(int i=0,j=0;i<n;i++)if(r[i]=='_'||r[i]<1)r[i]=s[j++%s.Length];while(r.ToList().IndexOf('_')>=0);return r;}

1 चार बेहतर, ताकि आप जियोबिट्स में सुधार कर सकें;)

— माइक m
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.