_{Nous n'avons pas eu de question de chaîne depuis un moment (5 jours pour être précis), alors allons-y.}

Étant donné une chaîne set un entier positif n, prenez chaque nélément de s, répétez-le nfois et remettez-le dans s.

Par exemple, si n = 3et s = "Hello, World!", chaque troisième caractère est Hl r!. Vous répétez ensuite chaque caractère npour produire HHHlll rrr!!!. Vous remplacez ensuite les lettres originales par les versions répétées pour produire le produit final deHHHellllo, Worrrld!!!

Vous devez accomplir cette tâche dans le code le plus court possible dans votre langue!

Règles

• Ceci est un code-golf donc le code le plus court en octets gagne
• nest garanti inférieur à la longueur set supérieur à 0
• Le premier caractère sest l' endroit où les ncaractères e sont tirés, et est toujours répété nfois
• sne consistera qu'en ASCII imprimable (le code pointe 0x20 (space)vers 0x7E (~))

Cas de test

s, n => output

"Hello, World!", 3 => "HHHellllo,   Worrrld!!!"
"Code golf", 1 => "Code golf"
"abcdefghijklm", 10 => "aaaaaaaaaabcdefghijkkkkkkkkkklm"
"tesTing", 6 => "ttttttesTingggggg"
"very very very long string for you to really make sure that your program works", 4 => "vvvvery    veryyyy verrrry loooong sssstrinnnng foooor yoooou toooo reaaaally    makeeee surrrre thhhhat yyyyour    proggggram    workkkks"

Gelée , 3 octets

Ḣs×

L'entrée est prise comme s, n .

Essayez-le en ligne!

Comment ça fonctionne

Ḣs×  Main link. Argument: s, n

Ḣ    Head; yield s.
     This pops the list, leaving [n] as the main link's argument.
 s   Split s into chunks of length n.
  ×  Multiply each chunk by [n], repeating its first element n times.

Gelée ,  6  5 octets

-1 octet grâce à Nun qui fuit (utilisez la multiplication de chaînes de Python.)

×Jm¥¦

Un programme complet, acceptant deux arguments de ligne de commande, la chaîne et le nombre, et imprimant le résultat.

Essayez-le en ligne!

Comment?

×Jm¥¦ - Main link: list of characters, s; number, n   e.g. ['g','o','l','f','e','r'], 2
    ¦ - sparse application:
   ¥  - ...to indices: last two links as a dyad:
 J    -      range of length of s                          [1,2,3,4,5,6]
  m   -      modulo slicing by n (every nth entry)         [1,3,5]
×    - ...action: multiply  ["gg",'o',"ll",'f',"ee",'r']
      - implicit print                                 >>> ggollfeer

JavaScript (ES6), 46 octets

Prend une entrée dans la syntaxe de curry (s)(n).

s=>n=>s.replace(/./g,(c,i)=>c.repeat(i%n?1:n))

Cas de test

let f =

s=>n=>s.replace(/./g,(c,i)=>c.repeat(i%n?1:n))

console.log(f("Hello, World!")(3))
console.log(f("Code golf")(1))
console.log(f("abcdefghijklm")(10))
console.log(f("tesTing")(6))
console.log(f("very very very long string for you to really make sure that your program works")(4))

Proton , 44 octets

s=>n=>"".join(s[i]*(i%n?1:n)for i:0..len(s))

Essayez-le en ligne!

C # (.NET Core) , 84 82 octets

n=>m=>{var s="";for(int i=0;i<n.Length;)s+=new string(n[i],i++%m<1?m:1);return s;}

Essayez-le en ligne!

05AB1E , 8 7 octets

-1 octet grâce à @Emigna

ôʒć²×ì?

Essayez-le en ligne!

Explication

ôʒć²×ì?    Arguments s, n  ("Hello, World!", 3)
ô          Split s into pieces of n  (["Hel", "lo,", ...])
 ʒ         Filter (used as foreach)
  ć          Extract head  ("Hel" -> "el", "H" ...)
   ²×ì       Repeat n times and prepend  ("el", "H" -> "HHHel" ...)
      ?      Print without newline

PowerShell , 51 octets

param($a,$n)-join($a|%{($_,("$_"*$n))[!($i++%$n)]})

Essayez-le en ligne!

Prend l'entrée comme un chartableau $aet le nombre $n. Boucles $aet chaque itération sort soit la lettre courante $_soit la lettre courante multipliée par $n, basée sur un index dans un pseudo-ternaire. L'index choisit entre les deux en fonction de l'incrémentation $ipuis du modulo $n. Ces lettres sont ensuite -joinrééditées ensemble et la chaîne est laissée sur le pipeline; la sortie est implicite.

Python 2 , 54 53 octets

Edit: 1 octet enregistré grâce à @Rod

f=lambda x,n,i=0:x[i:]and[1,n][i%n<1]*x[i]+f(x,n,i+1)

Essayez-le en ligne!

Alice , 25 octets

/
KI /!Iw?&.?t&O?&wWOI.h%

Essayez-le en ligne!

Explication

/         Switch to Ordinal.
I         Read first line of input (i.e. n).
/         Switch to Cardinal.
!         Convert input to its integer value and store it on the tape.
I         Read first character from input string.
w         Push current IP address onto the return address stack. This
          effectively marks the beginning of the main loop.

  ?         Retrieve n.
  &.        Duplicate current character n times (once more than we need,
            but who cares about a clean stack...).
  ?t        Retrieve n and decrement.
  &O        Output n-1 copies of the current character.
  ?         Retrieve n.
  &w        Push the current IP address onto the return address stack n
            times. This marks the beginning of a loop that is executed n 
            times.

    W         Discard one copy of the return address from the stack,
              effectively decrementing the loop counter.
    O         Output the last character. On the first iteration, this is
              the final copy of the repeated character, otherwise it's just
              the single character we read on the last iteration.
    I         Read a character for the next iteration.
    .h%       Compute c % (c+1) on that character, which is a no-op for
              for valid characters, but terminates the program at EOF when
              c becomes -1.

K         Jump to the address on top of the return address stack. As long
          as there are still copies of the address from the inner loop, we
          perform another iteration of that, otherwise we jump back to the
          beginning of the outer loop.

R , 82 76 75 octets

function(s,n)cat(rep(S<-el(strsplit(s,'')),c(n,rep(1,n-1))+!seq(S)),sep='')

Essayez-le en ligne!

Une fonction; prend une chaîne set un entier net imprime la version répétée sur stdout.

Explication:

function(s,n){
 S <- el(strsplit(s,""))                  # characters
 r     <- c(n,rep(1,n-1))                 # [n, 1, 1,...,1], length n
 repeats <- r+!seq(S)                     # extends R to length of S
 cat(rep(S, repeats), sep="")             # print out
}

R , 55 octets

function(S,n)cat(rep(S,c(n,rep(1,n-1))+!seq(S)),sep="")

Essayez-le en ligne!

Même algorithme que ci-dessus, mais avec Sune liste de caractères individuels.

Python 2 , 57 octets

lambda s,n:''.join(c*[1,n][i%n<1]for i,c in enumerate(s))

Essayez-le en ligne!

Python 2 , 53 octets

f=lambda x,n,i=0:x[i:]and n**0**(i%n)*x[i]+f(x,n,i+1)

Essayez-le en ligne!

Japt , 8 octets

ËùDV*EvV

Testez-le en ligne!

Explication

 Ë    ùDV*EvV
UmDE{DùDV*EvV}   Ungolfed
                 Implicit: U = s, V = n
UmDE{        }   Replace each char D and (0-)index E in U by this function:
          EvV      Take 1 if the index is divisible by V; 0 otherwise.
        V*         Multiply this by V. This gives V for every Vth index; 0 for others.
     DùD           Pad D with itself to this length. This gives V copies of D for every
                   Vth index; 1 copy of D for others.
                 Implicit: output last expression

Je dois créditer l'idée d'utiliser ùpour @Shaggy réponse de là . Je ne sais pas si j'y aurais jamais pensé moi-même ...

J, 17 octets

(#@]$[,1#~<:@[)#]

• (...) # ]tout en parens crée la chaîne du verbe "copier" intégré à J. Ainsi, par exemple, si l'argument de gauche est 3, il crée la chaîne 3 1 1répétée au besoin pour égaler le nombre de caractères dans l'argument de droite ], qui contient la chaîne. Autrement dit, #résout le problème directement, en supposant que nous pouvons lui donner le bon argument de gauche: 4devrait être4 1 1 1 répété, etc.
• En examinant #@]$[,1#~<:@[, nous voyons qu'il utilise le verbe en forme de J$ en au milieu - c'est le verbe principal de cette phrase ...
• À gauche de $est #@], ce qui signifie la longueur #de l'argument de droite ].
• À droite de $est [,1#~<:@[, un train de 5 verbes. Le premier train exécuté est ...
• 1#~<:@[, ce qui signifie 1 copié #~(forme passive de copie) un de moins que <:l'argument de gauche [. Ce résultat est passé à la dernière fourche:
• [, ...ce qui signifie prendre l'argument de gauche et ajouter le résultat que nous venons de calculer, qui est une chaîne de 1s.

Essayez-le en ligne!

C # (.NET Core) , 61 + 18 = 79 octets

using System.Linq;
n=>m=>string.Concat(n.Select((c,i)=>new string(c,i%m<1?m:1)))

Essayez-le en ligne!

Perl 5, 37 , 29 +1 (-p) octets

-8 octets grâce au commentaire de Tom.

$n=<>;s/./"@-"%$n?$&:$&x$n/ge

Essayez-le en ligne

6502 routine de code machine , 50 octets

A0 01 84 97 88 84 9E 84 9F B1 FB F0 20 A4 9F 91 FD C6 97 D0 10 A6 FF CA F0
05 C8 91 FD D0 F8 84 9F A5 FF 85 97 E6 9E A4 9E E6 9F D0 DC A4 9F 91 FD 60

Il s'agit d'un sous-programme indépendant de la position qui attend un pointeur sur la chaîne d'entrée (terminée par 0, aka chaîne C) dans $fb / $fc, un pointeur sur le tampon de sortie dans $fd/ $feet le nombre (n ) dans $ff. Il utilise une indexation simple, il est donc limité à une longueur de sortie maximale de 255 caractères (+ 0 octet) en raison de l'architecture 8 bits.

Explication (démontage commenté):

 .rep:
A0 01       LDY #$01            ; init counter to next repetition sequence
84 97       STY $97
88          DEY                 ; init read and write index
84 9E       STY $9E             ; (read)
84 9F       STY $9F             ; (write)
 .rep_loop:
B1 FB       LDA ($FB),Y         ; read next character
F0 20       BEQ .rep_done       ; 0 -> finished
A4 9F       LDY $9F             ; load write index
91 FD       STA ($FD),Y         ; write next character
C6 97       DEC $97             ; decrement counter to nex rep. seq.
D0 10       BNE .rep_next       ; not reached yet -> next iteration
A6 FF       LDX $FF             ; load repetition counter
 .rep_seqloop:
CA          DEX                 ; and decrement
F0 05       BEQ .rep_seqdone    ; if 0, no more repetitions
C8          INY                 ; increment write index
91 FD       STA ($FD),Y         ; write character
D0 F8       BNE .rep_seqloop    ; and repeat for this sequence
 .rep_seqdone:
84 9F       STY $9F             ; store back write index
A5 FF       LDA $FF             ; re-init counter to next ...
85 97       STA $97             ; ... repetition sequence
 .rep_next:
E6 9E       INC $9E             ; increment read index
A4 9E       LDY $9E             ; load read index
E6 9F       INC $9F             ; increment write index
D0 DC       BNE .rep_loop       ; jump back (main loop)
 .rep_done:
A4 9F       LDY $9F             ; load write index
91 FD       STA ($FD),Y         ; and write terminating0-byte there
60          RTS                 ; done.

Exemple de programme de code machine C64 l'utilisant :

Il s'agit d'un programme en assembleur de style ca65 pour le C64 utilisant cette routine (importé en tant que rep):

REP_IN          = $fb
REP_IN_L        = $fb
REP_IN_H        = $fc

REP_OUT         = $fd
REP_OUT_L       = $fd
REP_OUT_H       = $fe

REP_N           = $ff

.import         rep


.segment "LDADDR"
                .word   $c000

.code
                jsr     $aefd           ; consume comma
                jsr     $ad9e           ; evaluate expression
                sta     REP_IN_L        ; store string length
                jsr     $b6a3           ; free string
                ldy     #$00            ; loop over string
readloop:       cpy     REP_IN_L        ; end of string?
                beq     termstr         ; then jump to 0-terminate string
                lda     ($22),y         ; read next character
                sta     in,y            ; store in input buffer
                iny                     ; next
                bne     readloop
termstr:        lda     #$00            ; load 0 byte
                sta     in,y            ; store in input buffer

                jsr     $b79b           ; read 8bit unsigned int
                stx     REP_N           ; store in `n`
                lda     #<in            ; (
                sta     REP_IN_L        ;   store pointer to
                lda     #>in            ;   to input string
                sta     REP_IN_H        ; )
                lda     #<out           ; (
                sta     REP_OUT_L       ;   store pointer to
                lda     #>out           ;   output buffer
                sta     REP_OUT_H       ; )
                jsr     rep             ; call function

                ldy     #$00            ; output result
outloop:        lda     out,y
                beq     done
                jsr     $ffd2
                iny
                bne     outloop
done:           rts


.bss
in:             .res    $100
out:            .res    $100

Démo en ligne

Utilisation:, sys49152,"[s]",[n] par exemplesys49152,"Hello, World!",3

Important: Si le programme a été chargé à partir du disque (comme dans la démo en ligne), lancez d'abord une newcommande! Cela est nécessaire car le chargement d'un programme machine met à la corbeille certains pointeurs C64 BASIC.

Java 8, 100 76 octets

s->n->{int i,k=0;for(char c:s)for(i=k++%n<1?n:1;i-->0;)System.out.print(c);}

-24 octets grâce à @ OliverGrégoire .

Explication:

Essayez-le ici.

s->n->{                    // Method with char-array and int parameters and no return-type
  int i,k=0;               //  Index-integers
  for(char c:s)            //  Loop (1) over the characters of the input array
    for(i=k++%n<1?         //   If `k` is divisible by the input `n`:
         n                 //    Change `i` to `n`
        :                  //   Else:
         1;                //    Change `i` to 1
        i-->0;)            //   Inner loop (2) from `i` down to 0
      System.out.print(c); //    And print the current character that many times
                           //   End of inner loop (2) (implicit / single-line body)
                           //  End of loop (1) (implicit / single-line body)
}                          // End of method

MATL , 10 7 octets

-3 octets grâce à Luis Mendo!

tq:ghY"

Essayez-le en ligne!

Prend comme entrée net Scomme une matrice chaîne / char.

    % (implicit input)
    % stack: n
t   % duplicate
    % stack: n n
q   % decrement
    % stack: n n-1
:   % range
    % stack: n [1 2 ... n-1]
g   % convert to logical (nonzero->1, zero->0)
    % stack: n [1 1 ... 1]
h   % horizontal concatenate
    % stack: [n 1 1 ... 1]
Y"  % run-length decoding, taking the string as first input and recycling 
    % the lengths [n 1 1 ... 1] as needed
    % (implicit output as string)

Haskell , 51 46 octets

Merci @Laikoni de m'avoir sauvé 5 octets!

n&s=do(m,c)<-zip[0..]s;c<$[0..(n-1)*0^mod m n]

Essayez-le en ligne!

Explication / Non golfé

L'opérateur c <$ [a..b]remplace chaque élément de la liste [a,a+1...b]par c- c'est donc juste un golf replicate:

do(m,c)<-zip[0..]s;                                  -- with all (m,c) in the enumerated ([(0,a),(1,b)..]) input string, replace with
                   replicate (1 + (n-1)*0^mod m n) c -- either n or 1 times the character c (note that the list begins with 0, that's where the 1+ comes from)

Fusain , 14 octets

Ｎθ⪫ＥＳ⎇﹪κθι×ιθω

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend entrée dans l'ordre n, s.

V , 13 octets

"aDJòylÀpÀll

Essayez-le en ligne!

Il s'agit d'une solution de contournement vraiment stupide. òlhÀälÀlÀ<M-->ldevrait fonctionner, mais je ne peux pas pour la vie de me comprendre pourquoi, en particulier car cela manuellement lhÀälÀlÀ<M-->lrépété un certain nombre de fois fait le travail.

Hexdump:

00000000: 1822 6144 4af2 796c c070 c06c 6c         ."aDJ.yl.p.ll

Explication:

<C-x>               " Decrement the number
       D            " Delete that number...
     "a             "   Into register 'a'
        J           " Remove the blank line
         ò          " Recursively...
          yl        "   Yank the letter under the cursor
            Àp      "   And paste it 'a' times
              Àl    "   Move 'a' times to the right ('l' for right)
                l   "   Move to the right one more time
                    " (implicit) end the loop

Pyth , 12 octets

s*Vzm^Q!d%Uz

Essayez-le ici.

Python 3 , 58 octets

Travailler sur le golf.

Je sais qu'il y a déjà d'autres réponses Python, mais je pensais que je posterais celle-ci aussi car elle est assez bonne par rapport aux autres, bien qu'elle soit une fonction complète et non un lambda.

Prend l'entrée comme paramètres de fonction et imprime vers STDOUT.

def f(s,n,i=0):
 for c in s:print(end=[c,c*n][i%n<1]);i+=1

Essayez-le en ligne!

Pour un octet de moins (57), j'ai codé un lambda, mais des réponses similaires ont déjà été publiées par d'autres utilisateurs:

lambda s,n:''.join([c,c*n][i%n<1]for i,c in enumerate(s))

Brain-Flak (BrainHack) , 122 + 3 ( -A) = 125 octets

Je suis sûr que c'est trop long, mais j'ai passé un bon moment à chercher et je n'ai trouvé aucune amélioration.

([]){{}([(([{}]<>)<{({}<<>(({})<>)>())}{}{}>)<{({}<<>({}<>)>())}{}>]<>)([][()])}({}{}<>){({}{(<()>)}{}[()])}{}{({}<>)<>}<>

Essayez-le en ligne!

05AB1E , 12 11 octets

vX‚RNIÖèy×?

Essayez-le en ligne!

Explication

v             # for each letter in the input string
       è      # index into
 X‚           # the list [input_int,1]
   R          # reversed
    NIÖ       # with letter_index % input_int == 0
        y×    # repeat the current letter this many times
          ?   # print

Mathematica, 71 octets

""<>s[[i]]~t~If[i~Mod~#2==1,#2,1]~(t=Table)~{i,Tr[1^(s=Characters@#)]}&

Essayez-le en ligne!

enregistré -2 octets en écoutant user202729

K (oK) , 23 19 octets

Solution:

{,/(1|y*~y!!#x)#'x}

Essayez-le en ligne!

Exemples:

> {,/(1|y*~y!!#x)#'x}["Hello, World!";3]
"HHHellllo,   Worrrld!!!"
> {,/(1|y*~y!!#x)#'x}["Code golf";1]
"Code golf"
> {,/(1|y*~y!!#x)#'x}["abcdefghijklm";10]
"aaaaaaaaaabcdefghijkkkkkkkkkklm"

Explication:

{,/(1|y*~y!!#x)#'x} / the solution
{                 } / lambda function with x and y as implicit parameters
   (          )     / do everything in brackets together
            #x      / count x, #"Hello, World!" -> 13
           !        / til, !13 -> 0 1 2 3 4 5 6 7 8 9 10 11 12
         y!         / y modulo, 3!0 1 2 3 4 5 6 7 8 9 10 11 12 -> 0 1 2 0 1 2 0 1 2 0 1 2 0
        ~           / not, ~0 1 2 0 1 2 0 1 2 0 1 2 0 -> 1 0 0 1 0 0 1 0 0 1 0 0 1
      y*            / multiply by y, 3*1 0 0 1 0 0 1 0 0 1 0 0 1 -> 3 0 0 3 0 0 3 0 0 3 0 0 3
    1|              / min of 1 and, 1|3 0 0 3 0 0 3 0 0 3 0 0 3 -> 3 1 1 3 1 1 3 1 1 3 1 1 3
                #'x / take each parallel, 1 2 3#'"abc" -> "a", "bb", "ccc"
 ,/                 / flatten the list, "a", "bb", "ccc" -> "abbccc"

Remarques:

• -4 octets avec une approche différente

Excel VBA, 71 octets

Fonction de fenêtre immédiate VBE anonyme qui prend les entrées de la plage [A1:B1]et les sorties vers la fenêtre immédiate VBE.

For i=1To[Len(A1)]:[C1]=i:?[Rept(Mid(A1,C1,1),B1^(Mod(C1,B1)=1))];:Next