การป้อนข้อมูล:

• สตริง (คลื่นข้อมูลโค้ด) >= 2ที่มีความยาว
• เป็นจำนวนเต็มบวกn >= 1

เอาท์พุท:

เราส่งคลื่นเดี่ยวบรรทัด เราทำสิ่งนี้โดยทำซ้ำสตริงอินพุตnครั้ง

กฏท้าทาย:

• หากอักขระตัวแรกและตัวสุดท้ายของอินพุตสตริงตรงกันเราจะแสดงผลลัพธ์เพียงครั้งเดียวในเอาต์พุตทั้งหมด (เช่น^_^ความยาว 2 กลายเป็น^_^_^และไม่ใช่^_^^_^)
• สตริงอินพุตจะไม่มี whitespaces / tabs / new-lines / etc ใด ๆ
• หากภาษาของคุณไม่รองรับอักขระที่ไม่ใช่ 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!)

Pyke, 15 14 10 ไบต์

tQQhQeq>*+

ลองที่นี่!

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

Python 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

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

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

ตัวอย่างออนไลน์

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

MATL, 19 17 14 ไบต์

ttP=l):&)liX"h

สิ่งนี้ใช้ได้กับ ASCII บนล่ามออนไลน์และสำหรับทั้งยูนิโค้ดและ ASCII เมื่อทำงานโดยใช้ MATLAB

ลองออนไลน์!

คำอธิบาย

        % 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

PS: ไม่น่าเชื่อว่า 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 Bytes

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

Pip , 18 ไบต์

โซลูชัน Regex ใช้ประโยชน์จากกฎ "ไม่มีช่องว่างในอินพุต" รับสายจาก 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และพื้นที่ในตอนท้ายของสตริงจะถูกลบออก จากนั้นผลลัพธ์จะถูกพิมพ์อัตโนมัติ

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

Java 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 ไบต์แปลงจาก Java 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

Javascript 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

ฉันเดาว่าฉันควรเพิ่ม LEFT $ และ RIGHT $ เป็น QBIC ...

คำอธิบาย:

;          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จำนวนครั้งสตริง มิฉะนั้นแบ่งสตริงให้ยาว -1 ทำซ้ำและใส่อักขระตัวสุดท้ายที่จุดสิ้นสุด

สามารถยอมรับอักขระ ASCII เท่านั้น (หรืออักขระที่สร้างขึ้นใน SpecBAS IDE)

APL, 19 ไบต์

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

การใช้งาน:

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

คำอธิบาย:

• ⊃⍺=⊃⌽⍺: ดูว่าตัวอักษรตัวแรกตรงกับตัวละครตัวสุดท้าย
• ⍺↓⍨: ในกรณีนี้ให้ดรอปอักขระแรก
• ⊂: ล้อมรอบผลลัพธ์
• ⍵⍴: ทำซ้ำ⍵ครั้ง
• 1↓: วางอันแรก (อันนี้สั้นกว่า(⍵-1)⍴)
• ∊: รับองค์ประกอบง่าย ๆ (เลิกทำการชกมวย)
• ⍺,: เพิ่มหนึ่งอินสแตนซ์ของสตริงทั้งหมดที่ด้านหน้า

Postscript ขนาด 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 ของคุณเพื่อล้างบัฟเฟอร์การสื่อสารอีกหกไบต์ :(

Common 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

คำอธิบาย:

~~ =>   ~

\" =>   " 

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

เป็นกลุ่ม, 17 ไบต์

วิธีง่ายๆในการทำเช่นนี้คือใช้ regex อ้างอิงกลับที่สามารถบอกได้ว่าตัวอักษรตัวแรกและตัวสุดท้ายตรงกันหรือไม่ แต่ regexes ยาวนั้นยาว เราไม่ต้องการสิ่งนั้น

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

คลื่นที่จะทำซ้ำอยู่ในบัฟเฟอร์ ฉันสมมติว่าจำนวนที่จะทำซ้ำอยู่ในการลงทะเบียน"a(พิมพ์qaNqด้วย N เป็นหมายเลขที่จะตั้งค่า) ความคิดคือ:

• หากการจับคู่แรกและไบต์สุดท้ายลบทุกอย่างจนถึงอักขระตัวสุดท้าย
• หากไบต์แรกและไบต์สุดท้ายไม่ตรงกันให้ลบอักขระทั้งหมด

จากนั้นPข้อความที่ถูกลบ@aครั้ง

• lDg*: การซ้อมรบนี้สร้าง regex ที่ตรงกับตัวละครตัวแรกโดยไม่คำนึงว่าจำเป็นต้องหลบหนีหรือไม่หรือไม่ว่าจะเป็นคำหรือไม่ก็ตาม ( *จะเพียงพอที่จะสร้าง regex ที่หลบหนีได้อย่างเหมาะสม แต่จะเพิ่ม\<\>ขยะที่ไม่ต้องการหากเป็นตัวอักษรของคำเช่น_)
• p^: ขั้นตอนสุดท้ายยุ่ง ทำความสะอาดถึงตำแหน่งเริ่มต้นของบรรทัด
• v$: ในโหมดวิชวล$โดยค่าเริ่มต้นจะย้ายไปยังหลังจากสิ้นสุดบรรทัด
• ?<C-P>$<CR>hd: หากมี regex ก่อนหน้าอยู่ท้ายบรรทัดการค้นหานี้จะย้ายไป มิฉะนั้นอยู่ที่ส่วนท้ายของบรรทัด เลื่อนไปทางซ้ายจากที่นั่นและเราทำการลบ (น่าเบื่อ) ที่เราต้องการ
• @aP: Pเรียกใช้ซ้ำตัวเลขเป็นแมโครที่จะใช้เป็นข้อโต้แย้งไปยัง

Ruby, 38 ไบต์

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

ฉันคิดว่านี่เป็นคำอธิบายที่ค่อนข้างดี ฉันยังสงสัยว่ามีวิธีรัดกุมมากกว่าในการเป็นตัวแทนs[0..-2]บล็อก แต่ฉันยังไม่พบมัน

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