_{我们已经有一段时间没有字符串问题了（准确地说是5天），所以让我们继续。}

给定一个字符串s和一个正整数n，取的每一个n元素s，重复n一次，然后放回s。

例如，如果n = 3和s = "Hello, World!"，则第三个字符为Hl r!。然后，您重复每个字符n时间以产生HHHlll rrr!!!。然后，您将原始字母替换为重复的字母，以生成最终的HHHellllo, Worrrld!!!

您将使用您的语言以最短的代码完成此任务！

规则

• 这是一个代码高尔夫球，因此以字节为单位的最短代码胜出
• n保证小于的长度s并大于0
• 的第一个字符s是其中n第字符是从采取，并且总是反复n次
• s就只包括可打印的ASCII的（代码点0x20 (space)到0x7E (~)）

测试用例

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"

果冻，3个字节

Ḣs×

输入取为s，n。

在线尝试！

怎么运行的

Ḣ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.

果冻， 6  5 字节

-1字节归功于泄漏的尼姑（使用Python的字符串乘法。）

×Jm¥¦

一个完整的程序，接受两个命令行参数（字符串和数字）并打印结果。

在线尝试！

怎么样？

×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个字节

以currying语法接受输入(s)(n)。

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

测试用例

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

质子，44字节

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

在线尝试！

C＃（.NET Core），84 82字节

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

在线尝试！

05AB1E，8 7字节

-1字节感谢@Emigna

ôʒć²×ì?

在线尝试！

说明

ôʒć²×ì?    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字节

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

在线尝试！

将输入作为a char数组$a和number $n。循环遍历，$a并且每次迭代都基于伪三元组的索引输出当前字母$_或当前字母乘以$n。索引基于增量$i和取模，在两者之间进行选择$n。然后将这些字母-join放在一起，并将字符串留在管道中；输出是隐式的。

Python 2中，54 53个字节

编辑：由于@Rod，保存了1个字节

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

在线尝试！

爱丽丝，25个字节

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

在线尝试！

说明

/         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字节

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

在线尝试！

功能；接受一个字符串s和一个整数n，并将重复的版本输出到stdout。

说明：

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个字节

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

在线尝试！

与上述相同的算法，但S将其作为单个字符的列表。

Python 2，57字节

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

在线尝试！

Python 2，53个字节

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

在线尝试！

Japt，8字节

ËùDV*EvV

在线测试！

说明

 Ë    ù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

我必须信贷的想法，使用ù到@Shaggy的答案在这里。我不知道自己会不会想到...

J，17个字节

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

• (...) # ]parens中的所有内容都会为J的内置“复制”动词创建字符串。因此，例如，如果left参数为3，则它将3 1 1根据需要创建重复的字符串，以使其等于]包含字符串的右侧arg 中的字符数。也就是说，#假设我们可以给它正确的left参数，则可以直接解决该问题：4应该4 1 1 1重复，依此类推。
• 检查#@]$[,1#~<:@[一下，我们看到它$在中间使用了J的形动词-这是该短语的主要动词...
• 在的左侧$是#@]，表示#右侧arg 的长度]。
• 在的右侧$是[,1#~<:@[5动词组。执行的第一列火车是...
• 1#~<:@[，表示1个副本#~（副本的被动形式）比<:左侧arg小1个[。这个结果被传递到最后的fork：
• [, ...意思是取左arg，并附加刚刚计算的结果，它是1s 的字符串。

在线尝试！

C＃（.NET Core），61 + 18 = 79字节

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

在线尝试！

Perl 5中，37，29 1（-p）个字节

-8字节，感谢汤姆的评论。

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

在线试用

6502机器代码例程，50个字节

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

这是一种与位置无关的子程序期望的指针输入串（0终结又名C-串）中$fb/ $fc，一个指针到输出缓冲器中$fd/ $fe和计数（n）中$ff。它使用简单的索引编制，因此由于8位体系结构，它的最大输出长度限制为255个字符（+ 0字节）。

说明（注释拆卸）：

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

使用它的示例C64机器代码程序：

这是使用以下例程（导入为）的C65的ca65样式汇编程序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

在线演示

用法： sys49152,"[s]",[n]例如sys49152,"Hello, World!",3

重要：如果程序是从磁盘加载的（如在线演示中一样），请new首先发出命令！这是必需的，因为加载机器程序会浪费一些C64 BASIC指针。

Java 8，100 76字节

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

-24个字节，感谢@OliverGrégoire。

说明：

在这里尝试。

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字节

-3个字节感谢Luis Mendo！

tq:ghY"

在线尝试！

将输入作为n，然后S作为字符串/字符数组。

    % (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字节

感谢@Laikoni为我节省了5个字节！

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

在线尝试！

解释/取消

操作员c <$ [a..b]用-替换列表中[a,a+1...b]的每个元素，c所以它只是打高尔夫球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)

木炭，14字节

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

在线尝试！链接是详细版本的代码。需要输入的顺序n，s。

V，13个字节

"aDJòylÀpÀll

在线尝试！

这是一个非常愚蠢的解决方法。òlhÀälÀlÀ<M-->l应该可以工作，但是我无法终生理解为什么会这样做，尤其是因为手动进行lhÀälÀlÀ<M-->l多次重复确实可以工作。

十六进制转储：

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

说明：

<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个字节

s*Vzm^Q!d%Uz

在这里尝试。

Python 3 3，58个字节

正在打高尔夫球。

我知道已经有其他Python答案，但我想我也应该发布此答案，因为尽管它是一个完整的功能而不是lambda，但与其他答案相比，它的得分还不错。

将输入作为功能参数，并打印到STDOUT。

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

在线尝试！

少了一个字节（57），我编写了一个lambda，但是其他用户已经发布了类似的答案：

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

Brain-Flak（BrainHack），122 + 3（-A）= 125字节

我确定这太长了，但是我花了相当长的时间寻找并且找不到任何改进。

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

在线尝试！

05AB1E，12 11字节

vX‚RNIÖèy×?

在线尝试！

说明

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个字节

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

在线尝试！

通过侦听user202729保存了-2字节

K（oK），23 19字节

解：

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

在线尝试！

例子：

> {,/(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"

说明：

{,/(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"

笔记：

• -4个字节，采用不同的方法

Excel VBA，71字节

匿名VBE立即窗口功能，可从范围获取输入[A1:B1]并输出到VBE立即窗口。

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