_{Wir hatten eine Weile keine String- Frage (um genau zu sein 5 Tage), also lass uns eine machen.}

Nehmen Sie für eine Zeichenfolge sund eine positive Ganzzahl njedes nElement von s, wiederholen Sie es nund setzen Sie es wieder ein s.

Zum Beispiel, wenn n = 3und s = "Hello, World!", ist jedes dritte Zeichen Hl r!. Dann wiederholst du jedes Zeichen n, um es zu produzieren HHHlll rrr!!!. Anschließend ersetzen Sie die Originalbuchstaben durch die wiederholten Versionen, um das Endprodukt von zu erhaltenHHHellllo, Worrrld!!!

Sie müssen diese Aufgabe in kürzester Zeit in Ihrer Sprache erledigen!

Regeln

• Dies ist ein Code-Golf, so dass der kürzeste Code in Bytes gewinnt
• nist garantiert kleiner als die Länge von sund größer als 0
• Das erste Zeichen von sist, wo die nth Zeichen genommen werden, und wird immer nMale wiederholt
• sbesteht nur aus druckbarem ASCII (Code zeigt 0x20 (space)auf 0x7E (~))

Testfälle

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"

Gelee , 3 Bytes

Ḣs×

Die Eingabe wird als s, n genommen .

Probieren Sie es online!

Wie es funktioniert

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

Gelee ,  6  5 Bytes

-1 Byte dank undichter Nun (verwenden Sie die Python-String-Multiplikation.)

×Jm¥¦

Ein vollständiges Programm, das zwei Befehlszeilenargumente akzeptiert, die Zeichenfolge und die Zahl, und das Ergebnis druckt.

Probieren Sie es online!

Wie?

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

Übernimmt Eingaben in der Currying-Syntax (s)(n).

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

Testfälle

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 Bytes

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

Probieren Sie es 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;}

Probieren Sie es online!

05AB1E , 8 7 Bytes

-1 Byte dank @Emigna

ôʒć²×ì?

Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es online!

charÜbernimmt $adie Eingabe als -array und die Nummer $n. Durchlaufen $aund jede Iteration gibt entweder den aktuellen Buchstaben $_oder den aktuellen Buchstaben multipliziert mit aus $n, basierend auf einem Index in einem Pseudoternär. Der Index wählt zwischen Inkrementierung $iund Modulo $n. Diese Buchstaben werden dann -joinwieder zusammengefügt und die Zeichenfolge verbleibt in der Pipeline. Ausgabe ist implizit.

Python 2 , 54 53 Bytes

Bearbeiten: 1 Byte dank @Rod gespeichert

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

Probieren Sie es online!

Alice , 25 Bytes

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Eine Funktion; Nimmt einen String sund eine Ganzzahl nund gibt die wiederholte Version in stdout aus.

Erläuterung:

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

Probieren Sie es online!

Gleicher Algorithmus wie oben, jedoch Sals Liste der einzelnen Zeichen.

Python 2 , 57 Bytes

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

Probieren Sie es 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)

Probieren Sie es online!

Japt , 8 Bytes

ËùDV*EvV

Online testen!

Erläuterung

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

Ich muss die Idee ùauf @Shaggys Antwort hier zurückführen . Ich weiß nicht, dass ich jemals selbst daran gedacht hätte ...

J, 17 Bytes

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

• (...) # ]Alles in Parens erzeugt den String für das in J eingebaute "copy" -Verb. Wenn das linke Argument beispielsweise 3 ist, wird die Zeichenfolge 3 1 1so oft wiederholt, bis die Anzahl der Zeichen im rechten Argument, das die Zeichenfolge ]enthält, erreicht ist. Das heißt, es #löst das Problem direkt, vorausgesetzt, wir können ihm das richtige linke Argument geben: 4sollte 4 1 1 1wiederholt werden und so weiter.
• Betrachtet #@]$[,1#~<:@[man, sieht man, dass es Js Formverb verwendet$ in der Mitte verwendet - das ist das Hauptverb dieser Phrase ...
• Links von $ist #@]die Länge #des rechten Arg] .
• Rechts von $ist [,1#~<:@[ein 5-Verb-Zug. Der erste ausgeführte Zug ist ...
• 1#~<:@[Dies bedeutet, dass 1 kopiert #~(passive Form der Kopie) 1 weniger als <:das linke Argument ist [. Dieses Ergebnis wird an die letzte Gabel übergeben:
• [, ...Das heißt, nimm das linke Argument und hänge das Ergebnis an, das wir gerade berechnet haben. Dies ist eine Folge von 1s.

Probieren Sie es online!

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

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

Probieren Sie es online!

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

-8 Bytes dank Toms Kommentar.

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

Probieren Sie es online

6502 Maschinencode- Routine, 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

Dies ist eine positionsunabhängige Subroutine, die einen Zeiger auf die Eingabezeichenfolge (0-terminated aka C-string) in $fb/ $fc, einen Zeiger auf den Ausgabepuffer in $fd/ $feund den count ( n) in erwartet $ff. Die einfache Indizierung ist aufgrund der 8-Bit-Architektur auf eine maximale Ausgabelänge von 255 Zeichen (+ 0 Byte) beschränkt.

Erklärung (kommentierte Demontage):

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

Beispiel für ein C64-Maschinencode-Programm, das es verwendet :

Dies ist ein Programm im ca65- Style Assembler für den C64, das diese Routine verwendet (importiert als 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

Online-Demo

Verwendung: sys49152,"[s]",[n] zBsys49152,"Hello, World!",3

Wichtig: Wenn das Programm von der Festplatte geladen wurde (wie in der Online-Demo), geben Sie zuerst einen newBefehl aus! Dies ist notwendig, weil das Laden eines Maschinenprogramms einige C64 BASIC-Zeiger in den Papierkorb wirft.

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

Erläuterung:

Probieren Sie es hier aus.

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 dank Luis Mendo!

tq:ghY"

Probieren Sie es online!

Übernimmt die Eingabe als nund dann Sals String / Char-Array.

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

Danke @Laikoni, dass du mir 5 Bytes gespart hast!

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

Probieren Sie es online!

Erklärung / Ungolfed

Der Operator c <$ [a..b]ersetzt jedes Element der Liste [a,a+1...b]durch c- es ist also nur ein 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)

Holzkohle , 14 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Nimmt die Eingabe in der Reihenfolge n, s.

V , 13 Bytes

"aDJòylÀpÀll

Probieren Sie es online!

Dies ist eine wirklich blöde Problemumgehung. òlhÀälÀlÀ<M-->lsollte funktionieren, aber ich kann für mein ganzes Leben nicht verstehen warum, zumal manuelles lhÀälÀlÀ<M-->lWiederholen ein paar Mal funktioniert .

Hexdump:

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

Erläuterung:

<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

Probieren Sie es hier aus.

Python 3 , 58 Bytes

Ich arbeite daran, Golf zu spielen.

Ich weiß, dass es bereits andere Python-Antworten gibt, aber ich dachte, ich würde diese auch posten, da sie im Vergleich zu den anderen ziemlich gut abschneidet, obwohl sie eine vollständige Funktion und kein Lambda ist.

Nimmt Eingaben als Funktionsparameter und druckt auf STDOUT.

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

Probieren Sie es online!

Für ein Byte weniger (57) habe ich ein Lambda codiert, ähnliche Antworten wurden jedoch bereits von anderen Benutzern gepostet:

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

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

Ich bin sicher, das ist zu lang, aber ich habe lange gesucht und keine Verbesserungen gefunden.

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

Probieren Sie es online!

05AB1E , 12 11 Bytes

vX‚RNIÖèy×?

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

sparte -2 Bytes durch Abhören von user202729

K (oK) , 23 & ndash ; 19 Bytes

Lösung:

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

Probieren Sie es online!

Beispiele:

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

Erläuterung:

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

Anmerkungen:

• -4 Bytes mit unterschiedlichem Ansatz

Excel VBA, 71 Bytes

Anonyme VBE-Direktfensterfunktion, die Eingaben aus dem Bereich [A1:B1]und Ausgaben in das VBE-Direktfenster übernimmt .

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