Đầu vào:

• Một chuỗi (đoạn sóng) có độ dài >= 2.
• Một số nguyên dương n >= 1 .

Đầu ra:

Chúng tôi tạo ra một sóng đơn. Chúng tôi làm điều này bằng cách lặp lại chuỗi đầu vào n lần.

Quy tắc thử thách:

• Nếu ký tự đầu tiên và cuối cùng của chuỗi đầu vào khớp với nhau, chúng ta chỉ xuất nó một lần trong tổng đầu ra (nghĩa là ^_^độ dài 2 trở thành ^_^_^và không ^_^^_^).
• Chuỗi đầu vào sẽ không chứa bất kỳ khoảng trắng / tab / dòng mới / v.v.
• Nếu ngôn ngữ của bạn không hỗ trợ các ký tự không phải ASCII, thì tốt thôi. Miễn là nó vẫn tuân thủ thách thức với đầu vào sóng chỉ ASCII.

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Các quy tắc chuẩn áp dụng cho câu trả lời của bạn, vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp, các chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn.
• Ngoài ra, xin vui lòng thêm một lời giải thích nếu cần thiết.

Các trường hợp thử nghiệm:

_.~"(              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!)

Pyke, 15 14 10 byte

tQQhQeq>*+

Hãy thử nó ở đây!

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

Python 3, 32 byte

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

Nối các nbản sao của chuỗi, loại bỏ ký tự đầu tiên khỏi tất cả các bản sao nhưng ký tự đầu tiên nếu ký tự đầu tiên khớp với ký tự cuối cùng.

05AB1E , 13 byte

Sử dụng mã hóa CP-1252 .

D¬U¤XQi¦}I<×J

Hãy thử trực tuyến!

Giải trình

-___-và 3được sử dụng làm đầu vào chẳng hạn.

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

JavaScript (ES6), 47 byte

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>

Perl, 29 byte

Mã 28 byte + 1 cho -p.

Cảm ơn @Dada đã giúp tôi cạo sạch một vài byte!

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

Sử dụng

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

Ví dụ trực tuyến.

Perl, 23 byte

Bao gồm +1 cho -p

Đưa ra chuỗi đầu vào theo sau là số trên các dòng riêng biệt trên STDIN

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

wave.pl:

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

Nếu ký tự đầu tiên trong từ không phải là ký tự đặc biệt regex thì phiên bản 22 byte này cũng hoạt động:

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

MATL, 19 17 14 byte

ttP=l):&)liX"h

Điều này hoạt động cho ASCII trên trình thông dịch trực tuyến và cho cả unicode và ASCII khi chạy bằng MATLAB.

Hãy thử trực tuyến!

Giải trình

        % 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

Võng mạc , 29 byte

Dòng 2 và 5 có một không gian dấu.

 .+
$* 
 $


 $`
(.) +\1?
$1

Hãy thử trực tuyến! (Dòng đầu tiên cho phép bộ kiểm tra được phân tách bằng nguồn cấp.)

Mẻ, 117 byte

@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%

Lấy số lần lặp lại dưới dạng tham số dòng lệnh và đọc chuỗi từ STDIN.

Bình thường, 13 byte

+z*@tBzqhzezt

Bộ thử nghiệm!

Giải thích để làm theo.

Gema, 41 ký tự

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

Chạy mẫu:

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 byte

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

Xuất toàn bộ chuỗi một lần, theo sau là n-1 bản sao của chuỗi hoặc chuỗi con, tùy thuộc vào việc ký tự đầu tiên và ký tự cuối có khớp hay không.

Các .Substring()kết quả đầu ra phương pháp từ chỉ số cung cấp cho sự kết thúc của chuỗi, vì vậy nếu $s[0]-eq$s[-1]đánh giá lại là false (0), chúng tôi nhận được toàn bộ chuỗi. Nếu tuyên bố đó là đúng (1), chúng tôi nhận được chuỗi con bắt đầu từ ký tự thứ hai.

VBA 119 byte

Mới cho trò chơi này và vba thắng với số byte cao nhất: P

PS: không thể tin vba đứng gần 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

Giải trình:

+------------------------------------------------------------+-----------------------------------------------------------------------------------+
|                            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 byte

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

Dùng thử trực tuyến

Giải trình:

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 byte

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

Cảm ơn

PHP, 72 byte

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

với PHP 7.1, nó có thể giảm xuống còn 65 byte

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

Pip , 18 byte

Giải pháp Regex, tận dụng quy tắc "không có khoảng trống trong đầu vào". Lấy chuỗi từ stdin và số làm đối số dòng lệnh.

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

Hãy thử trực tuyến!

Giải trình:

 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

Do đó, a bbiến thành ab, a abiến thành avà không gian ở cuối chuỗi được loại bỏ. Sau đó, kết quả được tự động in.

Haskell, 59 byte

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

Phiên bản bị đánh cắp:

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

Java 10, 123 111 109 107 102 100 79 byte

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

Hãy thử trực tuyến.

Thay thế với cùng số đếm byte ( 79 byte ):

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

Hãy thử trực tuyến.

Tất nhiên tôi sẽ cố gắng trả lời câu hỏi của riêng tôi. ;)
-5 byte nhờ @ dpa97 .
-21 byte chuyển đổi từ Java 7 thành 10.

Giải trình:

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

Javascript ES6, 49 ký tự

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

Kiểm tra:

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 byte

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

Tôi đoán tôi nên thêm LEFT $ và RIGHT $ vào QBIC ...

Giải trình:

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

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

Một chút của một phương pháp vô lý để lặp lại một chuỗi. Tạo một chuỗi mới có độ dài lặp lại mong muốn và sau đó thay thế từng ký tự bằng chuỗi cần lặp lại. Ngoài ra, có vẻ như khá nhiều chiến lược giống như nhiều người khác.

/*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 byte

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

Sử dụng nội tuyến- IFđể kiểm tra xem các ký tự đầu tiên và cuối cùng có giống nhau không. Nếu không, in nsố chuỗi lần. Mặt khác, nối chuỗi thành độ dài-1, lặp lại điều đó và đặt ký tự cuối cùng vào cuối.

Chỉ có thể chấp nhận các ký tự ASCII (hoặc các ký tự được tích hợp trong SpecBAS IDE)

APL, 19 byte

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

Sử dụng:

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

Giải trình:

• ⊃⍺=⊃⌽⍺: xem nếu ký tự đầu tiên khớp với ký tự cuối cùng
• ⍺↓⍨: nếu đây là trường hợp, thả ký tự đầu tiên
• ⊂: kèm theo kết quả
• ⍵⍴: nhân rộng nó ⍵lần
• 1↓: thả cái đầu tiên (cái này ngắn hơn (⍵-1)⍴)
• ∊: có được tất cả các yếu tố đơn giản (hoàn tác quyền anh)
• ⍺,: thêm một thể hiện của toàn bộ chuỗi vào phía trước

Bản ghi, 98 byte

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

... nhưng bạn có thể cần một 'tuôn ra' được xử lý để có được trình thông dịch PS của bạn để xóa bộ đệm comm, sáu byte khác :(

Lisp thường gặp (LispWorks), 176 byte

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

Sử dụng:

    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

Giải trình:

~~ =>   ~

\" =>   " 

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

Vim, 17 byte

Cách dễ dàng để làm điều này là sử dụng biểu thức chính quy tham chiếu ngược có thể cho biết ký tự đầu tiên và ký tự cuối cùng có khớp hay không. Nhưng regexes dài là dài. Chúng tôi không muốn điều đó.

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

Sóng để lặp lại là trong bộ đệm. Tôi giả sử số được lặp lại là trong thanh ghi "a(gõ qaNqvới N là số để thiết lập). Ý tưởng là:

• Nếu các byte đầu tiên và cuối cùng khớp với nhau, hãy xóa mọi thứ cho đến ký tự cuối cùng.
• Nếu byte đầu tiên và cuối cùng không khớp, hãy xóa tất cả các ký tự.

Sau đó P lần xóa văn bản @a.

• lDg*: Thao tác này tạo ra một biểu thức phù hợp với bất kỳ ký tự đầu tiên nào, bất kể nó có cần được thoát hay không, hoặc đó có phải là một từ hay không. (* sẽ đủ để tạo regex thoát đúng, nhưng sẽ thêm \<\>rác không mong muốn nếu đó là một ký tự từ, như _.)
• p^: Bước cuối cùng là lộn xộn. Làm sạch đến vị trí ban đầu, bắt đầu của dòng.
• v$: Trong chế độ trực quan, $theo mặc định di chuyển đến sau kết thúc dòng.
• ?<C-P>$<CR>hd: Nếu regex trước tồn tại ở cuối dòng, tìm kiếm này sẽ di chuyển đến nó; nếu không, ở ngoài cuối dòng. Di chuyển sang trái từ đó và chúng tôi thực hiện xóa (tẻ nhạt) chúng tôi cần.
• @aP: Chạy số lặp lại dưới dạng macro được sử dụng làm đối số P.

Ruby, 38 byte

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

Tôi nghĩ rằng điều này là khá tự giải thích. Tôi vẫn tự hỏi liệu có cách nào ngắn gọn hơn để đại diện cho s[0..-2]khối không, nhưng tôi chưa tìm thấy nó.

Java (117 byte)

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