_{No hemos tenido una pregunta de cadena por un tiempo (5 días para ser precisos), así que vamos por una.}

Dada una cadena sy un entero positivo n, tome cada nelemento de th s, repítalo nveces y vuelva a colocarlo s.

Por ejemplo, si n = 3y s = "Hello, World!", cada tercer personaje es Hl r!. Luego repites cada personaje npara producir HHHlll rrr!!!. Luego reemplaza las letras originales con las versiones repetidas para producir el producto final deHHHellllo, Worrrld!!!

¡Debe realizar esta tarea en el código más corto posible en su idioma!

Reglas

• Este es un código de golf, por lo que gana el código más corto en bytes
• nse garantiza que es menor que la longitud sy mayor que 0
• El primer carácter de ses de dónde nse toman los caracteres th, y siempre se repite nveces
• ssolo consistirá en ASCII imprimible (el código apunta 0x20 (space)a 0x7E (~))

Casos de prueba

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"

Jalea , 3 bytes

Ḣs×

La entrada se toma como s, n .

Pruébalo en línea!

Cómo 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.

Jalea ,  6  5 bytes

-1 byte gracias a Nun con fugas (use la multiplicación de cuerdas de Python).

×Jm¥¦

Un programa completo, que acepta dos argumentos de línea de comando, la cadena y el número, e imprime el resultado.

Pruébalo en línea!

¿Cómo?

×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

Toma entrada en la sintaxis de curry (s)(n).

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

Casos de prueba

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

Protón , 44 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

05AB1E , 8 7 bytes

-1 byte gracias a @Emigna

ôʒć²×ì?

Pruébalo en línea!

Explicación

ôʒć²×ì?    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)]})

Pruébalo en línea!

Toma la entrada como una charmatriz $ay el número $n. Recorre $ay cada iteración genera la letra actual $_o la letra actual multiplicada por $n, en base a un índice en un pseudoternario. El índice elige entre los dos en función del incremento $iy luego el módulo $n. Esas letras se -joinvuelven a unir y la cadena se deja en la tubería; La salida es implícita.

Python 2 , 54 53 bytes

Editar: guardado 1 byte gracias a @Rod

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

Pruébalo en línea!

Alice , 25 bytes

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

Pruébalo en línea!

Explicación

/         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='')

Pruébalo en línea!

Una función; toma una cadena sy un número entero ne imprime la versión repetida en stdout.

Explicación:

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

Pruébalo en línea!

Mismo algoritmo que el anterior, pero Stomado como una lista de caracteres individuales.

Python 2 , 57 bytes

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

Pruébalo en línea!

Python 2 , 53 bytes

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

Pruébalo en línea!

Japt , 8 bytes

ËùDV*EvV

¡Pruébalo en línea!

Explicación

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

Tengo que acreditar la idea de utilizar ùa @Shaggy respuesta 's aquí . No sé si alguna vez lo hubiera pensado yo mismo ...

J, 17 bytes

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

• (...) # ]todo en parens crea la cadena para el verbo de "copia" integrado de J. Entonces, por ejemplo, si el argumento izquierdo es 3, crea la cadena 3 1 1repetida según sea necesario para igualar el número de caracteres en el argumento derecho ], que contiene la cadena. Es decir, #resuelve el problema directamente, suponiendo que podamos darle el argumento izquierdo correcto: 4debe 4 1 1 1repetirse, y así sucesivamente.
• Examinando #@]$[,1#~<:@[, vemos que usa el verbo de la forma de J $en el medio, ese es el verbo principal de esta frase ...
• A la izquierda de $is #@], que significa la longitud #de la arg derecha ].
• A la derecha de $es [,1#~<:@[, un tren de 5 verbos. El primer tren ejecutado es ...
• 1#~<:@[, lo que significa 1 copiado #~(forma pasiva de copia) uno menos que <:el argumento izquierdo [. Este resultado se pasa a la bifurcación final:
• [, ...es decir, toma el argumento izquierdo y agrega el resultado que acabamos de calcular, que es una cadena de 1s.

Pruébalo en línea!

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

Pruébalo en línea!

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

-8 bytes gracias al comentario de Tom.

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

Pruébalo en línea

6502 rutina de código de máquina , 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 es una subrutina independiente de la posición que espera un puntero a la cadena de entrada (también conocida como C-string) en $fb/ $fc, un puntero al búfer de salida en $fd/ $fey la cuenta ( n) en $ff. Utiliza una indexación simple, por lo que está limitado a una longitud de salida máxima de 255 caracteres (+ 0 byte) debido a la arquitectura de 8 bits.

Explicación (desmontaje comentado):

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

Ejemplo de programa de código de máquina C64 usándolo :

Este es un programa en ensamblador de estilo ca65 para el C64 usando esta rutina (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

Demostración en línea

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

Importante: si el programa se cargó desde el disco (como en la demostración en línea), ¡emita newprimero un comando! Esto es necesario porque cargar un programa de máquina destruye algunos punteros BÁSICOS C64.

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 gracias a @ OliverGrégoire .

Explicación:

Pruébalo aquí

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 gracias a Luis Mendo!

tq:ghY"

Pruébalo en línea!

Toma entrada como ny luego Scomo una cadena / matriz de 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

¡Gracias @Laikoni por salvarme 5 bytes!

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

Pruébalo en línea!

Explicación / Ungolfed

El operador c <$ [a..b]reemplaza cada elemento de la lista [a,a+1...b]por c, por lo que es solo un campo de 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)

Carbón , 14 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Toma de entrada en el orden n, s.

V , 13 bytes

"aDJòylÀpÀll

Pruébalo en línea!

Esta es una solución muy tonta. òlhÀälÀlÀ<M-->ldebería funcionar, pero no puedo por la vida de entender por qué, sobre todo porque manualmente el hacer lhÀälÀlÀ<M-->lrepite un montón de veces que hace el trabajo.

Hexdump:

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

Explicación:

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

s*Vzm^Q!d%Uz

Pruébalo aquí

Python 3 , 58 bytes

Trabajando en jugar golf.

Sé que ya hay otras respuestas de Python, pero pensé en publicar esta también porque tiene una puntuación bastante buena en comparación con las otras, a pesar de ser una función completa y no una lambda.

Toma datos como parámetros de función e imprime en STDOUT.

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

Pruébalo en línea!

Por un byte menos (57), codifiqué un lambda, sin embargo, otros usuarios ya han publicado respuestas similares:

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

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

Estoy seguro de que esto es demasiado largo, pero pasé bastante tiempo buscando y no pude encontrar ninguna mejora.

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

Pruébalo en línea!

05AB1E , 12 11 bytes

vX‚RNIÖèy×?

Pruébalo en línea!

Explicación

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@#)]}&

Pruébalo en línea!

guardado -2 bytes al escuchar al usuario202729

K (oK) , 23 19 bytes

Solución:

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

Pruébalo en línea!

Ejemplos:

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

Explicación:

{,/(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 con enfoque diferente

Excel VBA, 71 bytes

Función de ventana inmediata anónima de VBE que toma la entrada del rango [A1:B1]y las salidas a la ventana inmediata de VBE.

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