Eingang:

• Ein String (das Wave-Snippet) mit einer Länge >= 2.
• Eine positive ganze Zahl n >= 1 .

Ausgabe:

Wir geben eine einzeilige Welle aus. Wir tun dies durch n- maliges Wiederholen der Eingabezeichenfolge .

Herausforderungsregeln:

• Wenn das erste und letzte Zeichen der Eingabezeichenfolge übereinstimmt, geben wir es in der Gesamtausgabe nur einmal aus (dh mit ^_^der Länge 2 wird ^_^_^und nicht ^_^^_^).
• Die Eingabezeichenfolge enthält keine Leerzeichen / Tabulatoren / Zeilenumbrüche / etc.
• Wenn Ihre Sprache keine Nicht-ASCII-Zeichen unterstützt, ist das in Ordnung. Solange es der Herausforderung mit ausschließlich ASCII-Welleneingang entspricht.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methode mit den richtigen Parametern und vollständige Programme verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie ggf. auch eine Erklärung hinzu.

Testfälle:

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

tQQhQeq>*+

Probieren Sie es hier aus!

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

Python 3, 32 Bytes

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

Verkettet nKopien der Zeichenfolge und entfernt das erste Zeichen von allen Kopien, aber das erste, wenn das erste Zeichen mit dem letzten übereinstimmt.

05AB1E , 13 Bytes

Verwendet CP-1252- Codierung.

D¬U¤XQi¦}I<×J

Probieren Sie es online!

Erläuterung

-___-und 3als Eingabe zum Beispiel verwendet.

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 Bytes

28 Byte Code + 1 für -p.

Vielen Dank an @Dada, der mir geholfen hat, ein paar Bytes zu entfernen !

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

Verwendung

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

Online-Beispiel.

Perl, 23 Bytes

Beinhaltet +1 für -p

Geben Sie die Eingabezeichenfolge gefolgt von der Nummer in separaten Zeilen auf STDIN ein

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

wave.pl:

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

Wenn das erste Zeichen im Wort kein reguläres Sonderzeichen ist, funktioniert auch diese 22-Byte-Version:

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

MATL, 19 17 14 Bytes

ttP=l):&)liX"h

Dies funktioniert für ASCII im Online-Interpreter und für Unicode und ASCII, wenn sie mit MATLAB ausgeführt werden.

Probieren Sie es online!

Erläuterung

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

Die Zeilen 2 und 5 haben ein Leerzeichen am Ende.

 .+
$* 
 $


 $`
(.) +\1?
$1

Probieren Sie es online! (Die erste Zeile aktiviert eine durch Zeilenvorschub getrennte Testsuite.)

Batch, 117 Bytes

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

Nimmt die Anzahl der Wiederholungen als Befehlszeilenparameter und liest die Zeichenfolge aus STDIN.

Pyth, 13 Bytes

+z*@tBzqhzezt

Testsuite!

Erklärung folgt.

Gema, 41 Zeichen

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

Probelauf:

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

Gibt die gesamte Zeichenfolge einmal aus, gefolgt von n-1 Kopien der Zeichenfolge oder der Teilzeichenfolge, je nachdem, ob das erste und das letzte Zeichen übereinstimmen.

Die .Substring()Methode gibt den Index aus, der an das Ende der Zeichenfolge übergeben wird. Wenn also $s[0]-eq$s[-1]false (0) ausgewertet wird, wird die gesamte Zeichenfolge abgerufen. Wenn diese Aussage wahr ist (1), erhalten wir die Teilzeichenfolge ab dem zweiten Zeichen.

VBA 119 Bytes

Neu in diesem Spiel und VBA gewinnt mit den höchsten Bytes: P

PS: kann nicht glauben , vba steht in der Nähe 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

Erläuterung:

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

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

Probieren Sie es online aus

Erläuterung:

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

Vielen Dank

PHP, 72 Bytes

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

mit PHP 7.1 könnte es auf 65 Bytes reduziert werden

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

Pip , 18 Bytes

Regex-Lösung, die die Regel "Keine Leerzeichen in der Eingabe" ausnutzt. Nimmt die Zeichenfolge von stdin und die Zahl als Befehlszeilenargument.

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

Probieren Sie es online!

Erläuterung:

 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

Somit, a b verwandelt sich in ab, a averwandelt sich in a, und der Raum am Ende der Schnur entfernt wird. Das Ergebnis wird dann automatisch ausgedruckt.

Haskell, 59 Bytes

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

Ungolfed-Version:

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

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

Probieren Sie es online aus.

Alternative mit gleicher Byteanzahl ( 79 Bytes ):

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

Probieren Sie es online aus.

Ich werde natürlich versuchen, meine eigene Frage zu beantworten. ;)
-5 Bytes dank @ dpa97 .
-21 Byte Konvertierung von Java 7 nach 10.

Erläuterung:

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 Zeichen

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

Prüfung:

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 Bytes

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

Ich denke, ich sollte LEFT $ und RIGHT $ zu QBIC hinzufügen ...

Erläuterung:

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

79 Bytes

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

Eine absurde Methode, einen String zu wiederholen. Erstellen Sie eine neue Zeichenfolge mit der gewünschten Wiederholungslänge und ersetzen Sie dann jedes Zeichen durch die zu wiederholende Zeichenfolge. Davon abgesehen sieht es nach der gleichen Strategie aus wie bei vielen anderen.

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

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

Verwendet Inline- IF, um zu prüfen, ob das erste und das letzte Zeichen gleich sind. Wenn nicht, drucken Sie die Zeichenfolgen mehrmals. Andernfalls spleißen Sie die Zeichenfolge auf die Länge 1, wiederholen Sie diese und setzen Sie das letzte Zeichen am Ende.

Kann nur ASCII-Zeichen (oder in SpecBAS IDE integrierte Zeichen) akzeptieren

APL, 19 Bytes

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

Verwendung:

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

Erläuterung:

• ⊃⍺=⊃⌽⍺: Überprüfen Sie, ob das erste Zeichen mit dem letzten Zeichen übereinstimmt
• ⍺↓⍨: Wenn dies der Fall ist, lassen Sie das erste Zeichen fallen
• ⊂: das Ergebnis beifügen
• ⍵⍴: repliziere es ⍵mal
• 1↓: Lass den ersten fallen (das ist kürzer als (⍵-1)⍴)
• ∊: Holen Sie sich alle einfachen Elemente (machen Sie das Boxen rückgängig)
• ⍺,: füge eine Instanz der ganzen Zeichenkette nach vorne hinzu

Postscript, 98 Bytes

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

... aber du brauchst vielleicht einen 'Flush', um deinen PS-Interpreter dazu zu bringen, den Kommunikationspuffer zu leeren, weitere sechs Bytes :(

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

Verwendung:

    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

Erläuterung:

~~ =>   ~

\" =>   " 

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 Bytes

Der einfache Weg, dies zu tun, besteht darin, einen Rückverweis-Regex zu verwenden, der erkennen kann, ob das erste und das letzte Zeichen übereinstimmen. Aber lange reguläre Ausdrücke sind lang. Das wollen wir nicht.

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

Die zu wiederholende Welle befindet sich im Puffer. Ich gehe davon aus, dass sich die zu wiederholende Nummer im Register befindet "a(geben Sie qaNqN als Nummer ein, um sie einzurichten). Die Idee ist:

• Wenn das erste und das letzte Byte übereinstimmen, löschen Sie alles bis zum letzten Zeichen.
• Wenn das erste und das letzte Byte nicht übereinstimmen, löschen Sie alle Zeichen.

Dann Pden gelöschten Text@a mal .

• lDg*: Dieses Manöver erstellt eine Regex, die mit jedem ersten Zeichen übereinstimmt, unabhängig davon, ob es maskiert werden muss oder nicht oder ob es sich um ein Wort handelt oder nicht. (* würde ausreichen, um die ordnungsgemäß entflohene Regex zu erstellen, würde aber unerwünschte hinzufügen\<\> Müll wenn es sich um ein Wort wie z _. B. handelt .)
• p^: Letzter Schritt war chaotisch. Bereinigen Sie bis zur ursprünglichen Position am Zeilenanfang.
• v$: Im visuellen Modus $ wird standardmäßig auf nach verschoben dem Zeilenende verschoben.
• ?<C-P>$<CR>hd: Wenn der vorherige reguläre Ausdruck am Ende der Zeile vorhanden ist, wird diese Suche dorthin verschoben. Andernfalls bleiben Sie über das Ende der Zeile hinaus. Bewegen Sie sich von dort nach links und wir führen das (mühsame) Löschen durch, das wir benötigen.
• @aP: Führen Sie die Zahlenwiederholung als Makro aus, das als Argument für verwendet werden soll P.

Ruby, 38 Bytes

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

Ich finde das ziemlich selbsterklärend. Ich frage mich immer noch, ob es eine präzisere Möglichkeit gibt, den s[0..-2]Block darzustellen , aber ich habe ihn noch nicht gefunden.

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