स्ट्रिंग स्ट्रिंग सीढ़ी

12

एक स्ट्रिंग sऔर एक सकारात्मक पूर्णांक को देखते हुए N, धीरे-धीरे प्रत्येक वर्ण को Nडुप्लिकेट तक अधिक से अधिक डुप्लिकेट करें, और फिर Nडुप्लिकेट पर तब तक रहें जब तक कि Nवर्ण अंत से दूर न हों , फिर से नीचे कदम रखें।

उदाहरण के लिए, दिया abaloneऔर 3:

a    we start with 1 copy
bb   then 2 copies
aaa  then 3 copies, which is our second parameter
lll  so we continue using 3 copies
ooo  until we reach the end
nn   where we use 2 copies
e    and then finally 1 copy

और परिणाम होगा abbaaalllooonne।

यह गारंटी है स्ट्रिंग से लंबाई अधिक से अधिक है कि 2Nऔर केवल से कैरेक्टर हैं aकरने के लिए z।

अधिक टेस्टकेस:

N string       output
2 aaaaa        aaaaaaaa
3 abcdabcdabcd abbcccdddaaabbbcccdddaaabbbccd

यह कोड-गोल्फ है । बाइट्स जीत में सबसे छोटा जवाब। मानक खामियां लागू होती हैं।

code-golf  string 
— लीक नन
स्रोत

जवाबों:

11

जेली , 6 बाइट्स

JṡFṢị⁸

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

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

JṡFṢị⁸  Main link. Arguments: s (string), n (integer)

J       Get the indices of s.
 ṡ      Split the indices into overlapping chunks of length n.
  F     Flatten the array of chunks.
   Ṣ    Sort the resulting array of indices.
    ị⁸   Get the characters of s at these indices.

नमूना चला

JṡFṢị⁸  "abalone", 3

J       [1, 2, 3, 4, 5, 6, 7].
 ṡ      [[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7]]
  F     [1, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 6, 5, 6, 7]
   Ṣ    [1, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 7]
    ị⁸  "abbaaalllooonne"
— डेनिस
स्रोत
3
यह विभाजन + समतल + प्रकार विधि शुद्ध प्रतिभा है। अच्छा! :)
— हाइपरन्यूट्रीनो
7

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

f=lambda s,n,i=1:s and s[0]*len(s[:i][:n])+f(s[1:],n,i+1)

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

57 भी:

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

f=lambda s,n,i=1:s and s[0]*len(s[:i])+f(s[1:],n,i+(i<n))

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

— XNOR
स्रोत
क्या आप अपने तर्क की व्याख्या कर सकते हैं len(s[:i][:n])? मुझे यकीन है कि उस नंबर को प्राप्त करने का एक छोटा तरीका है लेकिन मुझे यकीन नहीं है कि कैसे।
— संगीतज्ञ 523
कोई बात नहीं, मैं समझ गया! लेकिन यह एक बाइट से भी छोटा है min(len(s),i,n)। अच्छा काम!
— संगीतकार ५२३
6

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

चास ब्राउन की छोटी विधि का उपयोग करके -2 बाइट्स धन्यवाद min()।

s=>n=>s.replace(/./g,(c,i)=>c.repeat(Math.min(i+1,s.length-i,n)))

करी सिंटैक्स में इनपुट लेता है f("abalone")(3):।

टेस्ट स्निपेट

f=
s=>n=>s.replace(/./g,(c,i)=>c.repeat(Math.min(i+1,s.length-i,n)))
<div oninput="O.value=f(S.value)(+N.value)">String: <input id=S> N: <input id=N size=3></div>Out: <input id=O size=50 disabled>
स्निपेट का विस्तार करें

— जस्टिन मेरिनर
स्रोत
6

जेली , 8 7 बाइट्स

J««U$⁸x

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

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

J««U$⁸x - main link, input e.g. abalone
J        - range of length of letters: [1,2,3,4,5,6,7]
 «       - minimum of each term with second input: [1,2,3,3,3,3,3]
  «U$    - termwise minimum with the reverse: 
                    min([1,2,3,3,3,3,3],[3,3,3,3,3,2,1])=[1,2,3,3,3,2,1]
     ⁸x  - repeat each character of the input a number of times corresponding to elements:
                    a*1;b*2;a*3...e*1 = abbaaalllooonne

-1 बाईट थैंक्स टू @LeakyNun

— fireflame241
स्रोत
अच्छा लगता है @LeakyNun! मैं उस दिशा में निकटतम J«¥@«U$x@9 बाइट्स के लिए था ।
— अग्निशमन 241
कृपया स्पष्टीकरण दें?
— कॉमरेड स्पार्कलेपनी
@ fireflame241 वास्तव में, (मैं यहाँ इस्तेमाल किया ) के बराबर x@⁸है⁸x⁸
— लीक नून
2

हास्केल , 61 60 बाइट्स

@ बाइटोनी को धन्यवाद 1 बाइट दाढ़ी बनाने में मदद करने के लिए

n#s=do(i,c)<-zip[1..]s;replicate(minimum[n,i,length s-i+1])c

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

Ungolfed:

(#) n string = do
    (i, char) <- zip [1..] string
    replicate (minimum [n, i, length(string)-i+1]) char
— जूलियन वुल्फ
स्रोत
एक doब्लॉक का महान उपयोग ! कोष्ठक को अंदर गिराकर एक बाइट को बचाएं length(s)।
— लाइकोनी
1

हास्केल (लैंबडॉट), 74 बाइट्स

r=replicate
f x n=join$zipWith r([1..n]++r(length x-2*n)n++reverse[1..n])x

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

— ბიმო
स्रोत
आयात स्कोर में गिनती! आप के साथ बेहतर होगा>>=id
— bartvelle
हाँ, मैंने ऐसा पहले भी किया था और तब मैंने यह देखा (इसीलिए कोष्ठक में लैम्बडबॉट है)। सही तरीका क्या है?
— ।
मैं सही हो गया, मुझे लगता है कि यह ठीक है!
— बर्तवेल्ले
यह जानकर अच्छा लगा कि उस सूची में बहुत अधिक आयात किए गए हैं।
— ბიმო
1

जे, 24 बाइट्स

(<.&n<./(|.,:[)>:i.#s)#s

परेंस में बिट - (<.&n<./(|.,:[)>:i.#s)- 1 2 ... n n n ... 2 1एरे बनाता है , निम्नानुसार है:

                   #s    length of s, call it L
                 i.      numbers 0 1 ... L-1
               >:        increment by 1, now 1 2 ... L
        (|.,:[)          fork: |. = reverse, ,: = stack, [ = identity
                         resulting in  L ... 2 1
                                       1 2 ... L 
     <./                 min of each element of the top and bottom row
 <.&n                    min of each resulting elm and n

एक बार हमारे पास, जे के #ऑपरेटर स्वचालित रूप से वही करता है जो प्रत्येक तत्व को निर्दिष्ट समय की संख्या को दोहराता है।

एक जे विशेषज्ञ की इस पर सुधार देखने के लिए उत्सुक ...

— जोनाह
स्रोत
एक बहुत अलग दृष्टिकोण के साथ 23 बाइट्स [#~#@[$([:>:<:,&:i.-)@](शायद एक आवारा अंतरिक्ष वहां पकड़ा गया)। मैं एक नुकसान में हूं कि हुक क्यों नहीं ले रहा है xलेकिन देखभाल करने के लिए बहुत अधिक स्थिति में नहीं है।
— कोल
1

PHP> = 7.1, 75 बाइट्स

for([,$a,$n]=$argv;--$z?:($x=$a[$i]).$z=min($n,strlen($a)-$i,++$i);)echo$x;

PHP सैंडबॉक्स ऑनलाइन

PHP> = 7.1, 78 बाइट्स

for([,$a,$n]=$argv;~$x=$a[$i];)for($z=min($n,strlen($a)-$i,++$i);$z--;)echo$x;

PHP सैंडबॉक्स ऑनलाइन

PHP> = 7.1, 80 बाइट्स

for([,$a,$n]=$argv;$i<$l=strlen($a);)echo str_repeat($a[$i],min($n,$l-$i,++$i));

PHP सैंडबॉक्स ऑनलाइन

— जार्ग हुल्सरमन
स्रोत
1

जाप , 11 10 बाइट्स

ËpVm°TEnUÊ

झसे आज़माओ

व्याख्या

स्ट्रिंग Uऔर पूर्णांक का निहित इनपुट V।

Ë

Uहर चरित्र को मैप करें और बदलें।

Vm

न्यूनतम प्राप्त करें V...

°T

T(शुरू में 0) 1 से बढ़ा, ...

EnUÊ

और वर्तमान चरित्र का सूचकांक E( n) लंबाई ( Ê) से घटाया गया है U।

p

वर्तमान चरित्र को दोहराएं जो कई बार।

अंतिम स्ट्रिंग को स्पष्ट रूप से आउटपुट करें।

— झबरा
स्रोत
0

अजगर 2 68 बाइट्स

f=lambda s,n:''.join(s[i]*min(i+1,len(s)-i,n)for i in range(len(s)))
— चास ब्राउन
स्रोत
आपको f=उत्तर की आवश्यकता नहीं है ; फ़ंक्शन अनाम हो सकता है। इसे ध्यान में रखते हुए, आप 3 बाइट्स निकाल सकते हैं lambda s,n:''.join(c*min(i+1,len(s)-i,n)for i,c in enumerate(s))।
— नॉटजागन
0

भूसी , 10 9 बाइट्स

₁₁ṀR
↔z↑N

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

पहली पंक्ति मुख्य कार्य है, यह प्रत्येक अक्षर को n बार दोहराता है और फिर दूसरी पंक्ति को दो बार कॉल करता है।

दूसरी पंक्ति दोहराए गए अक्षरों के प्रत्येक समूह से अधिकांश एन अक्षरों पर ले जाती है, जहां एन समूह का 1-आधारित सूचकांक है, फिर सूची को उलट देता है।

— सिंह
स्रोत
0

एपीएल (डायलॉग) , 15 बाइट्स

{⍵/⍨⍺⌊i⌊⌽i←⍳≢⍵}

{... } समारोह जहां बाईं तर्क (टोपी) है ⍺ और सही तर्क (स्ट्रिंग) है ⍵ :

 ≢⍵ स्ट्रिंग में वर्णों की संख्या गिनें

 ⍳ कि कई gers ntegers उत्पन्न करते हैं

 i← में स्टोर करता हूँ

 ⌽ उलटा

 i⌊मैं के  साथ जोड़ीदार न्यूनतम

 ⍺⌊ कैप के साथ जोड़ीदार न्यूनतम

 ⍵/⍨ स्ट्रिंग के अक्षरों को दोहराने के लिए उन नंबरों का उपयोग करें

 

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

— एडम
स्रोत
0

Abalone मछली का एक प्रकार है (अच्छी तरह से, एक शंख), इसलिए…

> <> , 79 बाइट्स

&i1\
0(?\:1+:&::&@)?$~i:@
&~}\&~1
0(?\:&::1+&@)?$~}}:
 ~r\
?!v>l?!;:o$1-:@
~~<^

इसे ऑनलाइन आज़माएं , या इसे देखें मछली के खेल के मैदान में देखें !

STDIN से स्ट्रिंग पढ़ता है, और मान लेता है कि संख्या पहले से ही स्टैक पर है।

व्याख्या: दूसरी, चौथी और छठी पंक्तियाँ मुख्य लूप हैं। विवरण कुछ बदसूरत स्टैक हेरफेर हैं, लेकिन व्यापक स्ट्रोक में, पहले, दूसरी पंक्ति इनपुट और मिनट ( i ,  n ) के चरित्र के बीच स्टैक को भरती है , जहां n लंबाई की टोपी है और मैं चरित्र का सूचकांक है इनपुट: "अबालोन" के लिए, 3, स्टैक जैसा दिखता है

"a", 1, "b", 2, "a", 3, "l", 3, "o", 3, "n", 3, "e", 3, -1=EOF, 3

अगला, पंक्ति 4 स्टैक के माध्यम से इसी तरह से रिवर्स में जाती है, दाहिने हाथ के छोर को ठीक से कैप करने के लिए:

"a", 1, "b", 2, "a", 3, "l", 3, "o", 3, "n", 2, "e", 1, -1

फिर छठी पंक्ति प्रत्येक वर्ण-संख्या जोड़ी को ले जाती है और वर्ण को संख्या के रूप में कई बार प्रिंट करती है।

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