_{Não temos uma pergunta em cadeia há um tempo (cinco dias para ser mais preciso), então vamos a uma.}

Dada uma string se um número inteiro positivo n, pegue cada nelemento th s, repita-o nvezes e coloque-o novamente s.

Por exemplo, se n = 3e s = "Hello, World!", todo terceiro caractere é Hl r!. Você então repete cada personagem npara produzir HHHlll rrr!!!. Em seguida, substitua as letras originais pelas versões repetidas para produzir o produto final deHHHellllo, Worrrld!!!

Você deve realizar esta tarefa no código mais curto possível no seu idioma!

Regras

• Este é um código de golfe, portanto o código mais curto em bytes vence
• né garantido que seja menor que o comprimento se maior que 0
• O primeiro caractere de sé de onde os ncaracteres são retirados e sempre é repetido nvezes
• sconsistirá apenas em ASCII imprimível (o código aponta 0x20 (space)para 0x7E (~))

Casos de teste

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éia , 3 bytes

Ḣs×

A entrada é tomada como s, n .

Experimente online!

Como funciona

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

Gelatina ,  6  5 bytes

-1 byte graças a Nun com vazamento (use a multiplicação de strings do Python.)

×Jm¥¦

Um programa completo, aceitando dois argumentos de linha de comando, a sequência e o número, e imprimindo o resultado.

Experimente online!

Quão?

×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 bytes

Recebe entrada na sintaxe de currying (s)(n).

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

Casos de teste

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

Próton , 44 bytes

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

Experimente online!

C # (.NET Core) , 84 82 bytes

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

Experimente online!

05AB1E , 8 7 bytes

-1 byte graças a @Emigna

ôʒć²×ì?

Experimente online!

Explicação

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

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

Experimente online!

Toma a entrada como uma charmatriz $ae o número $n. Loops $ae cada iteração gera a letra atual $_ou a letra atual multiplicada por $n, com base em um índice em um pseudo-ternário. O índice escolhe entre os dois com base no incremento $ie depois no módulo $n. Essas letras são -joineditadas novamente e a corda é deixada no pipeline; saída está implícita.

Python 2 , 54 53 bytes

Edit: Salvo 1 byte graças a @Rod

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

Experimente online!

Alice , 25 bytes

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

Experimente online!

Explicação

/         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 bytes

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

Experimente online!

Uma função; pega uma string se um número inteiro ne imprime a versão repetida em stdout.

Explicação:

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 bytes

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

Experimente online!

O mesmo algoritmo que o anterior, mas Sconsiderado como uma lista de caracteres individuais.

Python 2 , 57 bytes

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

Experimente online!

Python 2 , 53 bytes

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

Experimente online!

Japonês , 8 bytes

ËùDV*EvV

Teste online!

Explicação

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

Eu tenho que creditar a idéia de usar ùa resposta de @Shaggy aqui . Não sei se teria pensado nisso ...

J, 17 bytes

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

• (...) # ]tudo em parens cria a string para o J, construído no verbo "copiar". Portanto, por exemplo, se o argumento da esquerda for 3, ele criará a sequência 3 1 1repetida conforme necessário para igualar o número de caracteres no argumento à direita ], que contém a sequência. Ou seja, #resolve o problema diretamente, assumindo que podemos fornecer o argumento correto à esquerda:4 deve ser 4 1 1 1repetido e assim por diante.
• Examinando #@]$[,1#~<:@[ , vemos que ele usa o verbo $em forma de J no meio - esse é o verbo principal desta frase ...
• À esquerda de $é #@], significando o comprimento# do argumento direito ].
• À direita de $é[,1#~<:@[ , um trem de 5 verbos. O primeiro trem executado é ...
• 1#~<:@[, o que significa 1 copiado #~(forma passiva da cópia) um a menos que <:o argumento esquerdo[ . Este resultado é passado para a bifurcação final:
• [, ...significa pegar o argumento esquerdo e acrescentar o resultado que acabamos de calcular, que é uma sequência de 1s.

Experimente online!

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

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

Experimente online!

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

-8 bytes graças ao comentário de Tom.

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

Experimente Online

Rotina de código de máquina 6502 , 50 bytes

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

Esta é uma sub-rotina independente da posição que espera um ponteiro para a sequência de entrada (terminação 0, também conhecida como C-string) em $fb/ $fc, um ponteiro para o buffer de saída em $fd/ $fee a contagem (n ) em $ff. Utiliza indexação simples, limitando-se a um comprimento máximo de saída de 255 caracteres (+ 0 byte) devido à arquitetura de 8 bits.

Explicação (desmontagem comentada):

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

Exemplo de programa de código de máquina C64 usando-o :

Este é um programa no assembler no estilo ca65 para o C64 usando esta rotina (importada como 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

Demonstração online

Uso: sys49152,"[s]",[n] por exemplosys49152,"Hello, World!",3

Importante: Se o programa foi carregado a partir do disco (como na demonstração online), emita um newcomando primeiro! Isso é necessário porque o carregamento de um programa de máquina elimina alguns ponteiros C64 BASIC.

Java 8, 100 76 bytes

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

-24 bytes graças a @ OliverGrégoire .

Explicação:

Experimente aqui.

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 bytes

-3 bytes graças a Luis Mendo!

tq:ghY"

Experimente online!

Recebe entrada como ne, em seguida, Scomo uma matriz de caracteres / caracteres.

    % (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 bytes

Obrigado @Laikoni por me salvar 5 bytes!

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

Experimente online!

Explicação / Ungolfed

O operador c <$ [a..b]substitui cada elemento da lista [a,a+1...b]por c- portanto, é apenas um jogo de golfe 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)

Carvão , 14 bytes

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

Experimente online! Link é a versão detalhada do código. Toma entrada na ordem n, s.

V , 13 bytes

"aDJòylÀpÀll

Experimente online!

Esta é uma solução realmente burra. òlhÀälÀlÀ<M-->ldeve funcionar, mas eu não posso para a vida de me entender por que, especialmente desde manualmente fazendo lhÀälÀlÀ<M-->lrepetido um monte de vezes faz o trabalho.

Hexdump:

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

Explicação:

<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

Pitão , 12 bytes

s*Vzm^Q!d%Uz

Experimente aqui.

Python 3 , 58 bytes

Trabalhando no golfe.

Eu sei que já existem outras respostas em Python, mas pensei em postar essa também, uma vez que tem uma pontuação muito boa em comparação com as outras, apesar de ser uma função completa e não uma lambda.

Pega a entrada como parâmetros de função e imprime em STDOUT.

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

Experimente online!

Por um byte a menos (57), codifiquei um lambda, no entanto, respostas semelhantes já foram publicadas por outros usuários:

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

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

Tenho certeza de que isso é muito longo, mas passei um bom tempo procurando e não consegui encontrar nenhuma melhoria.

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

Experimente online!

05AB1E , 12 11 bytes

vX‚RNIÖèy×?

Experimente online!

Explicação

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 bytes

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

Experimente online!

salvou -2 bytes ouvindo user202729

K (oK) , 23 19 bytes

Solução:

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

Experimente online!

Exemplos:

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

Explicação:

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

Notas:

• -4 bytes com abordagem diferente

Excel VBA, 71 bytes

Função de janela imediata VBE anônima que leva a entrada do intervalo [A1:B1]e as saídas para a janela imediata VBE.

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