Contribution:

• Une chaîne (l'extrait de vague) d'une longueur >= 2.
• Un entier positif n >= 1 .

Sortie:

Nous émettons une onde unifilaire. Nous faisons cela en répétant la chaîne d'entrée n fois.

Règles du défi:

• Si le premier et le dernier caractère de la chaîne d'entrée correspondent, nous ne le sortons qu'une seule fois dans la sortie totale (c'est ^_^-à- dire que la longueur 2 devient ^_^_^et non ^_^^_^).
• La chaîne d'entrée ne contiendra aucun espace / onglet / nouvelle ligne / etc.
• Si votre langue ne prend pas en charge les caractères non ASCII, c'est bien. Tant qu'il répond toujours au défi avec une entrée d'onde ASCII uniquement.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés, des programmes complets. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

Cas de test:

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

tQQhQeq>*+

Essayez-le ici!

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

Python 3, 32 octets

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

Concatène les ncopies de la chaîne, supprimant le premier caractère de toutes les copies, mais le premier si le premier caractère correspond au dernier.

05AB1E , 13 octets

Utilise l' encodage CP-1252 .

D¬U¤XQi¦}I<×J

Essayez-le en ligne!

Explication

-___-et 3utilisé comme entrée par exemple.

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 octets

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 octets

Code de 28 octets + 1 pour -p.

Merci à @Dada de m'avoir aidé à raser quelques octets!

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

Usage

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

Exemple en ligne.

Perl, 23 octets

Comprend +1 pour -p

Donnez la chaîne d'entrée suivie du numéro sur des lignes distinctes sur STDIN

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

wave.pl:

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

Si le premier caractère du mot n'est pas un caractère spécial regex, cette version de 22 octets fonctionne également:

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

MATL, 19 17 14 octets

ttP=l):&)liX"h

Cela fonctionne pour ASCII sur l'interpréteur en ligne et pour unicode et ASCII lorsqu'il est exécuté à l'aide de MATLAB.

Essayez-le en ligne!

Explication

        % 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

Rétine , 29 octets

Les lignes 2 et 5 ont un espace de fin.

 .+
$* 
 $


 $`
(.) +\1?
$1

Essayez-le en ligne! (La première ligne active une suite de tests séparés par un saut de ligne.)

Lot, 117 octets

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

Prend le nombre de répétitions comme paramètre de ligne de commande et lit la chaîne depuis STDIN.

Pyth, 13 octets

+z*@tBzqhzezt

Suite de tests!

Explication à suivre.

Gema, 41 personnages

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

Exemple d'exécution:

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 octets

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

Génère une fois la chaîne entière, suivie de n-1 copies de la chaîne ou de la sous-chaîne, selon que les premier et dernier caractères correspondent.

La .Substring()méthode sort de l'index fourni à la fin de la chaîne, donc si $s[0]-eq$s[-1]évalue à false (0), nous obtenons la chaîne entière. Si cette affirmation est vraie (1), nous obtenons la sous-chaîne à partir du deuxième caractère.

VBA 119 octets

Nouveau dans ce jeu et vba gagne avec les octets les plus élevés: P

PS: je ne peux pas croire que vba soit proche de 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

Explication:

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

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

Essayez-le en ligne

Explication:

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 octets

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

Merci

PHP, 72 octets

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

avec PHP 7.1, il pourrait être réduit à 65 octets

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

Pip , 18 octets

Solution Regex, profitant de la règle "pas d'espaces en entrée". Prend la chaîne de stdin et le nombre comme argument de ligne de commande.

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

Essayez-le en ligne!

Explication:

 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

Ainsi, se a btransforme en ab, se a atransforme en aet l'espace à la fin de la chaîne est supprimé. Le résultat est ensuite imprimé automatiquement.

Haskell, 59 octets

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

Version non golfée:

-- 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 109 107 102 100 79 octets

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

Essayez-le en ligne.

Alternative avec le même nombre d'octets ( 79 octets ):

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

Essayez-le en ligne.

Je vais bien sûr essayer de répondre à ma propre question. ;)
-5 octets grâce à @ dpa97 .
-21 octets conversion de Java 7 à 10.

Explication:

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 caractères

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

Tester:

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 octets

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

Je suppose que je devrais ajouter LEFT $ et RIGHT $ au QBIC ...

Explication:

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

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

Un peu une méthode absurde pour répéter une chaîne. Créez une nouvelle chaîne de la longueur de répétition souhaitée, puis remplacez chaque caractère par la chaîne à répéter. En dehors de cela, cela ressemble à peu près à la même stratégie que beaucoup d'autres.

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

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

Utilise inline-IF pour vérifier si les premier et dernier caractères sont identiques. Sinon, imprimez le nnombre de fois de la chaîne . Sinon, épissez la chaîne à la longueur 1, répétez cela et mettez le dernier caractère à la fin.

Ne peut accepter que des caractères ASCII (ou des caractères intégrés dans SpecBAS IDE)

APL, 19 octets

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

Usage:

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

Explication:

• ⊃⍺=⊃⌽⍺: voir si le premier caractère correspond au dernier caractère
• ⍺↓⍨: si tel est le cas, supprimez le premier caractère
• ⊂: joindre le résultat
• ⍵⍴: le reproduire ⍵fois
• 1↓: déposez le premier (c'est plus court que (⍵-1)⍴)
• ∊: récupérez tous les éléments simples (défaites la boxe)
• ⍺,: ajouter une instance de la chaîne entière au début

Postscript, 98 octets

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

... mais vous pourriez avoir besoin d'un "flush" collé dessus pour que votre interprète PS vide le tampon de communication, six autres octets :(

Lisp commun (LispWorks), 176 octets

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

Usage:

    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

Explication:

~~ =>   ~

\" =>   " 

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 octets

Le moyen le plus simple consiste à utiliser une expression rationnelle de référence arrière qui peut déterminer si les premier et dernier caractères correspondent. Mais les longues expressions régulières sont longues. Nous n'en voulons pas.

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

L'onde à répéter est dans le tampon. Je suppose que le nombre à répéter est dans le registre "a(tapez qaNqavec N comme nombre pour le configurer). L'idée est:

• Si le premier et le dernier octet correspondent, supprimez tout jusqu'au dernier caractère.
• Si les premier et dernier octets ne correspondent pas , supprimez tous les caractères.

Ensuite, Ple texte supprimé @afois.

• lDg*: Cette manœuvre crée un regex qui correspond à n'importe quel premier caractère, qu'il soit échappé ou non, que ce soit un mot ou non. ( *serait suffisant pour créer l'expression rationnelle correctement échappée, mais ajouterait des \<\>déchets indésirables s'il s'agissait d'un mot, comme _.)
• p^: La dernière étape était en désordre. Nettoyez à la position d'origine, au début de la ligne.
• v$: En mode visuel, $se déplace par défaut après la fin de la ligne.
• ?<C-P>$<CR>hd: Si la regex précédente existe à la fin de la ligne, cette recherche se déplacera vers elle; sinon, restez au-delà de la fin de la ligne. Déplacez-vous à gauche à partir de là et nous accomplissons la suppression (fastidieuse) dont nous avons besoin.
• @aP: Exécutez la répétition numérique sous forme de macro à utiliser comme argument P.

Rubis, 38 octets

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

Je pense que c'est assez explicite. Je me demande toujours s'il existe un moyen plus concis de représenter le s[0..-2]bloc, mais je ne l'ai pas encore trouvé.

Java (117 octets)

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