입력:

• 길이가 문자열 (웨이브 스 니펫)입니다 >= 2.
• 양의 정수 n >= 1 입니다.

산출:

우리는 단일 라인 웨이브를 출력합니다. 입력 문자열을 n 번 반복하여이 작업을 수행합니다 .

도전 규칙 :

• 입력 문자열의 첫 번째 문자와 마지막 문자가 일치하면 전체 출력에서 ​​한 번만 출력합니다 (예 : ^_^길이 2는 ^_^_^아니고 ^_^^_^).
• 입력 문자열에는 공백 / 탭 / 줄 바꿈 등이 포함되지 않습니다.
• 귀하의 언어가 비 ASCII 문자를 지원하지 않는다면 괜찮습니다. ASCII 전용 웨이브 입력의 문제를 여전히 준수하는 한.

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 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!)

파이크, 15 14 10 바이트

tQQhQeq>*+

여기 사용해보십시오!

  QhQeq    -    input_1[0] == input_1[-1]
 Q     >   -   input_1[^:]
        *  -  ^ * V
t          -   input_2 - 1
         + - input_1 + ^

파이썬 3, 32 바이트

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

n문자열의 사본을 연결 하여 모든 사본에서 첫 번째 문자를 제거하고 첫 번째 문자가 마지막 문자와 일치하면 첫 번째 문자를 제거합니다.

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

자바 스크립트 (ES6), 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>

펄, 29 바이트

28 바이트 코드 + 1 -p.

몇 바이트 를 줄여 주는 @Dada 에게 감사드립니다 !

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'
*******

온라인 예.

펄, 23 바이트

에 +1 포함 -p

STDIN에서 별도의 줄에 입력 문자열과 숫자를 지정하십시오.

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

wave.pl:

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

단어의 첫 문자가 정규식 특수 문자가 아닌 경우이 22 바이트 버전도 작동합니다.

#!/usr/bin/perl -p
$_ x=<>;/./;s/
$&?//g

MATL, 19 17 14 바이트

ttP=l):&)liX"h

이것은 온라인 인터프리터의 ASCII와 MATLAB을 사용하여 실행될 때 유니 코드와 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

레티 나 , 29 바이트

2 행과 5 행에는 후행 공백이 있습니다.

 .+
$* 
 $


 $`
(.) +\1?
$1

온라인으로 사용해보십시오! 첫 번째 줄은 줄 바꿈으로 구분 된 테스트 스위트를 활성화합니다.

배치, 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%

반복 횟수를 명령 행 매개 변수로 사용하고 STDIN에서 문자열을 읽습니다.

Pyth, 13 바이트

+z*@tBzqhzezt

테스트 스위트!

따라야 할 설명.

Gema, 41 자

* *=@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'
*******

PowerShell v2 +, 48 바이트

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

첫 번째 문자와 마지막 문자가 일치하는지 여부에 따라 전체 문자열을 한 번 출력 한 다음 문자열 또는 하위 문자열의 n-1 복사본을 출력합니다.

.Substring()인덱스로부터 출력 방법은 그러한 경우, 문자열의 끝에 공급 $s[0]-eq$s[-1]거짓 (0)으로 평가, 우리는 전체 문자열을 얻는다. 해당 문장이 참이면 (1) 두 번째 문자부터 시작하는 부분 문자열을 얻습니다.

VBA 119 바이트

이 게임을 처음 사용하고 vba는 가장 높은 바이트 수를 얻습니다. : P

추신 : 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                                           |
+------------------------------------------------------------+-----------------------------------------------------------------------------------+

CJam, 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

K, 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 ,/[("-_";"-_")] --> "-_-_"

감사

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

핍 , 18 바이트

"입력 공간 없음"규칙을 이용하는 정규식 솔루션. stdin에서 문자열과 숫자를 명령 행 인수로 가져옵니다.

(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하고, 스트링의 끝에서의 공간을 제거한다. 그런 다음 결과가 자동으로 인쇄됩니다.

하스켈, 59 바이트

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

언 골프 버전 :

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

자바 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;}

온라인으로 사용해보십시오.

물론 내 자신의 질문에 대답하려고 노력할 것입니다. ;) @ dpa97
덕분에 -5 바이트 . Java 7에서 10으로 변환하는 -21 바이트

설명:

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

자바 스크립트 ES6, 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>

QBIC , 65 바이트

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

QBIC에 LEFT $와 RIGHT $를 추가해야한다고 생각합니다 ...

설명:

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

C #, 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
    )
;

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여러 번 인쇄하십시오 . 그렇지 않으면, 문자열을 length-1로 스플 라이스하고 반복하고 마지막 문자를 끝에 놓습니다.

ASCII 문자 (또는 SpecBAS IDE에 내장 된 문자) 만 허용

APL, 19 바이트

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

용법:

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

설명:

• ⊃⍺=⊃⌽⍺: 첫 번째 문자가 마지막 문자와 일치하는지 확인
• ⍺↓⍨:이 경우 첫 번째 문자를 삭제하십시오.
• ⊂: 결과를 동봉
• ⍵⍴: ⍵시간을 복제
• 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

...하지만 PS 인터프리터가 통신 버퍼, 또 다른 6 바이트를 플러시하려면 '플러시'가 필요할 수 있습니다.

공통 Lisp (LispWorks), 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

설명:

~~ =>   ~

\" =>   " 

언 골프 :

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

Vim, 17 바이트

가장 쉬운 방법은 첫 번째 문자와 마지막 문자가 일치하는지 확인할 수있는 역 참조 정규식을 사용하는 것입니다. 그러나 긴 정규 표현식은 길다. 우리는 그것을 원하지 않습니다.

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

반복 할 파도는 버퍼에 있습니다. 반복 할 숫자가 레지스터에 있다고 가정합니다 "a( qaNqN을 숫자로 설정하십시오). 아이디어는 다음과 같습니다.

• 첫 번째와 마지막 바이트가 일치하면 마지막 문자까지 모든 것을 삭제하십시오.
• 첫 번째 바이트와 마지막 바이트 가 일치 하지 않으면 모든 문자를 삭제하십시오.

그런 다음 P삭제 된 텍스트 @a시간.

• lDg*:이 기동은 이스케이프해야하는지 여부 또는 단어인지 여부에 관계없이 첫 번째 문자와 일치하는 정규식을 만듭니다. ( *정상적으로 이스케이프 된 정규 표현식을 작성하기에 충분하지만 \<\>단어 문자 인 경우 원치 않는 쓰레기를 추가합니다 _.)
• p^: 마지막 단계는 지저분했습니다. 라인의 시작 부분에서 원래 위치까지 청소하십시오.
• v$: 시각적 모드에서는 $기본적으로 줄 끝 이후로 이동합니다 .
• ?<C-P>$<CR>hd: 줄 끝에 이전 정규 표현식이 있으면이 검색으로 이동합니다. 그렇지 않으면 줄 끝을 넘어서십시오. 거기에서 왼쪽으로 이동하면 필요한 (지루한) 삭제를 수행합니다.
• @aP: 인수로 사용할 매크로로 숫자 반복을 실행하십시오 P.

루비, 38 바이트

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

나는 이것이 꽤 설명 적이라고 생각합니다. s[0..-2]블록 을 표현하는 더 간결한 방법이 있는지 여전히 궁금 하지만 아직 찾지 못했습니다.

자바 (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;}