चलो वेव करते हैं!

29

इनपुट:

  • एक स्ट्रिंग (लहर-स्निपेट) एक लंबाई के साथ >= 2।
  • एक सकारात्मक पूर्णांक एन >= 1 ।

आउटपुट:

हम एकल-पंक्ति तरंग का उत्पादन करते हैं। हम इसे इनपुट स्ट्रिंग n बार दोहराकर करते हैं ।

चुनौती नियम:

  • यदि इनपुट स्ट्रिंग के पहले और अंतिम वर्ण से मेल खाता है, तो हम इसे केवल कुल आउटपुट में एक बार आउटपुट करते हैं (अर्थात ^_^लंबाई 2 बन जाती है ^_^_^और नहीं ^_^^_^)।
  • इनपुट स्ट्रिंग में कोई व्हाट्सएप / टैब / नई-लाइनें / आदि नहीं होंगे।
  • यदि आपकी भाषा गैर- ASCII वर्णों का समर्थन नहीं करती है, तो यह ठीक है। जब तक यह अभी भी ASCII- केवल तरंग-इनपुट के साथ चुनौती का अनुपालन करता है।

सामान्य नियम:

  • यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
    कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
  • मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
  • डिफ़ॉल्ट ढीले निषिद्ध हैं।
  • यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
  • इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

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

_.~"(              length 12
_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(

'°º¤o,¸¸,o¤º°'     length 3
'°º¤o,¸¸,o¤º°'°º¤o,¸¸,o¤º°'°º¤o,¸¸,o¤º°'

-__                length 1
-__

-__                length 8
-__-__-__-__-__-__-__-__

-__-               length 8
-__-__-__-__-__-__-__-__-

¯`·.¸¸.·´¯         length 24
¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯

**                 length 6
*******

String & length of your own choice (be creative!)
code-golf  string 
— केविन क्रूज़सेन
स्रोत
प्रश्न में परिणाम के साथ स्निपेट जोड़ना अच्छा होगा :)
— क्वर्टी
2
"ए पॉजिटिव पूर्णांक n >= 1 " मुझे थोड़े फुलेलॉस्टिक लगता है ... :)
— पाओलो

जवाबों:

23

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

lambda s,n:s+s[s[0]==s[-1]:]*~-n

nसभी प्रतियों में से पहले वर्ण को हटाते हुए स्ट्रिंग की प्रतियों को समेटता है , लेकिन यदि पहला वर्ण अंतिम से मेल खाता है।

— XNOR
स्रोत
यह प्रश्न के "¯` ·। · · ´¯" स्ट्रिंग को ठीक से संभाल नहीं करता है, है ना? जब मैं यह कोशिश करता हूं, s[0]और s[-1]पहले और आखिरी बाइट के बजाय पहले और आखिरी बाइट का संदर्भ देता हूं । संपादित करें: आह, रुको, वह पायथन 2 बनाम पायथन 3 है। यह पायथन 3 में सही ढंग से काम करता है।
— hvd
15

05AB1E , 13 बाइट्स

CP-1252 एन्कोडिंग का उपयोग करता है ।

D¬U¤XQi¦}I<×J

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

व्याख्या

-___-और 3उदाहरण के लिए इनपुट के रूप में उपयोग किया जाता है।

D              # duplicate input string
               # STACK: "-___-", "-___-"
 ¬U¤X          # push copies of the first and last element of the string
               # STACK: "-___-", "-___-", "-", "-"
     Q         # compare for equality 
               # STACK: "-___-", "-___-", 1
      i¦}      # if true, remove the first char of the copy of the input string
               # STACK: "-___-", "___-" 
         I<    # push input number and decrease by 1
               # STACK: "-___-", "___-", 2
           ×   # repeat the top string this many times
               # STACK: "-___-", "___-___-"
            J  # join with input string
               # STACK: "-___-___-___-"
               # implicitly output
— Emigna
स्रोत
11

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

f=
(s,n)=>s+s.slice(s[0]==s.slice(-1)).repeat(n-1)
;
<div oninput=o.textContent=n.value&&f(s.value,n.value)><input id=s><input id=n type=number min=1><div id=o>
स्निपेट का विस्तार करें

— नील
स्रोत
1
20k पर बधाई!
— अदनान
2
@ अदनान धन्यवाद! 20002 भी, जो अच्छा और सममित है।
— नील
1
क्या इस उदाहरण में करीना संभव है? मेरा मतलब s=>n=>...है(s,n)=>
— Zwei
8

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

28 बाइट्स कोड + 1 के लिए -p।

कुछ बाइट्स से मुझे दाढ़ी बनाने में मदद करने के लिए @ दादा का धन्यवाद !

s/^((.).*?)(\2?)$/$1x<>.$3/e

प्रयोग

perl -pe 's/^((.).*?)(\2?)$/$1x<>.$3/e' <<< "'°º¤o,¸¸,o¤º°'
3"
'°º¤o,¸¸,o¤º°'°º¤o,¸¸,o¤º°'°º¤o,¸¸,o¤º°'
perl -pe 's/^((.).*?)(\2?)$/$1x<>.$3/e' <<< '**
6'
*******

ऑनलाइन उदाहरण।

— डोम हेस्टिंग्स
स्रोत
2
अच्छा लगा। आप (परोक्ष रूप से) का उपयोग करके बचा सकता है 3 बाइट्स <>के बजाय $'के रूप में यह आप से छुटकारा पाने के लिए अनुमति देता है -0। और फिर आप एक और बाइट जीतने के s///eबजाय उपयोग कर सकते हैं //;$_=:-)
— दादा
@ दादा अच्छा ... मैंने अपने मूल प्रयास को पूरी तरह से खराब कर दिया और इसे ओवरसिम्प्लाइज़ किया और इसे बहुत बड़ा बना दिया ... मैंने आपकी टिप्पणियों को बोर्ड पर ले लिया है, लेकिन मुझे लगता है $कि मैच को समाप्त करने की आवश्यकता है , फिर भी मुझे बाइट्स के रूप में बचाता है उपयोग नहीं करने का 'मतलब है कि मैं इसे 3 के लिए जोड़ने के लिए एक फ़ाइल में सहेजने के लिए छोड़ सकता हूं -pऔर इसे 1 पर वापस छोड़ सकता हूं !
— डोम हेस्टिंग्स
1
Huhu। हां, वास्तव में $आपको पहले की गई नई लाइन के बजाय इसकी जरूरत है । (क्षमा करें, मेरी टिप्पणी बहुत विस्तृत नहीं थी, मैं जल्दी में था ...)
— दादा '
मुझे <>प्रतिस्थापित स्ट्रिंग में उपयोग करने का विचार पसंद है । लेकिन अगर nएक न्यूलाइन के बजाय एक स्थान से अलग किया जाता है, तो चरित्र की गिनती को थोड़ा कम किया जा सकता है:s/(.+?) (\d+)/$1x$2/e
— स्क्विश ओस्सिफ्रेज
1
@DomHastings आह, मेरी गलती है। प्रश्न को ठीक से नहीं पढ़ा :-)
— स्क्वीश ossifrage
6

पर्ल, 23 ​​बाइट्स

के लिए +1 शामिल है -p

STDIN पर अलग-अलग लाइनों पर नंबर के बाद इनपुट स्ट्रिंग दें

wave.pl <<< "'°º¤o,¸¸,o¤º°'
3"

wave.pl:

#!/usr/bin/perl -p
$_ x=<>;s/(.)\K
\1?//g

यदि शब्द का पहला वर्ण regex विशेष वर्ण नहीं है, तो यह 22 बाइट्स संस्करण भी काम करता है:

#!/usr/bin/perl -p
$_ x=<>;/./;s/
$&?//g
— टन हास्पेल
स्रोत
साफ! मुझे लगता है कि आप /gसंशोधक को भूल गए जब आपने इसे चिपकाया था ;-)
— दादा
@ दादा उफ़। फिक्स्ड
— टन हास्पेल
5

MATL, 19 17 14 बाइट्स

ttP=l):&)liX"h

MATLAB का उपयोग करते हुए चलाने पर यह ASCII के लिए ऑनलाइन दुभाषिया पर और यूनिकोड और ASCII दोनों के लिए काम करता है।

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

व्याख्या

        % Implicitly grab the input as a string
        %   STACK:  {'abcdea'}
        %
tt      % Make two copies and push them to the stack
        %   STACK:  {'abcdea'    'abcdea'    'abcdea'}
        %
P       % Flip the second copy around
        %   STACK:  {'abcdea'    'abcdea'    'aedcba'}
        %
=       % Perform an element-wise comparison. Creates a boolean array
        %   STACK:  {'abcdea'    [1 0 0 0 1]}
        %
l)      % Get the first element. If the first and last char are the same this will be
        % TRUE (1), otherwise FALSE (0)
        %   STACK:  {'abcdea'    1 }
        %
:       % Create an array from [1...previous result]. If the first char was repeated,
        % this results in the scalar 1, otherwise it results in an empty array: []
        %   STACK: {'abcdea'    1 } 
        %
&)      % Break the string into pieces using this index. If there were repeated
        % characters, this pops off the first char, otherwise it pops off
        % an empty string
        %   STACK: {'a'    'bcdea'}
        %
li      % Push the number 1 and explicitly grab the second input argument
        %   STACK: {'a'    'bcdea'    1    3}
        %
X"      % Repeat the second string this many times
        %   STACK: {'a'    'bcdeabcdeabcdea'}
        %
h       % Horizontally concatenate the first char (in case of repeat) 
        % or empty string (if no repeat) with the repeated string
        %   STACK: {'abcdeabcdeabcdea'}
        %
        % Implicitly display the result
— Suever
स्रोत
4

बैच, 117 बाइट्स

@set/ps=
@set t=%s%
@if %s:~0,1%==%s:~1% set t=%s:~1%
@for /l %%i in (2,1,%1)do @call set s=%%s%%%%t%%
@echo %s%

कमांड-लाइन पैरामीटर के रूप में दोहराव की संख्या लेता है और एसटीडीआईएन से स्ट्रिंग पढ़ता है।

— नील
स्रोत
3

गामा, ४१ अक्षर

* *=@subst{\? \$1=\?\; =;@repeat{$2;$1 }}

नमूना रन:

bash-4.3$ gema '* *=@subst{\? \$1=\?\; =;@repeat{$2;$1 }}' <<< '_.~"( 12'
_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(

bash-4.3$ gema '* *=@subst{\? \$1=\?\; =;@repeat{$2;$1 }}' <<< "'°º¤o,¸¸,o¤º°' 3"
'°º¤o,¸¸,o¤º°'°º¤o,¸¸,o¤º°'°º¤o,¸¸,o¤º°'

bash-4.3$ gema '* *=@subst{\? \$1=\?\; =;@repeat{$2;$1 }}' <<< '** 6'
*******
— आदमी काम पर है
स्रोत
3

PowerShell v2 +, 48 बाइट्स

Param($s,$n)$s+$s.Substring($s[0]-eq$s[-1])*--$n

पूरे स्ट्रिंग को एक बार आउटपुट करता है, उसके बाद स्ट्रिंग की एन -1 कॉपियां या सबस्ट्रिंग, इस पर निर्भर करता है कि पहले और आखिरी अक्षर मेल खाते हैं या नहीं।

.Substring()सूचकांक से विधि आउटपुट स्ट्रिंग के अंत करने के लिए आपूर्ति की है, इसलिए यदि $s[0]-eq$s[-1]झूठी (0) के लिए मूल्यांकन करता है, हम पूरी स्ट्रिंग मिलता है। यदि यह कथन सही है (1), तो हमें दूसरे वर्ण पर शुरू करने वाली सबस्ट्रिंग मिलती है।

— बेन ओवेन
स्रोत
डंगिट, हां मुझे कुछ मिनटों के लिए हराया। मेरे पास एक ही जवाब था ($ s और $ n के बजाय $ a और $ b का उपयोग करके)।
— AdmBorkBork
3

VBA 119 बाइट्स

इस खेल के लिए नया और vba उच्चतम बाइट्स के साथ जीतता है: पी

पुनश्च: विश्वास नहीं कर सकता vba JAVA HAHA के करीब है

Function l(s,x)
l=s: s=IIf(Left(s,1)=Right(s,1),Mid(s,2,Len(s)),s)
z: x=x-1: If x>0 Then l=l & s: GoTo z:
End Function

स्पष्टीकरण:

+------------------------------------------------------------+-----------------------------------------------------------------------------------+
|                            code                            |                                     function                                      |
+------------------------------------------------------------+-----------------------------------------------------------------------------------+
| l=s                                                        | input string s is saved to base                                                   |
| s = IIf(Left(s, 1) = Right(s, 1), Right(s, Len(s) - 1), s) | checks whether 1 and last char is equal,                                          |
|                                                            | if yes removes the first char from s and that s will be used to for further joins |
| z:                                                         | z: is a label                                                                     |
| x = x - 1:                                                 | decreases looping round                                                           |
| If x > 0 Then l = l & s: GoTo z:                           | join strings until no more rounds to do                                           |
+------------------------------------------------------------+-----------------------------------------------------------------------------------+
— क्रिश के.एम.
स्रोत
3
PPCG में आपका स्वागत है! खुद QBasic प्रोग्रामर के रूप में, मैं कहूंगा कि आप अधिकांश रिक्त स्थान निकाल सकते हैं और अभी भी मान्य VBA कोड है, क्योंकि आप शॉर्ट कोड (रिक्त स्थान जोड़ते हुए ऑटोफ़ॉर्मर के साथ) टाइप कर सकते हैं, या रन कर सकते हैं, और यह काम करता है। इससे आपका स्कोर काफी बेहतर होगा। :)
— DLosc
3

सीजेएम, 16 15 बाइट्स

l]li*{(s@)@|@}*

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

स्पष्टीकरण:

l]li*            Create a list of n-times the input string.
{(s@)@|@}*       Fold this list by taking out the last character of the first 
                 argument and the first character of the second argument and 
                 replacing them by their unique set union.
                 e.g.: "aba" "aba" -> "ab" 'a"a"| "ba" -> "ab" "a" "ba"
                       "abc" "abc" -> "ab" 'c"a"| "bc" -> "ab" "ca" "bc
— Neorej
स्रोत
2
मुझे आपकी तरंग-इनपुट पसंद है। :)
— केविन क्रूज़सेन
3

के, 12 बाइट्स

{,/[y#(,)x]}


/in action
{,/[y#(,)x]}["lollol";4]
"lollollollollollollollol"
{,/[y#(,)x]}["-_";10]
"-_-_-_-_-_-_-_-_-_-_"

/explanation (read function from right to left)
x is the string and y is the number of repetitions
(,)y    --enlist x so it becomes 1 value (rather than a list)
y#x     --take y many items of x
,/      --coalesce the list ,/[("-_";"-_")] --> "-_-_"

धन्यवाद

— Chromozorz
स्रोत
यह नियम 1 {,/y#,$[(*x)~*|x;-1;0]_x}को तोड़ता है। 25 बाइट्स के लिए पहला / अंतिम मिलान होता है। यदि आप नियम 1 को तोड़कर खुश हैं, तो आप {,/y#,x}8 के लिए हो सकते हैं
— स्ट्रीटस्टर
2

PHP, 72 बाइट्स

<?=($a=$argv[1]).str_repeat(substr($a,$a[0]==substr($a,-1)),$argv[2]-1);

PHP 7.1 के साथ इसे 65 बाइट्स तक कम किया जा सकता है

<?=($a=$argv[1]).str_repeat(substr($a,$a[0]==$a[-1]),$argv[2]-1);
— जार्ग हुल्सरमन
स्रोत
2

पिप , 18 बाइट्स

रेगेक्स समाधान, "इनपुट में रिक्त स्थान नहीं" नियम का लाभ उठाते हुए। स्टड से स्ट्रिंग लेता है और कमांड-लाइन तर्क के रूप में संख्या।

(q.s)XaR`(.) \1?`B

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

स्पष्टीकरण:

 q.s                Read from stdin and append a space
(   )Xa             String-multiply by first cmdline arg
       R            Replace
        `(.) \1?`     Regex: char followed by space followed by (optional) same char again
                 B    Callback function, short for {b}: return 1st capturing group

इस प्रकार, में a bबदल जाता है ab, a aबदल जाता है a, और स्ट्रिंग के अंत में स्थान हटा दिया जाता है। फिर परिणाम स्वतःपूर्ण है।

— DLosc
स्रोत
2

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

a%b=concat$replicate a b
a@(s:z)#n|s/=last z=n%a|1<2=s:n%z

Ungolfed संस्करण:

-- Helper: Appends str to itself n times
n % str = concat (replicate n str)

-- Wave creating function
(x:xs) # n
 -- If start and end of wave differ, 
 | x /= last xs = n%(x:xs)
 | otherwise   = x:(n%xs)
— क्रेग रॉय
स्रोत
2

जावा 10, 123 111 109 107 102 100 79 बाइट्स

s->n->{var r=s;for(;n-->1;r+=s.matches("(.).*\\1")?s.substring(1):s);return r;}

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

एक ही बाइट-काउंट ( 79 बाइट्स ) के साथ वैकल्पिक :

(s,n)->{for(var t=s.matches("(.).*\\1")?s.substring(1):s;n-->1;s+=t);return s;}

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

मैं निश्चित रूप से अपने खुद के सवाल का जवाब देने की कोशिश करूंगा। ;)
-5 बाइट्स @ dpa97 के लिए धन्यवाद ।
-21 बाइट जावा 7 से 10 तक परिवर्तित।

स्पष्टीकरण:

s->n->{                // Method with String and integer parameters and String return-type
  var r=s;             //  Result-String, starting at the input-String
  for(;n-->1;          //  Loop `n-1` times
    r+=s.matches("(.).*\\1")?
                       //   If the first and last characters are the same:
        s.substring(1) //    Append the result-String with the input-String, 
                       //    excluding the first character
       :               //   Else:
        s);            //    Append the result-String with the input-String
  return r;}           //  Return the result-String
— केविन क्रूज़सेन
स्रोत
1
s.split ("^।") [1] के बजाय s.replaceAll ("^।", "", ") काम करना चाहिए, एक युगल बाइट
— बचाएं
@ dpa97 धन्यवाद! मैंने इसे संपादित किया है। मैं हमेशा उपयोग करने के बारे में भूल जाता हूं .split।
— केविन क्रूज़सेन
@ dpa97 मुझे लगता है कि मैं (या हम) इसे उखाड़ फेंक रहे हैं .. s.substring(1)दो बाइट्स कम है। ;)
— केविन क्रूज़सेन
@KevinCurijssen हाँ, यह देखना चाहिए था, अच्छी खोज। मुझे लगता है कि मैं regex का उपयोग करने के विचार पर अटक गया था ...
— dpa97
1

जावास्क्रिप्ट ईएस 6, 49 चरस

(s,n)=>s.replace(/(.).*?(?=\1?$)/,m=>m.repeat(n))

परीक्षा:

f=(s,n)=>s.replace(/(.).*?(?=\1?$)/,m=>m.repeat(n))
console.log(document.querySelector("pre").textContent.split(`
`).map(s=>s.split` `).every(([s,n,k])=>f(s,n)==k))
<pre>_.~"( 12 _.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(
'°º¤o,¸¸,o¤º°' 3 '°º¤o,¸¸,o¤º°'°º¤o,¸¸,o¤º°'°º¤o,¸¸,o¤º°'
-__ 1 -__
-__ 8 -__-__-__-__-__-__-__-__
-__- 8 -__-__-__-__-__-__-__-__-
¯`·.¸¸.·´¯ 24 ¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯
** 6 *******</pre>
स्निपेट का विस्तार करें

— Qwertiy
स्रोत
1

QBIC , 65 बाइट्स

;:~left$$|(A,1)=right$$|(A,1)|A=left$$|(A,len(A)-1)][1,a|B=B+A]?B

मुझे लगता है कि मुझे QFT में बाएँ और दाएँ $ को जोड़ना चाहिए ...

स्पष्टीकरण:

;          make the first cmd line parameter into A$
:          make the second cmd line parameter into a (num)
~left..]   Drop the last char if equal to the first char
[1,a...]   FOR the given number of repetitions, concat A$ to B$ (starts out empty)
?B         print B$
— steenbergh
स्रोत
1

सी #, 79 बाइट्स

(s,n)=>s+new string('x',n-1).Replace("x",s[0]==s[s.Length-1]?s.Substring(1):s);

स्ट्रिंग को दोहराने की एक बेतुकी विधि। वांछित दोहराने की लंबाई का एक नया स्ट्रिंग बनाएं और फिर प्रत्येक वर्ण को दोहराने के लिए स्ट्रिंग के साथ बदलें। इसके अलावा, कई अन्य लोगों की तरह ही बहुत अधिक रणनीति की तरह दिखता है।

/*Func<string, int, string> Lambda =*/ (s, n) =>
    s                                      // Start with s to include first char at start
    + new string('x', n - 1).Replace("x",  // Concatenate n-1 strings of...
        s[0] == s[s.Length - 1]            // if first/last char are the same
            ? s.Substring(1)               // then skip the first char for each concat
            : s                            // else concat whole string each time
    )
;
— दूध
स्रोत
1
हम्म, यदि इनपुट स्ट्रिंग में ए हो तो क्या होगा x? शायद इसे अंतरिक्ष में बदलना बेहतर होगा, क्योंकि " इनपुट स्ट्रिंग में कोई व्हाट्सएप / टैब / नई-लाइनें / आदि शामिल नहीं होंगे। "
— केविन क्रूज़सेन
1
यदि इनपुट है तो यह ठीक काम करेगा x। यह xx...xस्ट्रिंग को पहले बनाता है और फिर प्रत्येक xको स्ट्रिंग के पुनर्मूल्यांकन के बिना शुरू से बदल देता है जिसे प्रतिस्थापित करने की आवश्यकता होती है।
— दूध
1

SpecBAS - 68 बाइट्स

1 INPUT a$,n: l=LEN a$: ?IIF$(a$(1)<>a$(l),a$*n,a$( TO l-1)*n+a$(l))

इनलाइन IFका उपयोग करता है- यह जांचने के लिए कि पहले और अंतिम अक्षर समान हैं या नहीं। यदि नहीं, तो nकई बार स्ट्रिंग संख्या प्रिंट करें । अन्यथा, स्ट्रिंग को लंबाई -1 में विभाजित करें, इसे दोहराएं और अंतिम चरित्र को अंत में रखें।

केवल ASCII वर्ण (या SpecBAS IDE में निर्मित वर्ण) स्वीकार कर सकते हैं

यहाँ छवि विवरण दर्ज करें

— ब्रायन
स्रोत
1

एपीएल, 19 बाइट्स

{⍺,∊1↓⍵⍴⊂⍺↓⍨⊃⍺=⊃⌽⍺}

उपयोग:

      '^_^' {⍺,∊1↓⍵⍴⊂⍺↓⍨⊃⍺=⊃⌽⍺} 5
^_^_^_^_^_^

स्पष्टीकरण:

  • ⊃⍺=⊃⌽⍺: देखें कि क्या पहला चरित्र अंतिम चरित्र से मेल खाता है
  • ⍺↓⍨: अगर ऐसा है, तो पहले पात्र को छोड़ दें
  • ⊂: परिणाम संलग्न करें
  • ⍵⍴: इसे ⍵बार-बार दोहराएं
  • 1↓: पहले वाले को छोड़ दो (यह इससे छोटा है (⍵-1)⍴)
  • ∊: सभी सरल तत्वों को प्राप्त करें (मुक्केबाजी को पूर्ववत करें)
  • ⍺,: सामने की ओर पूरी स्ट्रिंग का एक उदाहरण जोड़ें
— मारीनस
स्रोत
1

पोस्टस्क्रिप्ट, 98 बाइट्स

exch/s exch def/l s length 1 sub def s 0 get s l get eq{/s s 0 l getinterval def}if{s print}repeat

... लेकिन आपको अपने पीएस दुभाषिए को कम बफर को फ्लश करने के लिए एक 'फ्लश' की जरूरत पड़ सकती है, एक और छः बाइट्स :(

— दे दु
स्रोत
1

आम लिस्प (लिस्पवर्क्स), 176 बाइट्स

(defun f(s pos)(if(equal(elt s 0)(elt s #1=(1-(length s))))(let((s1(subseq s 0 1))(s2(subseq s 0 #1#)))(dotimes(j pos)(format t s2))(format t s1))(dotimes(j pos)(format t s))))

उपयोग:

    CL-USER 130 > (f "_.~~\"(" 12)
    _.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(
    NIL

    CL-USER 131 > (f "'°o¤o,??,o¤o°'" 3)
    '°o¤o,??,o¤o°'°o¤o,??,o¤o°'°o¤o,??,o¤o°'
    NIL

    CL-USER 132 > (f "-__" 1)
    -__
    NIL

    CL-USER 133 > (f "-__" 8)
    -__-__-__-__-__-__-__-__
    NIL

    CL-USER 134 > (f "ˉ`·.??.·′ˉ" 24)
    ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ
    NIL

    CL-USER 135 > (f "**" 6)
    *******
    NIL

स्पष्टीकरण:

~~ =>   ~

\" =>   "

Ungolf:

    (defun f (s pos)
      (if (equal (elt s 0) (elt s (1- (length s))))
          (let ((s1 (subseq s 0 1)) (s2 (subseq s 0 (1- (length s)))))
            (dotimes (j pos)
              (format t s2))
            (format t s1))        
        (dotimes (i pos)
          (format t s))))
— sadfaf
स्रोत
1

विम, 17 बाइट्स

ऐसा करने का आसान तरीका एक बैक-रेफ़रेंस रेक्सेक्स का उपयोग करना है, जो यह बता सकता है कि क्या पहला और आखिरी चार्ट मैच है। लेकिन लंबे रेगेक्स लंबे होते हैं। हम ऐसा नहीं चाहते हैं।

lDg*p^v$?<C-P>$<CR>hd@aP

दोहराने की लहर बफर में है। मैं मान रहा हूं कि संख्या दोहराया जाना रजिस्टर में है "a( qaNqइसे सेट करने के लिए संख्या के रूप में एन के साथ टाइप करें)। विचार यह है:

  • यदि पहला और अंतिम बाइट्स मेल खाते हैं, तो अंतिम वर्ण तक सब कुछ हटा दें।
  • यदि पहले और अंतिम बाइट्स मेल नहीं खाते हैं, तो सभी वर्णों को हटा दें।

फिर Pहटाए गए पाठ @aबार।

  • lDg*: यह पैंतरेबाज़ी किसी भी पहले चरित्र से मेल खाता है, भले ही यह बच निकलने की जरूरत है या नहीं, या यह एक शब्द है या नहीं। ( *ठीक से बच गए रेगेक्स को बनाने के लिए पर्याप्त होगा, लेकिन \<\>अगर यह एक शब्द चरित्र है, तो अवांछित कचरा जोड़ देगा _।)
  • p^: अंतिम चरण गड़बड़ था। मूल स्थिति तक सफाई करें, लाइन की शुरुआत।
  • v$: दृश्य मोड में, पंक्ति के अंत के बाद$ डिफ़ॉल्ट रूप से चलता है ।
  • ?<C-P>$<CR>hd: यदि पिछला रेगेक्स लाइन के अंत में मौजूद है, तो यह खोज उसके पास जाएगी; अन्यथा, पंक्ति के अंत से परे रहें। वहाँ से बाईं ओर ले जाएँ और हम (थकाऊ) को हटा दें जिसे हमें ज़रूरत है।
  • @aP: मैक्रो के रूप में दोहराए जाने वाले नंबर को तर्क के रूप में उपयोग करने के लिए चलाएँ P।
— udioica
स्रोत
1

रूबी, 38 बाइट्स

->s,n{s[0]==s[-1]?s[0..-2]*n+s[0]:s*n}

मुझे लगता है कि यह बहुत आत्म-व्याख्यात्मक है। मैं अभी भी सोच रहा हूं कि क्या प्रतिनिधित्व करने के लिए अधिक संक्षिप्त तरीका हैs[0..-2] ब्लॉक , , लेकिन मैंने अभी तक इसे नहीं पाया है।

— ली डब्ल्यू
स्रोत
0

जावा (117 बाइट्स)

String w(String a,int b){String c=a;for(;b>0;b--)c+=b+a.substring(a.charAt(a.length()-1)==a.charAt(0)?1:0);return c;}
— codecubed
स्रोत
1
नमस्ते, PPCG में आपका स्वागत है! हम्म, मैंने पहले ही एक छोटा जावा 7 उत्तर यहां पोस्ट किया है । आपका जो पहले था, उसके समान एक दृष्टिकोण का उपयोग करता है। यह एक ही दृष्टिकोण का उपयोग करके आप कर सकते थे गोल्फ b>0;b--के लिए b-->0;। इसके अलावा, b+वहाँ क्यों है c+=b+a.substring? फिर भी, यह एक महान पहला जवाब है अगर आप इसे स्वतंत्र रूप से लेकर आए हैं। PPCG पर अपने यहाँ रहने का आनंद लें! :) इसके अलावा, आपको पढ़ने के लिए दिलचस्प जावा में गोल्फिंग के लिए सुझाव मिल सकते हैं।
— केविन क्रूज़सेन 12
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.