Memasukkan:

• Tali (potongan gelombang) dengan panjang >= 2.
• Bilangan bulat positif n >= 1 .

Keluaran:

Kami menampilkan gelombang single-line. Kami melakukan ini dengan mengulangi input string n kali.

Aturan tantangan:

• Jika karakter pertama dan terakhir dari string input cocok, kami hanya menampilkannya sekali dalam total output (yaitu ^_^panjang 2 menjadi ^_^_^dan tidak ^_^^_^).
• String input tidak akan mengandung spasi putih / tab / baris baru / dll.
• Jika bahasa Anda tidak mendukung karakter non-ASCII, maka itu tidak masalah. Selama masih sesuai dengan tantangan dengan input gelombang ASCII saja.

Aturan umum:

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa non-codegolf. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa saja'.
• Aturan standar berlaku untuk jawaban Anda, jadi Anda diperbolehkan menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat, program lengkap. Panggilanmu.
• Celah default tidak diperbolehkan.
• Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda.
• Juga, silakan tambahkan penjelasan jika perlu.

Kasus uji:

_.~"(              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>*+

Coba di sini!

  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

Menggabungkan nsalinan string, menghapus karakter pertama dari semua salinan tetapi yang pertama jika karakter pertama cocok dengan yang terakhir.

05AB1E , 13 byte

Menggunakan pengodean CP-1252 .

D¬U¤XQi¦}I<×J

Cobalah online!

Penjelasan

-___-dan 3digunakan sebagai input misalnya.

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

28 byte kode +1 untuk -p.

Terima kasih kepada @Dada karena telah membantu saya mengurangi beberapa byte!

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

Pemakaian

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

Contoh online.

Perl, 23 byte

Termasuk +1 untuk -p

Berikan string input diikuti dengan angka pada baris terpisah di STDIN

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

wave.pl:

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

Jika karakter pertama dalam kata itu bukan karakter khusus regex, versi 22 byte ini juga berfungsi:

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

MATL, 19 17 14 byte

ttP=l):&)liX"h

Ini berfungsi untuk ASCII pada juru bahasa online dan untuk unicode dan ASCII saat dijalankan menggunakan MATLAB.

Cobalah secara Online!

Penjelasan

        % 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

Retina , 29 byte

Baris 2 dan 5 memiliki ruang tambahan.

 .+
$* 
 $


 $`
(.) +\1?
$1

Cobalah online! (Baris pertama memungkinkan suite tes yang dipisahkan dengan linefeed.)

Batch, 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%

Mengambil jumlah pengulangan sebagai parameter baris perintah dan membaca string dari STDIN.

Pyth, 13 byte

+z*@tBzqhzezt

Suite uji!

Penjelasan untuk diikuti.

Gema, 41 karakter

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

Contoh dijalankan:

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

Keluarkan seluruh string satu kali, diikuti oleh n-1 salinan string atau substring, tergantung pada apakah karakter pertama dan terakhir cocok.

The .Substring()Metode output dari indeks dipasok ke akhir string, jadi jika $s[0]-eq$s[-1]mengevaluasi ke false (0), kita mendapatkan seluruh string. Jika pernyataan itu benar (1), Kami mendapatkan substring mulai dari karakter kedua.

VBA 119 byte

Baru dalam game ini dan vba menang dengan byte tertinggi: P

PS: tidak percaya vba berdiri dekat dengan JAWA 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

Penjelasan:

+------------------------------------------------------------+-----------------------------------------------------------------------------------+
|                            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@)@|@}*

Cobalah online

Penjelasan:

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 Bytes

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

Terima kasih

PHP, 72 Bytes

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

dengan PHP 7.1 bisa dikurangi menjadi 65 Bytes

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

Pip , 18 byte

Solusi Regex, mengambil keuntungan dari aturan "no spasi dalam input". Mengambil string dari stdin dan angka sebagai argumen baris perintah.

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

Cobalah online!

Penjelasan:

 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

Dengan demikian, a bberubah menjadi ab, a aberubah menjadi a, dan ruang di ujung tali dihilangkan. Kemudian hasilnya dicetak secara otomatis.

Haskell, 59 byte

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

Versi tidak disatukan:

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

Cobalah online.

Alternatif dengan byte-count yang sama ( 79 byte ):

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

Cobalah online.

Tentu saja saya akan mencoba menjawab pertanyaan saya sendiri. ;)
-5 byte terima kasih kepada @ dpa97 .
-21 byte mengkonversi dari Java 7 ke 10.

Penjelasan:

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 karakter

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

Uji:

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

Saya kira saya harus menambahkan $ KIRI dan $ KANAN ke QBIC ...

Penjelasan:

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

Sedikit metode yang aneh untuk mengulang suatu string. Buat string baru dengan panjang pengulangan yang diinginkan dan kemudian ganti setiap karakter dengan string untuk diulang. Selain itu, sepertinya strategi yang sama seperti banyak orang lain.

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

Menggunakan inline-IF untuk memeriksa apakah karakter pertama dan terakhir sama. Jika tidak, cetaklah string nbeberapa kali. Jika tidak, pisahkan string dengan panjang-1, ulangi dan masukkan karakter terakhir di akhir.

Hanya dapat menerima karakter ASCII (atau karakter yang dibangun di dalam IDE SpecBAS)

APL, 19 byte

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

Pemakaian:

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

Penjelasan:

• ⊃⍺=⊃⌽⍺: lihat apakah karakter pertama cocok dengan karakter terakhir
• ⍺↓⍨: jika ini masalahnya, lepaskan karakter pertama
• ⊂: lampirkan hasilnya
• ⍵⍴: mereplikasi itu ⍵kali
• 1↓: jatuhkan yang pertama (ini lebih pendek dari (⍵-1)⍴)
• ∊: dapatkan semua elemen sederhana (undo the boxing)
• ⍺,: tambahkan satu instance dari seluruh string ke depan

Catatan tambahan, 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

... tetapi Anda mungkin perlu 'flush' untuk memperbaikinya agar juru bahasa PS Anda menyiram buffer comm, enam byte lagi :(

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

Pemakaian:

    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

Penjelasan:

~~ =>   ~

\" =>   " 

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

Cara mudah untuk melakukan ini adalah dengan menggunakan regex referensi belakang yang dapat mengetahui apakah karakter pertama dan terakhir cocok. Tapi regex panjang itu panjang. Kami tidak menginginkan itu.

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

Gelombang yang akan diulang ada di buffer. Saya berasumsi nomor yang akan diulang ada di register "a(ketik qaNqdengan N sebagai nomor untuk mengaturnya) Idenya adalah:

• Jika byte pertama dan terakhir cocok, hapus semuanya hingga karakter terakhir.
• Jika byte pertama dan terakhir tidak cocok, hapus semua karakter.

Kemudian Pteks yang terhapus @adikali.

• lDg*: Manuver ini membuat regex yang cocok dengan karakter pertama apa pun, terlepas dari apakah perlu melarikan diri atau tidak, atau apakah itu sebuah kata atau tidak. ( *akan cukup untuk membuat regex lolos dengan benar, tetapi akan menambahkan \<\>sampah yang tidak diinginkan jika itu adalah karakter kata, seperti _.)
• p^: Langkah terakhir berantakan. Bersihkan ke posisi awal, awal baris.
• v$: Dalam mode visual, $secara default pindah ke setelah akhir baris.
• ?<C-P>$<CR>hd: Jika regex sebelumnya ada di akhir baris, pencarian ini akan pindah ke sana; jika tidak, tetap berada di luar batas. Bergerak ke kiri dari sana dan kami menyelesaikan penghapusan (membosankan) yang kami butuhkan.
• @aP: Jalankan pengulangan angka sebagai makro untuk digunakan sebagai argumen P.

Ruby, 38 byte

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

Saya pikir ini cukup jelas. Saya masih bertanya-tanya apakah ada cara yang lebih ringkas untuk mewakili s[0..-2]blok, tetapi saya belum menemukannya.

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