Repeat a string

Take a string and repeat it some number of times.

Example: repeat("ha", 5) => "hahahahaha"

If there is a simpler/more efficient way to repeat a single “character” (i.e. creating a string filled with a certain character), you might want to show that as well (i.e. repeat-char("*", 5) => "*****").

Other tasks related to string operations:

Metrics

Counting

Remove/replace

Anagrams/Derangements/shuffling

Find/Search/Determine

Formatting

Song lyrics/poems/Mad Libs/phrases

Tokenize

Sequences

11l

print(‘ha’ * 5)

Output:

hahahahaha

360 Assembly

*        Repeat a string           - 19/04/2020
REPEATS  CSECT
         USING  REPEATS,R13        base register
         B      72(R15)            skip savearea
         DC     17F'0'             savearea
         SAVE   (14,12)            save previous context
         ST     R13,4(R15)         link backward
         ST     R15,8(R13)         link forward
         LR     R13,R15            set addressability
         XPRNT  C24,24             print c24
         LA     R1,PARMLST         pg=repeat(cx,ii) - repeat('abc ',6)
         BAL    R14,REPEAT         call repeat
         XPRNT  PG,L'PG            print pg
         L      R13,4(0,R13)       restore previous savearea pointer
         RETURN (14,12),RC=0       restore registers from calling save
REPEAT   CNOP   0,4                procedure repeat(b,a,i)
         STM    R2,R8,REPEATSA     save registers
         L      R2,0(R1)           @b=%r1
         L      R3,4(R1)           @a=%(r1+4)
         L      R4,8(R1)           @i=%(r1+8)
         LR     R5,R3              length(a) before a 
         SH     R5,=H'2'           @lengh(a)
         LH     R6,0(R5)           l=length(a)
         LR     R7,R6              l
         BCTR   R7,0               l-1
         L      R8,0(R4)           i=%r4
         LTR    R8,R8              if i<=0
         BNP    RET                then return
LOOP     EX     R7,MVCX            move a to b len R6
         AR     R2,R6              @b+=l
         BCT    R8,LOOP            loop i times
RET      LM     R2,R8,REPEATSA     restore registers
         BR     R14                return
PARMLST  DC     A(PG,CX,II)        parmlist
REPEATSA DS     7F                 local savearea
MVCX     MVC    0(0,R2),0(R3)      move @ R3 to @ R2
C24      DC     6C'xyz '           constant repeat - repeat('xyz ',6)
LCX      DC     AL2(L'CX)          lengh(cc)
CX       DC     CL4'abc '          cx
II       DC     F'6'               ii
PG       DC     CL80' '            pg
         REGEQU
         END    REPEATS

Output:

xyz xyz xyz xyz xyz xyz
abc abc abc abc abc abc

4DOS Batch

gosub repeat ha 5
echo %@repeat[*,5]
quit

:Repeat [String Times]
    do %Times%
        echos %String%
    enddo
    echo.
return

Output shows:

hahahahaha
*****

6502 Assembly

CHROUT equ $FFD2    ;KERNAL call, prints the accumulator to the screen as an ascii value.

	org $0801		


	db $0E,$08,$0A,$00,$9E,$20,$28,$32,$30,$36,$34,$29,$00,$00,$00  



	
	lda #>TestStr
	sta $11
	
	lda #<TestStr	
	sta $10

	
	ldx #5				;number of times to repeat

loop:	
	jsr PrintString
	dex
	bne loop
	

	RTS					;RETURN TO BASIC
	
	
PrintString:
	ldy #0				
loop_PrintString:
	lda ($10),y			;this doesn't actually increment the pointer itself, so we don't need to back it up.
	beq donePrinting	
	jsr CHROUT	
	iny
	jmp loop_PrintString	
donePrinting:
	rts					
	
		
	
TestStr:				
	db "HA",0

Output:

READY.
LOAD"*",8,1:

SEARCHING FOR *
LOADING
READY.
RUN
HAHAHAHAHA
READY.

68000 Assembly

Easiest way to do this is with a loop.

MOVE.W #5-1,D1
RepString:
LEA A3, MyString
MOVE.L A3,-(SP) ;PUSH A3
JSR PrintString ;unimplemented hardware-dependent printing routine, assumed to not clobber D1
MOVE.L (SP)+,A3 ;POP A3
DBRA D1,RepString
RTS             ;return to basic or whatever

MyString:
DC.B "ha",0
even

8080 Assembly

        org     100h
        jmp     demo

        ; Repeat the string at DE into HL, B times
repeat: mvi     c,'$'   ; string terminator
        xra     a       ; repeat 0x?
        ora     b
        mov     m,c     ; then empty string
        rz
rpt1:   push    d       ; save begin of string to repeat
chcpy:  ldax    d       ; copy character from input to output
        mov     m,a
        inx     d       ; advance pointers
        inx     h
        cmp     c       ; end of string?
        jnz     chcpy
        pop     d       ; restore begin of string to repeat
        dcx     h       ; move back past terminator in copy
        dcr     b       ; done yet?
        jnz     rpt1    ; if not add another copy
        ret

demo:   lxi     d,ha    ; get string to repeat
        lxi     h,buf   ; place to store result
        mvi     b,5     ; repeat 5 times
        call    repeat
        lxi     d,buf   ; print result using CP/M call
        mvi     c,9
        jmp     5

ha:     db      'ha$'   ; string to repeat
buf:    ds      32      ; place to store repeated string

Output:

hahahahaha

8th

"ha" 5 s:*
. cr

Output shows:

hahahahaha

AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits
or android 64 bits with application Termux

/* ARM assembly AARCH64 Raspberry PI 3B */
/*  program repeatstring.s   */
   

/*******************************************/
/* Constantes                              */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc" 

.equ BUFFERSIZE, 2000
/*******************************************/
/*   Macros                              */
/*******************************************/
//.include "../../ficmacros64.inc"            // for developer debugging

/*********************************/
/* Initialized data              */
/*********************************/
.data
szMessDebutPgm:   .asciz "Program 64 bits start. \n"
szCarriageReturn: .asciz "\n"
szMessFinOK:      .asciz "Program normal end. \n"
szMessErreur:     .asciz "Error  Buffer too small!!!\n"

szString1:          .asciz "ho"
                    
   
         
/*********************************/
/* UnInitialized data            */
/*********************************/
.bss

.align 4
sZoneConv:             .skip 24
sBuffer:               .skip BUFFERSIZE
/*********************************/
/*  code section                 */
/*********************************/
.text
.global main 
main:
    ldr x0,qAdrszMessDebutPgm
    bl affichageMess              // start message 
    ldr x0,qAdrszString1          // load phrase adress 
    ldr x1,qAdrsBuffer
    mov x2,#5
    bl repeatString
    cmp x0,#0
    ble 99f

    ldr x0,qAdrsBuffer            // buffer display
    bl affichageMess

    ldr x0,qAdrszCarriageReturn
    bl affichageMess
    
    ldr x0,qAdrszMessFinOK
    bl affichageMess       
    b 100f
99:
    ldr x0,qAdrszMessErreur        // error
    bl affichageMess
    mov x0, #1                     // return code error
    b 100f
100: 
    mov x8,EXIT 
    svc #0                         // system call
qAdrszMessDebutPgm:          .quad szMessDebutPgm
qAdrszMessFinOK:             .quad szMessFinOK
qAdrszMessErreur:            .quad szMessErreur 
qAdrszString1:               .quad szString1
qAdrsBuffer:                 .quad sBuffer
qAdrsZoneConv:               .quad sZoneConv
qAdrszCarriageReturn:        .quad szCarriageReturn

/******************************************************************/
/*     test if number is aritmetic number                                               */ 
/******************************************************************/
/* x0 contains string address */
/* x1 contains buffer address */
/* x2 number repeat  */
/* x0 return buffer writed length or -1 if error*/
repeatString: 
    stp x3,lr,[sp,-16]!    // save  registers 
    stp x4,x5,[sp,-16]!    // save  registers 
    stp x6,x7,[sp,-16]!    // save  registers 
    mov x3,#0              // indice repeat
    mov x4,#0              // indice buffer
1:
    mov x5,#0              // indice string
2:
    ldrb w6,[x0,x5]        // load string characters
    cmp x6,#0              // end string ?
    beq 3f
    strb w6,[x1,x4]        // store char in buffer
    add x4,x4,#1           // increment indice
    add x5,x5,#1
    b 2b                   // and loop
3:
    mul x6,x5,x2           // compute repeat length string
    cmp x6,#BUFFERSIZE     // compare to buffer length
    bge 99f                // error ?
    add x3,x3,#1           // increment repeat counter
    cmp x3,x2              // end ?
    blt 1b
    mov x6,#0
    strb w6,[x1,x4]        // final zero
    mov x0,x4              // return length
    b 100f
99:
    mov x0,#-1             // error

100:
    ldp x6,x7,[sp],16      // restaur  r egisters 
    ldp x4,x5,[sp],16      // restaur  registers 
    ldp x3,lr,[sp],16      // restaur  registers
    ret 
/***************************************************/
/*      ROUTINES INCLUDE                 */
/***************************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeARM64.inc"

Output:

Program 64 bits start.
hohohohoho
Program normal end.

ABAP

This works for ABAP Version 7.40 and above

report z_repeat_string.

write repeat( val = `ha`  occ = 5 ).

Output:

hahahahaha

Action!

Proc Main()
 byte REPEAT

 REPEAT=5
  Do
   Print("ha")
   REPEAT==-1
   Until REPEAT=0
  Do

Return

Output:

hahahahaha

ActionScript

ActionScript does not have a built-in way to repeat a string multiple times, but the addition operator can be used to concatenate strings.

In Flex, there is the method mx.utils.StringUtil.repeat().

Iterative version

function repeatString(string:String, numTimes:uint):String
{
	var output:String = "";
	for(var i:uint = 0; i < numTimes; i++)
		output += string;
	return output;
}

Recursive version

The following double-and-add method is much faster when repeating a string many times.

function repeatRecursive(string:String, numTimes:uint):String
{
	if(numTimes == 0) return "";
	if(numTimes & 1) return string + repeatRecursive(string, numTimes - 1);
	var tmp:String = repeatRecursive(string, numTimes/2);
	return tmp + tmp;
}

Flex

import mx.utils.StringUtil;
trace(StringUtil.repeat("ha", 5));

Sample Output:

hahahahaha

Ada

In Ada multiplication of an universal integer to string gives the desired result. Here is an example of use:

with Ada.Strings.Fixed;  use Ada.Strings.Fixed;
with Ada.Text_IO;        use Ada.Text_IO;

procedure String_Multiplication is
begin
   Put_Line (5 * "ha");
end String_Multiplication;

Sample output:

hahahahaha

Aime

call_n(5, o_text, "ha");

ALGOL 68

print (5 * "ha")

Amazing Hopper

#!/usr/bin/hopper
#include <hopper.h>

main:
  {"ha"}replyby(5),    println
  {"ha",5}replicate,   println
{0}return

hahahahaha
hahahahaha

APL

Fill up a string of length 10 with 'ha':

      10⍴'ha'
hahahahaha

Alternatively, define a function:

      REPEAT←{(⍺×⍴⍵)⍴⍵}
      5 REPEAT 'ha'
hahahahaha

AppleScript

set str to "ha"
set final_string to ""
repeat 5 times
    set final_string to final_string & str
end repeat

For larger numbers of repetitions, however, it proves significantly faster to progressively double a copy of the original string (concatenating it with itself). Intermediate stages of doubling are appended to an accumulator wherever required for binary composition of the target number.

See the technique of 'Egyptian Multiplication' described in the Rhind Mathematical Papyrus at the British Museum.

Translation of: JavaScript

replicate(5000, "ha")

-- Repetition by 'Egyptian multiplication' - 
-- progressively doubling a list, appending
-- stages of doubling to an accumulator where needed for 
-- binary assembly of a target length.

-- replicate :: Int -> String -> String
on replicate(n, s)
    set out to ""
    if n < 1 then return out
    set dbl to s
    
    repeat while (n > 1)
        if (n mod 2) > 0 then set out to out & dbl
        set n to (n div 2)
        set dbl to (dbl & dbl)
    end repeat
    return out & dbl
end replicate

Applesoft BASIC

FOR I = 1 TO 5 : S$ = S$ + "HA" : NEXT

? "X" SPC(20) "X"

Output:

X                    X

ARM Assembly

Works with: as version Raspberry Pi
or android 32 bits with application Termux

/* ARM assembly Raspberry PI  */
/*  program repeatstring.s   */
   
/* REMARK 1 : this program use routines in a include file 
   see task Include a file language arm assembly 
   for the routine affichageMess conversion10 
   see at end of this program the instruction include */

/*******************************************/
/* Constantes                              */
/*******************************************/
.include "../constantes.inc"

.equ BUFFERSIZE, 2000
/*******************************************/
/*   Macros                              */
/*******************************************/
//.include "../../ficmacros32.inc"            @ for developer debugging

/*********************************/
/* Initialized data              */
/*********************************/
.data
szMessDebutPgm:   .asciz "Program 32 bits start. \n"
szCarriageReturn: .asciz "\n"
szMessFinOK:      .asciz "Program normal end. \n"
szMessErreur:     .asciz "Error  Buffer too small!!!\n"

szString1:          .asciz "ha"
                    
   
         
/*********************************/
/* UnInitialized data            */
/*********************************/
.bss

.align 4
sZoneConv:             .skip 24
sBuffer:               .skip BUFFERSIZE
/*********************************/
/*  code section                 */
/*********************************/
.text
.global main 
main:
    ldr r0,iAdrszMessDebutPgm
    bl affichageMess              @ start message 
    ldr r0,iAdrszString1          @ load phrase adress 
    ldr r1,iAdrsBuffer
    mov r2,#5
    bl repeatString
    cmp r0,#0
    ble 99f

    ldr r0,iAdrsBuffer            @ buffer display
    bl affichageMess

    ldr r0,iAdrszCarriageReturn
    bl affichageMess
    
    ldr r0,iAdrszMessFinOK
    bl affichageMess       
    b 100f
99:
    ldr r0,iAdrszMessErreur        @ error
    bl affichageMess
    mov r0, #1                     @ return code error
    b 100f
100: 
    mov r7,#EXIT                   @ program end
    svc #0                         @ system call
iAdrszMessDebutPgm:          .int szMessDebutPgm
iAdrszMessFinOK:             .int szMessFinOK
iAdrszMessErreur:            .int szMessErreur 
iAdrszString1:               .int szString1
iAdrsBuffer:                 .int sBuffer
iAdrsZoneConv:               .int sZoneConv
iAdrszCarriageReturn:        .int szCarriageReturn

/******************************************************************/
/*     test if number is aritmetic number                                               */ 
/******************************************************************/
/* r0 contains string address */
/* r1 contains buffer address */
/* r2 number repeat  */
/* r0 return buffer writed length or -1 if error*/
repeatString: 
    push {r3-r6,lr}       @ save  registers
    mov r3,#0              @ indice repeat
    mov r4,#0              @ indice buffer
1:
    mov r5,#0              @ indice string
2:
    ldrb r6,[r0,r5]        @ load string characters
    cmp r6,#0              @ end string ?
    beq 3f
    strb r6,[r1,r4]        @ store char in buffer
    add r4,r4,#1           @ increment indice
    add r5,r5,#1
    b 2b                   @ and loop
3:
    mul r6,r5,r2           @ compute repeat length string
    cmp r6,#BUFFERSIZE     @ compare to buffer length
    movge r0,#-1           @ error ?
    bge 100f 
    add r3,r3,#1           @ increment repeat counter
    cmp r3,r2              @ end ?
    blt 1b
    mov r6,#0
    strb r6,[r1,r4]        @ final zero
    mov r0,r4              @ return length

100:
    pop {r3-r6,pc}         @ restaur registers
/***************************************************/
/*      ROUTINES INCLUDE                 */
/***************************************************/
.include "../affichage.inc"

Output:

Program 32 bits start.
hahahahaha
Program normal end.

Arturo

print repeat "ha" 5

Output:

hahahahaha

AutoHotkey

MsgBox % Repeat("ha",5)

Repeat(String,Times)
{
  Loop, %Times%
    Output .= String
  Return Output
}

AutoIt

#include <String.au3>

ConsoleWrite(_StringRepeat("ha", 5) & @CRLF)

AWK

function repeat( str, n,    rep, i )
{
    for( ; i<n; i++ )
        rep = rep str   
    return rep
}

BEGIN {
    print repeat( "ha", 5 )
}

Babel

main: { "ha" 5 print_repeat }

print_repeat!: { <- { dup << } -> times }

Outputs:

hahahahaha

The '<<' operator prints, 'dup' duplicates the top-of-stack, 'times' does something x number of times. The arrows mean down (<-) and up (->) respectively - it would require a lengthy description to explain what this means, refer to the doc/babel_ref.txt file in the github repo linked from Babel

BaCon

To repeat a string:

DOTIMES 5
    s$ = s$ & "ha"
DONE
PRINT s$

Output:

hahahahaha

To repeat one single character:

PRINT FILL$(5, ASC("x"))

Output:

xxxxx

BASIC

BASIC256

function StringRepeat$ (s$, n)
	cad$ = ""
	for i = 1 to n
		cad$ += s$
	next i
	return cad$
end function

print StringRepeat$("rosetta", 1)
print StringRepeat$("ha", 5)
print StringRepeat$("*", 5)
end

Chipmunk Basic

Works with: Chipmunk Basic version 3.6.4

100 cls
110 print stringrepeat$("rosetta",1)
120 print stringrepeat$("ha",5)
130 print stringrepeat$("*",5)
140 end
150 function stringrepeat$(s$,n)
160   cad$ = ""
170   for i = 1 to n
180     cad$ = cad$+s$
190   next i
200   stringrepeat$ = cad$
210 end function

GW-BASIC

Works with: Applesoft BASIC

Works with: PC-BASIC version any

Works with: BASICA

Works with: Chipmunk Basic

Works with: QBasic

Works with: MSX BASIC

100 CLS : rem  100 HOME for Applesoft BASIC
110 S$ = "rosetta" : N = 1
120 GOSUB 210
130 PRINT CAD$
140 S$ = "ha" : N = 5
150 GOSUB 210
160 PRINT CAD$
170 S$ = "*" : N = 5
180 GOSUB 210
190 PRINT CAD$
200 END
210 REM FUNCTION STRINGREPEAT$(S$,N)
220   CAD$ = ""
230   FOR I = 1 TO N
240     CAD$ = CAD$+S$
250   NEXT I
260 RETURN

Minimal BASIC

Works with: Quite BASIC

100 REM Repeat a string
110 LET S$ = "rosetta"
120 LET N = 1
130 GOSUB 210
140 LET S$ = "ha"
150 LET N = 5
160 GOSUB 210
170 LET S$ = "*"
180 LET N = 5
190 GOSUB 210
200 STOP
210 REM FUNCTION StringRepeat$(S$,N)
220   FOR I = 1 TO N
230   PRINT S$;
240   NEXT I
250 PRINT
260 RETURN
270 END

MSX Basic

Works with: MSX BASIC version any

The GW-BASIC solution works without any changes.

QBasic

FUNCTION StringRepeat$ (s$, n)
    cad$ = ""
    FOR i = 1 TO n
        cad$ = cad$ + s$
    NEXT i
    StringRepeat$ = cad$
END FUNCTION

PRINT StringRepeat$("rosetta", 1)
PRINT StringRepeat$("ha", 5)
PRINT StringRepeat$("*", 5)
END

Quite BASIC

Works with: BASICA

Works with: Chipmunk Basic

Works with: GW-BASIC

Works with: MSX BASIC

Works with: PC-BASIC version any

Works with: QBasic

100 CLS
110 LET S$ = "rosetta"
115 LET N = 1
120 GOSUB 210
130 PRINT C$
140 LET S$ = "ha"
145 LET N = 5
150 GOSUB 210
160 PRINT C$
170 LET S$ = "*"
175 LET N = 5
180 GOSUB 210
190 PRINT C$
200 END
210 REM FUNCTION STRINGREPEAT$(S$,N)
220   LET C$ = ""
230   FOR I = 1 TO N
240     LET C$ = C$ + S$
250   NEXT I
260 RETURN

True BASIC

FUNCTION StringRepeat$ (s$, n)
    LET cad$ = ""
    FOR i = 1 TO n
        LET cad$ = cad$ & s$
    NEXT i
    LET StringRepeat$ = cad$
END FUNCTION

PRINT StringRepeat$("rosetta", 1)
PRINT StringRepeat$("ha", 5)
PRINT StringRepeat$("*", 5)
END

XBasic

Works with: Windows XBasic

PROGRAM	"Repeat a string"
VERSION	"0.0000"

DECLARE FUNCTION  Entry ()
DECLARE FUNCTION  StringRepeat$ (s$, n)

FUNCTION  Entry ()

PRINT StringRepeat$ ("rosetta", 1)
PRINT StringRepeat$ ("ha", 5)
PRINT StringRepeat$ ("*", 5)

END FUNCTION
FUNCTION StringRepeat$ (s$, n)
    cad$ = ""
    FOR i = 1 TO n
        cad$ = cad$ + s$
    NEXT i
    RETURN cad$
END FUNCTION
END PROGRAM

Yabasic

sub StringRepeat$ (s$, n)
    cad$ = ""
    for i = 1 to n
        cad$ = cad$ + s$
    next i
    return cad$
end sub

print StringRepeat$("rosetta", 1)
print StringRepeat$("ha", 5)
print StringRepeat$("*", 5)
end

Batch File

Commandline implementation

@echo off
if "%2" equ "" goto fail
setlocal enabledelayedexpansion
set char=%1
set num=%2
for /l %%i in (1,1,%num%) do set res=!res!%char%
echo %res%
:fail

'Function' version

@echo off
set /p a=Enter string to repeat :
set /p b=Enter how many times to repeat :
set "c=1"
set "d=%b%"
:a
echo %a%
set "c=%c%+=1"
if /i _"%c%"==_"%d%" (exit /b)
goto :a

'Function' version 2

@echo off
@FOR /L %%i in (0,1,9) DO @CALL :REPEAT %%i
@echo That's it!
@FOR /L %%i in (0,1,9) DO @CALL :REPEAT %%i
@echo.
@echo And that!
@GOTO END

:REPEAT
@echo|set /p="*"
@GOTO:EOF

:END

BBC BASIC

      PRINT STRING$(5, "ha")

beeswax

          p    <
      p0~1<}~< d@<
_VT@1~>yg~9PKd@M'd;

Example:

julia> beeswax("repeat a string.bswx")
sha
i5
hahahahaha
Program finished!

s tells the user that the program expects a string as input. i tells the user that the program expects an integer as input.

Beef

String s = new String('X', 5);
s.Replace("X", "ha");

And for single character repeats

String s1 = scope .();
s1.PadLeft(5, '*');

Befunge

v>                ">:#,_v
>29*+00p>~:"0"-    #v_v $
 v      ^p0p00:-1g00< $            >
 v    p00&p0-1g00+4*65< >00g1-:00p#^_@

Input sample:

ha05

Input string has to be zero terminated and less than 18 characters.

Output sample:

hahahahaha

BQN

⥊(reshape) can all by itself be used to repeat a string to a particular length. This function is just a wrapper around it to repeat n times.

Repeat ← ×⟜≠ ⥊ ⊢

•Show 5 Repeat "Hello"

"HelloHelloHelloHelloHello"

Bracmat

The code almost explains itself. The repetions are accumulated in a list rep. The str concatenates all elements into a single string, ignoring the white spaces separating the elements.

(repeat=
  string N rep
.   !arg:(?string.?N)
  & !string:?rep
  &   whl
    ' (!N+-1:>0:?N&!string !rep:?rep)
  & str$!rep
);

 repeat$(ha.5)
 hahahahaha

Brainf***

Prints "ha" 10 times. Note that this method only works for a number of repetitions that fit into the cell size.

+++++ +++++	init first as 10 counter
[-> +++++ +++++<] we add 10 to second each loopround

		Now we want to loop 5 times to follow std
+++++
[-> ++++ . ----- -- . +++<] print h and a each loop

and a newline because I'm kind and it looks good
+++++ +++++ +++ . --- .

Brat

p "ha" * 5  #Prints "hahahahaha"

Burlesque

blsq ) 'h5?*
"hhhhh"
blsq ) "ha"5.*\[
"hahahahaha"

C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char * string_repeat( int n, const char * s ) {
  size_t slen = strlen(s);
  char * dest = malloc(n*slen+1);

  int i; char * p;
  for ( i=0, p = dest; i < n; ++i, p += slen ) {
    memcpy(p, s, slen);
  }
  *p = '\0';
  return dest;
}

int main() {
  char * result = string_repeat(5, "ha");
  puts(result);
  free(result);
  return 0;
}

A variation.

...
char *string_repeat(const char *str, int n)
{
   char *pa, *pb;
   size_t slen = strlen(str);
   char *dest = malloc(n*slen+1);

   pa = dest + (n-1)*slen;
   strcpy(pa, str);
   pb = --pa + slen; 
   while (pa>=dest) *pa-- = *pb--;
   return dest;
}

To repeat a single character

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char * char_repeat( int n, char c ) {
  char * dest = malloc(n+1);
  memset(dest, c, n);
  dest[n] = '\0';
  return dest;
}

int main() {
  char * result = char_repeat(5, '*');
  puts(result);
  free(result);
  return 0;
}

If you use GLib, simply use g_strnfill ( gsize length, gchar fill_char ) function.

C#

string s = "".PadLeft(5, 'X').Replace("X", "ha");

or (with .NET 2+)

string s = new String('X', 5).Replace("X", "ha");

or (with .NET 2+)

string s = String.Join("ha", new string[5 + 1]);

or (with .NET 4+)

string s = String.Concat(Enumerable.Repeat("ha", 5));

To repeat a single character:

string s = "".PadLeft(5, '*');

or (with .NET 2+)

string s = new String('*', 5);

C++

#include <string>
#include <iostream>

std::string repeat( const std::string &word, int times ) {
   std::string result ;
   result.reserve(times*word.length()); // avoid repeated reallocation
   for ( int a = 0 ; a < times ; a++ ) 
      result += word ;
   return result ;
}

int main( ) {
   std::cout << repeat( "Ha" , 5 ) << std::endl ;
   return 0 ;
}

To repeat a single character:

#include <string>
#include <iostream>

int main( ) {
   std::cout << std::string( 5, '*' ) << std::endl ;
   return 0 ;
}

recursive version

#include <string>
#include <iostream>
 
std::string repeat( const std::string &word, uint times ) {
  return
    times == 0 ? "" :
    times == 1 ? word :
    times == 2 ? word + word :
    repeat(repeat(word, times / 2), 2) +
    repeat(word, times % 2);
}

int main( ) {
   std::cout << repeat( "Ha" , 5 ) << std::endl ;
   return 0 ;
}

Ceylon

shared void repeatAString() {
	print("ha".repeat(5));
}

Clipper

Also works with Harbour Project compiler Harbour 3.0.0 (Rev. 16951)

   Replicate( "Ha", 5 )

Clojure

(apply str (repeat 5 "ha"))

COBOL

Virtually a one-liner.

IDENTIFICATION DIVISION.
PROGRAM-ID. REPEAT-PROGRAM.
DATA DIVISION.
WORKING-STORAGE SECTION.
77  HAHA         PIC A(10).
PROCEDURE DIVISION.
    MOVE ALL 'ha' TO HAHA.
    DISPLAY HAHA.
    STOP RUN.

Output:

hahahahaha

ColdFusion

<cfset word = 'ha'>
<Cfset n = 5>
<Cfoutput>
<Cfloop from="1" to="#n#" index="i">#word#</Cfloop>
</Cfoutput>

Common Lisp

(defun repeat-string (n string)
  (with-output-to-string (stream)
    (loop repeat n do (write-string string stream))))

A version which allocates the result string in one step:

(defun repeat-string (n string
                     &aux
                     (len (length string))
                     (result (make-string (* n len)
                                          :element-type (array-element-type string))))
  (loop repeat n
        for i from 0 by len
        do (setf (subseq result i (+ i len)) string))
  result)

For those who love one-liners, even at the expense of readability:

(defun repeat-string (n string)
  (format nil "~V@{~a~:*~}" n string))

(princ (repeat-string 5 "hi"))

A single character may be repeated using just the builtin make-string:

(make-string 5 :initial-element #\X)

produces “XXXXX”.

Crystal

puts "ha" * 5

hahahahaha

D

Repeating a string:

import std.stdio, std.array;

void main() {
    writeln("ha".replicate(5));
}

Repeating a character with vector operations:

import std.stdio;

void main() {
    char[] chars;     // create the dynamic array
    chars.length = 5; // set the length
    chars[] = '*';    // set all characters in the string to '*'
    writeln(chars);
}

DCL

Not exactly what the task asks for but at least it is something;

$ write sys$output f$fao( "!AS!-!AS!-!AS!-!AS!-!AS", "ha" )
$ write sys$output f$fao( "!12*d" )

Output:

$ @repeat_a_string_and_then_character
hahahahaha
dddddddddddd

Delphi

Repeat a string

function RepeatString(const s: string; count: cardinal): string;
var
  i: Integer;
begin
  for i := 1 to count do
    Result := Result + s;
end;

Writeln(RepeatString('ha',5));

Repeat a character

Writeln( StringOfChar('a',5) );

Using recursion

function RepeatStr(const s: string; i: Cardinal): string;
begin
  if i = 0 then
    result := ''
  else
   result := s + RepeatStr(s, i-1)
end;

Built in RTL function:

StrUtils.DupeString

DuckDB

Notice that if s is a string, `repeat(s,0)` evaluates to the empty string.

select repeat('abc', 5) as five,
       (repeat('abc', 0) = '') as zero;

Output:

┌─────────────────┬─────────┐
│      five       │  zero   │
│     varchar     │ boolean │
├─────────────────┼─────────┤
│ abcabcabcabcabc │ true    │
└─────────────────┴─────────┘

To join `n` copies of a string together with a specific "join string", one can use `string_agg(_, _)`, e.g.

select string_agg('a',' ') as a from range(0,5);

Output:

┌───────────┐
│     a     │
│  varchar  │
├───────────┤
│ a a a a a │
└───────────┘

DWScript

Repeat a string

PrintLn( StringOfString('abc',5) );

Repeat a character

PrintLn( StringOfChar('a',5) );

Dyalect

String.Repeat("ha", 5)

Déjà Vu

!. concat( rep 5 "ha" )

Output:

"hahahahaha"

E

"ha" * 5

EasyLang

func$ rep s$ n .
   for i to n
      r$ &= s$
   .
   return r$
.
print rep "ha" 5

ECL

After version 4.2.2

IMPORT STD; //Imports the Standard Library
 
STRING MyBaseString := 'abc';
RepeatedString := STD.Str.Repeat(MyBaseString,3);
RepeatedString;  //returns 'abcabcabc'

Before version 4.2.2

RepeatString(STRING InStr, INTEGER Cnt) := FUNCTION
  rec := {STRING Str};
  ds  := DATASET(Cnt,TRANSFORM(rec,SELF.Str := InStr));
  res := ITERATE(ds,TRANSFORM(rec,SELF.Str := LEFT.Str + RIGHT.Str));
  RETURN Res[Cnt].Str;
END;

RepeatString('ha',3);
RepeatString('Who',2);

Ecstasy

String funny = "ha" * 5;
String stars = '*' * 80;

ed

Port of #sed. Number of ampersands is the number of repetitions.

# by Artyom Bologov
H
s/.*/&&&&&/
p
Q

Egison

(S.concat (take 5 (repeat1 "ha")))

Eiffel

 repeat_string(a_string: STRING; times: INTEGER): STRING
 require
   times_positive: times > 0
 do
   Result := a_string.multiply(times)
 end

Elena

ELENA 6.x :

import system'routines;
import extensions;
import extensions'text;
 
public program()
{
    var s := new Range(0, 5).selectBy::(x => "ha").summarize(new StringWriter())
}

Elixir

String.duplicate("ha", 5)

Emacs Lisp

Going via a list to repeat the desired string:

(apply 'concat (make-list 5 "ha"))

A single character can be repeated with make-string:

(make-string 5 ?x)

The cl-loop macro can repeat and concatenate:

Library: cl-lib

(require 'cl-lib)
(cl-loop repeat 5 concat "ha")

Erlang

repeat(X,N) ->
    lists:flatten(lists:duplicate(N,X)).

This will duplicate a string or character N times to produce a new string.

ERRE

PROCEDURE REPEAT_STRING(S$,N%->REP$)
   LOCAL I%
   REP$=""
   FOR I%=1 TO N% DO
       REP$=REP$+S$
   END FOR
END PROCEDURE

Note: If N% is less than 1, the result is the empty string "".If S$ is a one-character string you can use the predefined function STRING$ as REP$=STRING$(S$,N%).

Euphoria

A simple loop will do:

sequence s = ""
for i = 1 to 5 do s &= "ha" end for
puts(1,s)

hahahahaha

For repeating a single character:

sequence s = repeat('*',5)

*****

For repeating a string or sequence of numbers:

include std/console.e -- for display
include std/sequence.e -- for repeat_pattern
sequence s = repeat_pattern("ha",5)
sequence n = repeat_pattern({1,2,3},5)
display(s)
display(n)

hahahahaha
{1,2,3,1,2,3,1,2,3,1,2,3,1,2,3}

But wait, here's another way:

include std/console.e -- for display
include std/sequence.e -- for flatten
sequence s = flatten(repeat("ha",5))
display(s)

note: repeat creates a sequence of ha's as shown below; flatten concatenates them.

{
 "ha",
 "ha",
 "ha",
 "ha",
 "ha"
}

Explore

The Scratch solution, which requires making variables named "String", "Count", and "Repeated" first, works, unmodified:
https://i.ibb.co/yX3ybt7/Repeat-a-string-in-Explore-using-the-Scratch-solution.png

This example uses a special block located in the Strings category, and also outputs the results of the repeating of the string to a "say" block:
https://i.ibb.co/71x9rwn/Repeat-a-string-in-Explore-using-a-special-block.png

F#

> String.replicate 5 "ha";;
val it : string = "hahahahaha"

Or

> String.Concat( Array.create 5 "ha" );;
val it : string = "hahahahaha"

Factor

: repeat-string ( str n -- str' ) swap <repetition> concat ;

"ha" 5 repeat-string print

Forth

: place-n { src len dest n -- }
  0 dest c!
  n 0 ?do src len dest +place loop ;

s" ha" pad 5 place-n
pad count type    \ hahahahaha

The same code without the use of locals:

                                       
: place-n ( src len dest n -- )
  swap >r 0 r@ c!
  begin dup while -rot 2dup r@ +place rot 1- repeat
  r> 2drop 2drop ;

s" ha" pad 5 place-n
pad count type    \ hahahahaha

Filling a string with a single character is supported by ANS-Forth:

pad 10 char * fill   \ repeat a single character
pad 10 type    \ **********

Fortran

Works with: Fortran version 90 and later

program test_repeat

  write (*, '(a)') repeat ('ha', 5)

end program test_repeat

Output:

hahahahaha

Free Pascal

strUtils.dupeString('ha', 5)

Repetition of a single character:

stringOfChar('*', 5)

If the repeated character happens to be the space character:

space(5)

FreeBASIC

' FB 1.05.0 Win64

' A character is essentially a string of length 1 in FB though there is a built-in function, String,
' which creates a string by repeating a character a given number of times.

' To avoid repeated concatenation (a slow operation) when the string to be repeated has a length
' greater than one, we instead create a buffer of the required size and then fill that.

Function repeat(s As String, n As Integer) As String
  If n < 1 Then Return ""
  If n = 1 Then Return s
  Var size = Len(s)
  If size = 0 Then Return s  ' empty string
  If size = 1 Then Return String(n, s[0])  ' repeated single character  
  Var buffer = Space(size * n)  'create buffer for size > 1
  For i As Integer = 0 To n - 1
    For j As Integer = 0 To size - 1
      buffer[i * size + j] = s[j]
    Next j
  Next i
  Return buffer
End Function 

Print repeat("rosetta", 1)
Print repeat("ha", 5)
Print repeat("*", 5)
Print
Print "Press any key to quit program"
Sleep

Output:

rosetta
hahahahaha
*****

Frink

println[repeat["ha", 5]]

FutureBasic

include "NSLog.incl"

CFStringRef repeatStr
repeatStr = @"Hello, World!\n"
NSLog( @"%@", fn StringByPaddingToLength( @"", 50 * len(repeatStr), repeatStr, 0 ) )

HandleEvents

Output:

[50 line repetitions of "Hello, World!"]

Gambas

Click this link to run this code

Public Sub Main()

Print String$(5, "ha")

End

Output = hahahahaha

GAP

Concatenation(ListWithIdenticalEntries(10, "BOB "));
"BOB BOB BOB BOB BOB BOB BOB BOB BOB BOB "

Glee

'*' %% 5

'ha' => Str;
Str# => Len;
1..Len %% (Len * 5) => Idx;
Str [Idx] $;

'ha'=>S[1..(S#)%%(S# *5)]

Go

fmt.Println(strings.Repeat("ha", 5))        // ==> "hahahahaha"

There is no special way to repeat a single character, other than to convert the character to a string. The following works:

fmt.Println(strings.Repeat(string('h'), 5)) // prints hhhhh

Groovy

 println 'ha' * 5

Harbour

? Replicate( "Ha", 5 )

Haskell

For a string of finite length:

concat $ replicate 5 "ha"

Or with list-monad (a bit obscure):

[1..5] >> "ha"

Or with Control.Applicative:

[1..5] *> "ha"

For an infinitely long string:

cycle "ha"

To repeat a single character:

replicate 5 '*'

Or, unpacking the mechanism of replicate a little, and using a mappend-based rep in lieu of the cons-based repeat, so that we can skip a subsequent concat:

repString :: String -> Int -> String
repString s n =
  let rep x = xs
        where
          xs = mappend x xs
  in take (n * length s) (rep s)

main :: IO ()
main = print $ repString "ha" 5

Output:

"hahahahaha"

As the number of repetitions grows, however, it may become more efficient to repeat by progressive duplication (mappend to self), mappending to an accumulator only where required for binary composition of the target length. (i.e. Rhind Papyrus 'Egyptian' or 'Ethiopian' multiplication):

import Data.Tuple (swap)
import Data.List (unfoldr)
import Control.Monad (join)

-- BY RHIND PAPYRUS 'EGYPTIAN' OR 'ETHIOPIAN' MULTIPLICATION ------------------
repString :: Int -> String -> String
repString n s =
  foldr
    (\(d, x) a ->
        if d > 0 -- Is this power of 2 needed for the binary recomposition ?
          then mappend a x
          else a)
    mempty $
  zip
    (unfoldr
       (\h ->
           if h > 0
             then Just $ swap (quotRem h 2) -- Binary decomposition of n
             else Nothing)
       n)
    (iterate (join mappend) s) -- Iterative duplication ( mappend to self )

-- TEST -----------------------------------------------------------------------
main :: IO ()
main = print $ repString 500 "ha"

HicEst

CHARACTER out*20

EDIT(Text=out, Insert="ha", DO=5)

Icon and Unicon

The procedure repl is a supplied function in Icon and Unicon.

procedure main(args)
    write(repl(integer(!args) | 5))
end

If it weren't, one way to write it is:

procedure repl(s, n)
    every (ns := "") ||:= |s\(0 <= n)
    return ns
end

Idris

strRepeat : Nat -> String -> String
strRepeat Z s = ""
strRepeat (S n) s = s ++ strRepeat n s

chrRepeat : Nat -> Char -> String
chrRepeat Z c = ""
chrRepeat (S n) c = strCons c $ chrRepeat n c

Inform 7

Home is a room.

To decide which indexed text is (T - indexed text) repeated (N - number) times:
	let temp be indexed text;
	repeat with M running from 1 to N:
		let temp be "[temp][T]";
	decide on temp.

When play begins:
	say "ha" repeated 5 times;
	end the story.

Insitux

(str* "ha" 5)

Output:

hahahahaha

IS-BASIC

 10 PRINT STRING$("ha",5)
100 DEF STRING$(S$,N)
105   LET ST$=""
110   FOR I=1 TO N
120     LET ST$=ST$&S$
130   NEXT
140   LET STRING$=ST$
150 END DEF

J

   5 # '*'               NB. repeat each item 5 times
*****
   5 # 'ha'              NB. repeat each item 5 times
hhhhhaaaaa
   5 ((* #) $ ]) 'ha'    NB. repeat array 5 times
hahahahaha
   5 ;@# < 'ha'          NB. using boxing to treat the array as a whole
hahahahaha

Java

There are a few ways to achieve this in Java.
Starting with Java 11 you can use the String.repeat method.

"ha".repeat(5);

Which, if you view its implementation, is just using the Arrays.fill method.

String[] strings = new String[5];
Arrays.fill(strings, "ha");
StringBuilder repeated = new StringBuilder();
for (String string : strings)
    repeated.append(string);

And if you look at the 'Arrays.fill' implementation, it's just a for-loop, which is likely the most idiomatic approach.

String string = "ha";
StringBuilder repeated = new StringBuilder();
int count = 5;
while (count-- > 0)
    repeated.append(string);

Or

Works with: Java version 1.5+

Before Java 11 there was no method or operator to do this in Java, so you had to do it yourself.

public static String repeat(String str, int times) {
    StringBuilder sb = new StringBuilder(str.length() * times);
    for (int i = 0; i < times; i++)
        sb.append(str);
    return sb.toString();
}

public static void main(String[] args) {
    System.out.println(repeat("ha", 5));
}

Or even shorter:

public static String repeat(String str, int times) {
   return new String(new char[times]).replace("\0", str);
}

In Apache Commons Lang, there is a StringUtils.repeat() method.

JavaScript

Extending the String prototype

This solution creates an empty array of length n+1, then uses the array's join method to effectively concatenate the string n times. Note that extending the prototype of built-in objects is not a good idea if the code is to run in a shared workspace.

String.prototype.repeat = function(n) {
    return new Array(1 + (n || 0)).join(this);
}

console.log("ha".repeat(5));  // hahahahaha

As of ES6, `repeat` is built in, so this can be written as:

console.log("ha".repeat(5));  // hahahahaha

Repetition by Egyptian multiplication

For larger numbers of repetitions, however, it proves significantly faster to progressively double a copy of the original string (concatenating it with itself). Intermediate stages of doubling are appended to an accumulator wherever required for binary composition of the target number.

See the technique of 'Egyptian Multiplication' described in the Rhind Mathematical Papyrus at the British Museum.

(() => {
    'use strict';

    // replicate :: Int -> String -> String
    const replicate = (n, s) => {
        let v = [s],
            o = [];
        if (n < 1) return o;
        while (n > 1) {
            if (n & 1) o = o + v;
            n >>= 1;
            v = v + v;
        }
        return o.concat(v);
    };


    return replicate(5000, "ha")
})();

Concat . replicate

Or, more generically, we could derive repeat as the composition of concat and replicate

(() => {
    'use strict';

    // repeat :: Int -> String -> String
    const repeat = (n, s) => 
        concat(replicate(n, s));
        

    // GENERIC FUNCTIONS ------------------------------------------------------

    // concat :: [[a]] -> [a] | [String] -> String
    const concat = xs =>
        xs.length > 0 ? (() => {
            const unit = typeof xs[0] === 'string' ? '' : [];
            return unit.concat.apply(unit, xs);
        })() : [];

    // replicate :: Int -> a -> [a]
    const replicate = (n, x) =>
        Array.from({
            length: n
        }, () => x);


    // TEST -------------------------------------------------------------------
    return repeat(5, 'ha');
})();

Output:

hahahahaha

Joy

DEFINE repeat == "" rotate [concat] cons times.

"ha" 5 repeat.

jq

"a " * 3 # => "a a a "

Note that if the integer multiplicand is 0, then the result is the JSON value null.

Julia

Works with: Julia version 1.0

@show "ha" ^ 5

# The ^ operator is really just call to the `repeat` function
@show repeat("ha", 5)

K

 
  ,/5#,"ha"
"hahahahaha"

  5#"*"
"*****"

Kotlin

fun main(args: Array<String>) {
    println("ha".repeat(5))
}

Or more fancy:

operator fun String.times(n: Int) = this.repeat(n)

fun main(args: Array<String>) = println("ha" * 5)

LabVIEW

I don't know if there is a built-in function for this, but it is easily achieved with a For loop and Concatenate Strings.
By using built in functions:

Lambdatalk

{S.map {lambda {_} ha} {S.serie 1 10}} 
-> ha ha ha ha ha ha ha ha ha ha 

or

{S.replace \s 
        by 
        in {S.map {lambda {_} ha}
                  {S.serie 1 10}}}
-> hahahahahahahahahaha

or
 
{def repeat
 {lambda {:w :n}
  {if {< :n 0}
   then
   else :w{repeat :w {- :n 1}}}}}
-> repeat

{repeat ha 10}
-> hahahahahahahahahahaha

Lang

# Repeat text function
fn.println(fn.repeatText(5, ha))
# Output: hahahahaha

# Mul operator
fn.println(parser.op(ha * 5))
# Output: hahahahaha

# Mul operator function
fn.println(fn.mul(ha, 5))
# Output: hahahahaha

langur

"ha" * 5

Lasso

'ha'*5 // hahahahaha

loop(5) => {^ 'ha' ^} // hahahahaha

LFE

(string:copies '"ha" 5)

Liberty BASIC

a$ ="ha "
print StringRepeat$( a$, 5)

end

function StringRepeat$( in$, n)
    o$ =""
    for i =1 to n
        o$ =o$ +in$
    next i
    StringRepeat$ =o$
end function

Lingo

Take a string and repeat it some number of times.

on rep (str, n)
  res = ""
  repeat with i = 1 to n
    put str after res
  end repeat
  return res
end

put rep("ha", 5)
-- "hahahahaha"

If there is a simpler/more efficient way to repeat a single “character”...

put bytearray(5, chartonum("*")).readRawString(5)
-- "*****"

LiveCode

on mouseUp
    put repeatString("ha", 5)
end mouseUp

function repeatString str n 
    repeat n times
        put str after t
    end repeat
    return t
end repeatString

Logo

to copies :n :thing [:acc "||]
  if :n = 0 [output :acc]
  output (copies :n-1 :thing combine :acc :thing)
end

or using cascade:

show cascade 5 [combine "ha ?] "||    ; hahahahaha

Lhogho doesn't have cascade (yet), nor does it have the initialise a missing parameter capability demonstrated by the [:acc "||] above.

to copies :n :thing :acc
  if :n = 0 [output :acc]
  output (copies :n-1 :thing combine :acc :thing)
end

print copies 5 "ha "||

Lua

function repeats(s, n) return n > 0 and s .. repeats(s, n-1) or "" end

Or use native string library function

string.rep(s,n)

Maple

There are many ways to do this in Maple. First, the "right" (most efficient) way is to use the supplied procedures for this purpose.

> use StringTools in
>       Repeat( "abc", 10 ); # repeat an arbitrary string
>       Fill( "x", 20 )      # repeat a character
> end use;
                    "abcabcabcabcabcabcabcabcabcabc"

                         "xxxxxxxxxxxxxxxxxxxx"

These next two are essentially the same, but are less efficient (though still linear) because they create a sequence of 10 strings before concatenating them (with the built-in procedure cat) to form the result.

> cat( "abc" $ 10 );
                    "abcabcabcabcabcabcabcabcabcabc"

> cat( seq( "abc", i = 1 .. 10 ) );
                    "abcabcabcabcabcabcabcabcabcabc"

You can build up a string in a loop, but this is highly inefficient (quadratic); don't do this.

> s := "":
> to 10 do s := cat( s, "abc" ) end: s;
                    "abcabcabcabcabcabcabcabcabcabc"

If you need to build up a string incrementally, use a StringBuffer object, which keeps things linear.

Finally, note that strings and characters are not distinct datatypes in Maple; a character is just a string of length one.

Mathematica /Wolfram Language

StringRepeat["ha", 5]

MATLAB / Octave

function S = repeat(s , n)
    S = repmat(s , [1,n]) ;
return

Note 1: The repetition is returned, not displayed.
Note 2: To repeat a string, use single quotes. Example: S=repeat('ha',5)

Maxima

"$*"(s, n) := apply(sconcat, makelist(s, n))$
infix("$*")$

"abc" $* 5;
/* "abcabcabcabcabc" */

Mercury

Mercury's 'string' module provides an efficient char-repeater. The following uses string.builder to repeat strings.

:- module repeat.
:- interface.
:- import_module string, char, int.

:- func repeat_char(char, int) = string.
:- func repeat(string, int) = string.

:- implementation.
:- import_module stream, stream.string_writer, string.builder.

repeat_char(C, N) = string.duplicate_char(C, N).

repeat(String, Count) = Repeated :-
        S0 = string.builder.init,
        Repeated = string.builder.to_string(S),
        printn(string.builder.handle, Count, String, S0, S).

:- pred printn(Stream, int, string, State, State)
               <= (stream.writer(Stream, string, State),
                   stream.writer(Stream, character, State)).
:- mode printn(in, in, in, di, uo) is det.
printn(Stream, N, String, !S) :-
        ( N > 0 ->
                print(Stream, String, !S),
                printn(Stream, N - 1, String, !S)
        ; true ).

min

Works with: min version 0.19.3

"ha" 5 repeat print

Output:

hahahahaha

MiniScript

str = "Lol"
print str * 5

Output:

LolLolLolLolLol

Mirah

x = StringBuilder.new

5.times do 
    x.append "ha"
end

puts x # ==> "hahahahaha"

Monte

var s := "ha " * 5
traceln(s)

MontiLang

|ha| 5 * PRINT .

Or with a loop

FOR 5
    |ha| OUT .
ENDFOR || PRINT .

Or ...

|ha| FOR 5 OUT ENDFOR . || PRINT .

MUMPS

RPTSTR(S,N)
 ;Repeat a string S for N times
 NEW I
 FOR I=1:1:N WRITE S
 KILL I
 QUIT
RPTSTR1(S,N) ;Functionally equivalent, but denser to read
 F I=1:1:N W S
 Q

This last example uses the $PIECE function.

 ;Even better (more terse)
 S x="",$P(x,"-",10)="-"
 W x

Nanoquery

In Nanoquery, multiplying strings by an integer returns a new string with the original value repeated.

"ha" * 5

Neko

/* Repeat a string, in Neko */
var srep = function(s, n) {
    var str = ""
    while n > 0 {
        str += s
        n -= 1
    }
    return str
}

$print(srep("ha", 5), "\n")

Output:

prompt$ nekoc srep.neko
prompt$ neko srep
hahahahaha

Nemerle

Any of the methods shown in the C# solution would also work for Nemerle, but they're all semantically awkward. This example uses an extension method to wrap one of the awkward techniques in order to clarify the semantics (which is also possible in C#, there's nothing really Nemerle specific here except the syntax).

using System;
using System.Console;

module StrRep
{
    Repeat(this s : string, n : int) : string
    {
        String('x', n).Replace("x", s)
    }
    
    Main() : void
    {
        WriteLine("ha".Repeat(5));
        WriteLine("*".Repeat(5));
        WriteLine(String('*', 5)); // repeating single char

    }
}

NetRexx

NetRexx has built in functions to manipulate strings. The most appropriate for this task is the copies() function:

/* NetRexx */

ha5 = 'ha'.copies(5)

There are several other built-in functions that can be used to achieve the same result depending on need:

/* NetRexx */
sampleStr = 'ha' -- string to duplicate
say '   COPIES:' sampleStr.copies(5)
say 'CHANGESTR:' '.....'.changestr('.', sampleStr)

sampleChr = '*' -- character to duplicate
say '     LEFT:' sampleChr.left(5, sampleChr)
say '    RIGHT:' sampleChr.right(5, sampleChr)
say '   CENTRE:' sampleChr.centre(5, sampleChr)
say '  OVERLAY:' sampleChr.overlay(sampleChr, 1, 5, sampleChr)
say '   SUBSTR:' ''.substr(1, 5, sampleChr)
say 'TRANSLATE:' '.....'.translate(sampleChr, '.')

NewLISP

(dup "ha" 5)

A different result from "dup":

(dup "back" 3 true)

Output:

("back" "back" "back")

Nim

import strutils

# Repeat a char.
echo repeat('a', 5)     # -> "aaaaa".

# Repeat a string.
echo repeat("ha", 5)    # -> "hahahahaha".

Nu

Works with: Nushell version 0.97.1

'' | fill -c 'ha' -w 5

or

..<5 | each { 'ha' } | str join

Output:

hahahahaha

Objeck

bundle Default {
  class Repeat {
    function : Main(args : String[]) ~ Nil {
      Repeat("ha", 5)->PrintLine();
    }
    
    function : Repeat(string : String, max : Int) ~ String {
      repeat : String := String->New();
      for(i := 0; i < max; i += 1;) {
        repeat->Append(string);
      };
      
      return repeat;
    }
  }
}

Objective-C

Objective-C allows developers to extend existing an existing class by adding additional methods to the class without needing to subclass. These extensions are called categories. Category methods are available to all instances of the class, as well as any instances of its subclasses.

This task provides us with an opportunity to visit this aspect of the language feature.

We will extend NSString, the de facto Objective-C string class in environments that are either compatible with or descend directly from the OPENSTEP specification, such as GNUstep and Mac OS X, respectively, with a method that accomplishes the described task.

@interface NSString (RosettaCodeAddition)
- (NSString *) repeatStringByNumberOfTimes: (NSUInteger) times;
@end

@implementation NSString (RosettaCodeAddition)
- (NSString *) repeatStringByNumberOfTimes: (NSUInteger) times {
    return [@"" stringByPaddingToLength:[self length]*times withString:self startingAtIndex:0];
}
@end

Now, let's put it to use:

    // Instantiate an NSString by sending an NSString literal our new
    // -repeatByNumberOfTimes: selector.
    NSString *aString = [@"ha" repeatStringByNumberOfTimes:5];

    // Display the NSString.
    NSLog(@"%@", aString);

OCaml

Since Ocaml 4.02 strings are immutable, as is convenient for a functional language. Mutable strings are now implemented in the module Bytes.

let string_repeat s n =
  let s = Bytes.of_string s in
  let len = Bytes.length s in
  let res = Bytes.create (n * len) in
  for i = 0 to pred n do
    Bytes.blit s 0 res (i * len) len
  done;
  (Bytes.to_string res)
;;

which gives the signature

val string_repeat : string -> int -> string = <fun>

testing in the toplevel:

# string_repeat "Hiuoa" 3 ;;
- : string = "HiuoaHiuoaHiuoa"

Alternately create an array initialized to s, and concat:

let string_repeat s n =
  String.concat "" (Array.to_list (Array.make n s))
;;

Or:

let string_repeat s n =
  Array.fold_left (^) "" (Array.make n s)
;;

To repeat a single character use:

String.make 5 '*'

Oforth

StringBuffer new "abcd" <<n(5)

OmniMark

process
  repeat for integer i from 1 to 5
    output "ha"
  again

OpenEdge/Progress

MESSAGE FILL( "ha", 5 ) VIEW-AS ALERT-BOX.

OxygenBasic

'REPEATING A CHARACTER

print string 10,"A" 'result AAAAAAAAAA

'REPEATING A STRING

function RepeatString(string s,sys n) as string
  sys i, le=len s
  if le=0 then exit function
  n*=le
  function=nuls n
  '
  for i=1 to n step le
    mid function,i,s
  next
end function

print RepeatString "ABC",3 'result ABCABCABC

Oz

We have to write a function for this:

declare
  fun {Repeat Xs N}
     if N > 0 then
        {Append Xs {Repeat Xs N-1}}
     else
        nil
     end
  end
in
  {System.showInfo {Repeat "Ha" 5}}

PARI/GP

Version #1. Based on recursion.

This solution is recursive and unimaginably bad. Slightly less bad versions can be designed, but that's not the point: don't use GP for text processing if you can avoid it. If you really need to, it's easy to create an efficient function in PARI (see C) and pass that to GP.

repeat(s,n)={
  if(n, Str(repeat(s, n-1), s), "")
};

concat() joins together a vector of strings, in this case a single string repeated.

repeat(s,n)=concat(vector(n,i, s));

This solution is recursive and slightly less bad than the others for large n.

repeat(s,n)={
  if(n<4, return(concat(vector(n,i, s))));
  if(n%2,
    Str(repeat(Str(s,s),n\2),s)
  ,
    repeat(Str(s,s),n\2)
  );
}

Version #2. Simple loop based.

Works with: PARI/GP version 2.7.4 and above

Basic set of string functions is very handy for presentation purposes. At the same time, it is true that PARI/GP is not an appropriate tool for the heavy text processing.

\\ Repeat a string str the specified number of times ntimes and return composed string.
\\ 3/3/2016 aev
srepeat(str,ntimes)={
my(srez=str,nt=ntimes-1);
if(ntimes<1||#str==0,return("")); 
if(ntimes==1,return(str)); 
for(i=1,nt, srez=concat(srez,str));
return(srez);
}

{
\\ TESTS
print(" *** Testing srepeat:");
print("1.",srepeat("a",5));
print("2.",srepeat("ab",5));
print("3.",srepeat("c",1));
print("4.|",srepeat("d",0),"|");
print("5.|",srepeat("",5),"|");
print1("6."); for(i=1,10000000, srepeat("e",10));
}

Output:

 *** Testing srepeat:
1.aaaaa
2.ababababab
3.c
4.||
5.||
6.
(16:00) gp > ##
  ***   last result computed in 1min, 2,939 ms.

Pascal

See Delphi or Free Pascal, as standard Pascal does not know strings of unlimited length.

PascalABC.NET

##
Print('ha' * 5)

Output:

hahahahaha

Perl

"ha" x 5

Phix

?repeat('*',5)
?join(repeat("ha",5),"")

Output:

"*****"
"hahahahaha"

Phixmonti

def rep  /# s n -- s #/
     "" swap
     for drop
	over chain
     endfor
     nip
enddef

"ha" 5 rep print

Same result (simple character):

65 5 rep
65 5 repeat
'A' 5 repeat

PHP

str_repeat("ha", 5)

PicoLisp

(pack (need 5 "ha"))
-> "hahahahaha"

or:

(pack (make (do 5 (link "ha"))))
-> "hahahahaha"

Pike

"ha"*5;

PL/I

/* To repeat a string a variable number of times: */

s = repeat('ha', 4);

  /* or */

s = copy('ha', 5);

/* To repeat a single character a fixed number of times: */

s = (5)'h';     /* asigns 'hhhhh' to s. */

Plain English

To run:
Start up.
Put "ha" into a string.
Append the string to itself given 5.
Write the string on the console.
Fill another string with the asterisk byte given 5.
Write the other string on the console.
Wait for the escape key.
Shut down.

To append a string to itself given a number:
If the number is less than 1, exit.
Privatize the string.
Privatize the number.
Subtract 1 from the number.
Append the string to the original string given the number.

Output:

hahahahaha
*****

Plorth

"ha" 5 *

PostScript

% the comments show the stack content after the line was executed
% where rcount is the repeat count, "o" is for orignal,
% "f" is for final, and iter is the for loop variable
%
% usage: rcount ostring times -> fstring

/times {
  dup length dup    % rcount ostring olength olength
  4 3 roll          % ostring olength olength rcount
  mul dup string    % ostring olength flength fstring
  4 1 roll          % fstring ostring olength flength
  1 sub 0 3 1 roll  % fstring ostring 0 olength flength_minus_one 
  {                 % fstring ostring iter
    1 index 3 index % fstring ostring iter ostring fstring
    3 1 roll        % fstring ostring fstring iter ostring
    putinterval     % fstring ostring
  } for
  pop               % fstring
} def

PowerBASIC

MSGBOX REPEAT$(5, "ha")

PowerShell

"ha" * 5  # ==> "hahahahaha"

Processing

void setup() {
  String rep = repeat("ha", 5);
  println(rep);
}
String repeat(String str, int times) {
  // make an array of n chars,
  // replace each char with str,
  // and return as a new String
  return new String(new char[times]).replace("\0", str);
}

Processing Python mode

def setup():
    rep = repeat("ha", 5)
    println(rep)

def repeat(s, times):
    return s * times

Prolog

%repeat(Str,Num,Res).
repeat(Str,1,Str).
repeat(Str,Num,Res):-
    Num1 is Num-1,
    repeat(Str,Num1,Res1),
    string_concat(Str, Res1, Res).

alternative using DCG strings

This tail-recursive DCG implemention is more efficient than anything using lists:append .

Works with: SWI-Prolog version 7

:- system:set_prolog_flag(double_quotes,chars) .

repeat(SOURCEz0,COUNT0,TARGETz)
:-
prolog:phrase(repeat(SOURCEz0,COUNT0),TARGETz)
.

%! repeat(SOURCEz0,COUNT0)//2

repeat(_SOURCEz0_,0)
-->
! ,
[]
.

repeat(SOURCEz0,COUNT0)
-->
SOURCEz0 ,
{ COUNT is COUNT0 - 1 } ,
repeat(SOURCEz0,COUNT)
.

Output:

/*
?- repeat("ha",5,TARGETz) .
TARGETz = [h, a, h, a, h, a, h, a, h, a].

?-
*/

:- begin_tests(basic) .

:- system:set_prolog_flag(double_quotes,chars) .

test('1',[])
:-
repeat("a",2,"aa")
.

test('2',[])
:-
repeat("ha",2,"haha")
.

test('3',[])
:-
repeat("ha",3,"hahaha")
.

test('4',[])
:-
repeat("",3,"")
.

test('5',[])
:-
repeat("ha",0,"")
.

test('6',[])
:-
repeat("ha",1,"ha")
.

:- end_tests(basic) .

Pure

str_repeat is defined by pattern-matching: repeating any string 0 times results in the empty string; while repeating it more than 0 times results in the concatenation of the string and (n-1) further repeats.

> str_repeat 0 s = "";
> str_repeat n s = s + (str_repeat (n-1) s) if n>0;
> str_repeat 5 "ha";
"hahahahaha"
>

You can define str_repeat using infinite lazy list (stream).

str_repeat n::int s::string = string $ take n $ cycle (s:[]);

PureBasic

Procedure.s RepeatString(count, text$=" ")
   Protected i, ret$=""

   For i = 1 To count
      ret$ + text$
   Next
   ProcedureReturn ret$
EndProcedure

Debug RepeatString(5, "ha")

Python

"ha" * 5  # ==> "hahahahaha"

"Characters" are just strings of length one.

the other way also works:

5 * "ha"  # ==> "hahahahaha"

Using a Function

def repeat(s, times):
    return s * times

print(repeat("ha", 5))

Output:

hahahahaha

Using Lambda

x = lambda a: a * 5
print(x("ha"))

Output:

hahahahaha

Quackery

$ "ha" 5 of echo$

Output:

hahahahaha

R

strrep("ha", 5)

Racket

#lang racket
;; fast
(define (string-repeat n str)
  (string-append* (make-list n str)))
(string-repeat 5 "ha") ; => "hahahahaha"

To repeat a single character:

(make-string 5 #\*) => "*****"

Raku

(formerly Perl 6)

print "ha" x 5

(Note that the x operator isn't quite the same as in Perl 5: it now only creates strings. To create lists, use xx.)

RapidQ

'For a single char
showmessage String$(10, "-")

'For strings with more than one char
function Repeat$(Expr as string, Count as integer) as string
    dim x as integer
    for x = 1 to Count
        Result = Result + Expr
    next
end function

showmessage Repeat$("ha", 5)

REALbasic

Function Repeat(s As String, count As Integer) As String
  Dim output As String
  For i As Integer = 0 To count
    output = output + s
  Next
  Return output
End Function

REBOL

head insert/dup "" "ha" 5

Red

>> str: "Add duplicates to string"
>> insert/dup str "ha" 3
== "hahahaAdd duplicates to string"
>> insert/dup tail str "ha" 3
== "hahahaAdd duplicates to stringhahaha"

ReScript

Js.log(Js.String2.repeat("ha", 5))

Retro

with strings'
: repeatString ( $n-$ )
  1- [ dup ] dip [ over prepend ] times nip ;

"ha" 5 repeatString

REXX

Since the REXX language only supports the "character" type, it's not surprising that there are so many ways to skin a cat.

/*REXX program to show various ways to repeat a string (or repeat a single char).*/

/*all examples are equivalent, but not created equal.*/

                           /*───────────────────────────────────────────*/
y='ha'
z=copies(y,5)
                           /*───────────────────────────────────────────*/
z=copies( 'ha', 5 )
                           /*───────────────────────────────────────────*/
y='ha'
z=y||y||y||y||y
                           /*───────────────────────────────────────────*/
y='ha'
z=y || y || y || y || y    /*same as previous, but the "big sky" version*/
                           /*───────────────────────────────────────────*/
y='ha'
z=''
       do 5
       z=z||y
       end
                           /*───────────────────────────────────────────*/
y="ha"
z=
       do 5
       z=z||y
       end
                           /*───────────────────────────────────────────*/
y="ha"
z=
       do i=101 to 105
       z=z||y
       end

                           /*───────────────────────────────────────────*/
y='+'
z=left('',5,y)
                           /*───────────────────────────────────────────*/
y='+'
z=right('',5,y)
                           /*───────────────────────────────────────────*/
y='+'
z=substr('',1,5,y)
                           /*───────────────────────────────────────────*/
y='+'
z=center('',5,y)
                           /*───────────────────────────────────────────*/
y='+'
z=centre('',5,y)
                           /*───────────────────────────────────────────*/
y='+'
z=space('',5,y)
                           /*───────────────────────────────────────────*/
y='+'
z=translate('@@@@@',y,"@")
                           /*───────────────────────────────────────────*/
y='abcdef'
z=five(y)
exit

five: procedure expose y; parse arg g
if length(g)>=5*length(y) then return g
return five(y||g)
                           /*───────────────────────────────────────────*/
y='something wicked this way comes.'
z=y||y||y||y||y||y||y||y||y||y||y||y|\y||y||y
z=left(z,5*length(y))
                           /*───────────────────────────────────────────*/
y='+'
z=copies('',5,y)
                           /*───────────────────────────────────────────*/
y='+'
z=lower('',1,5,y)
                           /*───────────────────────────────────────────*/
y='+'
z=lower('',,5,y)
                           /*───────────────────────────────────────────*/
z='+'
z=upper('',1,5,y)
                           /*───────────────────────────────────────────*/
z=upper('',,5,y)
                           /*───────────────────────────────────────────*/

y='charter bus.'
z='*****'
z=changestr('*',z,y)
                           /*───────────────────────────────────────────*/
y='what the hey!'
z=
  do until length(z)==5*length(y)
  z=z||y
  end
                           /*───────────────────────────────────────────*/
y='what the hey!'
z=
  do until length(z)==5*length(y)
  z=insert(z,0,y)
  end
                           /*───────────────────────────────────────────*/
y='yippie ki yay'
z=
   do i=1 by 5 for 5
   z=overlay(y,z,i)
   end
                           /*───────────────────────────────────────────*/
y='+'
z=justify('',5,y)
                           /*───────────────────────────────────────────*/
whatever_this_variable_is_____it_aint_referenced_directly= 'boy oh boy.'
z=; signal me; me:
  do 5
  z=z||strip(subword(sourceline(sigl-1),2),,"'")
  end
                           /*───────────────────────────────────────────*/
y="any more examples & the angry townfolk with pitchforks will burn the castle."
parse value y||y||y||y||y with z

exit                                   /*stick a fork in it, we're done.*/

Some older REXXes don't have a changestr bif, so one is included here ──► CHANGESTR.REX.

Ring

 Copy("ha" , 5)  # ==> "hahahahaha"

RPL

≪ "" 1 5 START "ha" + NEXT ≫ EVAL

Output:

1: "hahahahaha"

Ruby

"ha" * 5  # ==> "hahahahaha"

Run BASIC

a$ = "ha "
for i = 1 to 5
  a1$ = a1$ + a$
next i
a$ = a1$
print a$

Rust

std::iter::repeat("ha").take(5).collect::<String>(); // ==> "hahahahaha"

Since 1.16:

"ha".repeat(5); // ==> "hahahahaha"

Scala

"ha" * 5 // ==> "hahahahaha"

Scheme

(define (string-repeat n str)
  (apply string-append (vector->list (make-vector n str))))

with SRFI 1:

(define (string-repeat n str)
	(fold string-append "" (make-list n str)))
(string-repeat 5 "ha") ==> "hahahahaha"

To repeat a single character:

(make-string 5 #\*)

Scratch

This example requires making variables named "String", "Count", and "Repeated" first.

sed

Number of ampersands indicates number of repetitions.

$ echo ha | sed 's/.*/&&&&&/'
hahahahaha

Seed7

$ include "seed7_05.s7i";

const proc: main is func
  begin
    writeln("ha" mult 5);
  end func;

Output:

hahahahaha

SenseTalk

put "Ho!" repeated 3 times

put "Merry" repeated to length 12

Output:

Ho!Ho!Ho!
MerryMerryMe

Sidef

'ha' * 5;  # ==> 'hahahahaha'

Sinclair ZX81 BASIC

Works with 1k of RAM. This program defines a subroutine that expects to find a string and a number of times to repeat it; but all it then does is loop and concatenate, so making it a separate subroutine is arguably overkill.

 10 LET S$="HA"
 20 LET N=5
 30 GOSUB 60
 40 PRINT T$
 50 STOP
 60 LET T$=""
 70 FOR I=1 TO N
 80 LET T$=T$+S$
 90 NEXT I
100 RETURN

Smalltalk

If n is a small constant, then simply concatenating n times will do; for example, n=5::

v := 'ha'.
v,v,v,v,v

Works with: Pharo version 1.4

Works with: Smalltalk/X

By creating a collection of n 'ha', and joining them to a string:

((1 to: n) collect: [:x | 'ha']) joinUsing: ''.

or:

Works with: Smalltalk/X

Works with: VisualWorks Smalltalk

(Array new:n withAll:'ha') asStringWith:''.

By creating a WriteStream, and putting N times the string 'ha' into it:

ws := '' writeStream.
n timesRepeat: [ws nextPutAll: 'ha'].
ws contents.

alternatively:

(String streamContents:[:ws | n timesRepeat: [ws nextPutAll: 'ha']])

all evaluate to:

hahahahaha

A string containing a repeated character is generated with:

String new:n withAll:$*

Works with: VA Smalltalk

(String new:n) atAllPut:$*

SNOBOL4

	output = dupl("ha",5)
end

Sparkling

spn:3> repeat("na", 8) .. " Batman!"
= nananananananana Batman!

SQL

select rpad('', 10, 'ha')

SQL PL

Works with: Db2 LUW

VALUES REPEAT('ha', 5);
VALUES RPAD('', 10, 'ha');

Output:

db2 -t
db2 => VALUES REPEAT('ha', 5);

1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
hahahahaha                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      

  1 record(s) selected.

db2 => VALUES RPAD('', 10, 'ha');

1         
----------
hahahahaha

  1 record(s) selected.

Standard ML

fun string_repeat (s, n) =
  concat (List.tabulate (n, fn _ => s))
;

testing in the interpreter:

- string_repeat ("Hiuoa", 3) ;
val it = "HiuoaHiuoaHiuoa" : string

To repeat a single character:

fun char_repeat (c, n) =
  implode (List.tabulate (n, fn _ => c))
;

Stata

. scalar a="ha"
. scalar b=a*5
. display b
hahahahaha

Suneido

'ha'.Repeat(5)  -->  "hahahahaha"
'*'.Repeat(5)  -->  "*****"

Swift

The Builtin Way

print(String(repeating:"*", count: 5))

Output:

*****

Functions

func * (left:String, right:Int) -> String {
     return String(repeating:left, count:right)
}

print ("HA" * 5)

Output:

HAHAHAHAHA

Extensions

Using extensions to do the repetition which makes for an easier syntax when repeating Strings, and using String.extend() to get faster evaluation.

extension String {
  // Slower version
  func repeatString(n: Int) -> String {
    return Array(count: n, repeatedValue: self).joinWithSeparator("")
  }
  
  // Faster version
  // benchmarked with a 1000 characters and 100 repeats the fast version is approx 500 000 times faster :-)
  func repeatString2(n:Int) -> String {
    var result = self
    for _ in 1 ..< n {
      result.appendContentsOf(self)   // Note that String.appendContentsOf is up to 10 times faster than "result += self"
    }
    return result
  }
}

print( "ha".repeatString(5) )
print( "he".repeatString2(5) )

Output:

hahahahaha
hehehehehe

To repeat a single character:

String(count:5, repeatedValue:"*" as Character)

Note that using the String version on a string of 1 Character, or the repeat single Character version is timewise close to the same. No point in using the Character version for efficiency (tested with repeating up to 100 000 times).

Bitwise Iterative Version

The following version is an enhanced version of the recursive ActionScript, where we're using bit operation along with iterative doubling of the string to get to the correctly repeated version of the text in the most effective manner without recursion. When benchmarked against the plain iterative version in previous section, this version is marginally better, but only my a very small percentage. The critical factor for making the repeat function effective when using larger strings (1000 characters) and multiple repeats (1000 repeats :-) ) was to to exchange the '+=' with 'String.extend' method.

extension String {
  func repeatBiterative(count: Int) -> String {
        var reduceCount = count
        var result = ""
        var doubled = self
        while reduceCount != 0 {
            if reduceCount & 1 == 1 {
                result.appendContentsOf(doubled)
            }
            reduceCount >>= 1
            if reduceCount != 0 {
                doubled.appendContentsOf(doubled)
            }
        }
        return result
    }
} 

"He".repeatBiterative(5)

Output:

"HeHeHeHeHe"

Tailspin

'$:1..5 -> 'ha';' -> !OUT::write

Output:

hahahahaha

Tcl

string repeat "ha" 5  ;# => hahahahaha

TorqueScript

--Eepos

function strRep(%str,%int)
{
	for(%i = 0; %i < %int; %i++)
	{
		%rstr = %rstr@%str;
	}

	return %rstr;
}

Tosh

when flag clicked
set String to "meow"
set Count to 4
set Repeated to ""
repeat Count
	set Repeated to (join (Repeated) (String))
end
stop this script

Transact-SQL

select REPLICATE( 'ha', 5 )

TUSCRIPT

$$ MODE TUSCRIPT
repeatstring=REPEAT ("ha",5)

UNIX Shell

Using printf

Works with: bash

Works with: ksh93

Works with: zsh

printf "ha"%.0s {1..5}

With ksh93 and zsh, the count can vary.

Works with: ksh93

Works with: zsh

i=5
printf "ha"%.0s {1..$i}

With bash, {1..$i} fails, because brace expansion happens before variable substitution. The fix uses eval.

Works with: bash

Works with: ksh93

Works with: zsh

i=5
eval "printf 'ha'%.0s {1..$i}"

For the general case, one must escape any % or \ characters in the string, because printf would interpret those characters.

Works with: bash

Works with: ksh93

Works with: zsh

reprint() {
  typeset e="$(sed -e 's,%,%%,g' -e 's,\\,\\\\,g' <<<"$1")"
  eval 'printf "$e"%.0s '"{1..$2}"
}
reprint '%  ha  \' 5

Using repeat

Works with: zsh

Works with: csh

len=12; str='='
repeat $len printf "$str"

Using head -c

head -c is a GNU extension, so it only works with those systems. (Also, this script can only repeat a single character.)

Works with: Bourne Shell

width=72; char='='
head -c ${width} < /dev/zero | tr '\0' "$char"

Ursala

#import nat

repeat = ^|DlSL/~& iota

#cast %s

example = repeat('ha',5)

output:

'hahahahaha'

Vala

Repeat a string 5 times:

string s = "ha";
string copy = "";
for (int x = 0; x < 5; x++)
	copy += s;

Fill a string with a char N times:

string s = string.nfill(5, 'c');

VBA

Repeat a string

Public Function RepeatStr(aString As String, aNumber As Integer) As String
	Dim bString As String, i As Integer
	bString = ""
	For i = 1 To aNumber
		bString = bString & aString
	Next i
	RepeatStr = bString
End Function

Debug.Print RepeatStr("ha", 5)

Output:

hahahahaha

Note: "String(5, "ha") in VBA produces "hhhhh" (only the first character is repeated)!

An alternative method:

Public Function RepeatString(stText As String, iQty As Integer) As String
  RepeatString = Replace(String(iQty, "x"), "x", stText)
End Function

Repeat a character

Debug.Print String(5, "x")

Output:

xxxxx

VBScript

Works with: Windows Script Host version *

' VBScript has a String() function that can repeat a character a given number of times
' but this only works with single characters (or the 1st char of a string):
WScript.Echo String(10, "123")	' Displays "1111111111"

' To repeat a string of chars, you can use either of the following "hacks"...
WScript.Echo Replace(Space(10), " ", "Ha")
WScript.Echo Replace(String(10, "X"), "X", "Ha")

Vedit macro language

Ins_Text("ha", COUNT, 5)

Visual Basic

Works with: Visual Basic version VB6 Standard

Repeat a string

Public Function StrRepeat(s As String, n As Integer) As String
	Dim r As String, i As Integer
	r = ""
	For i = 1 To n
		r = r & s
	Next i
	StrRepeat = r
End Function
 
Debug.Print StrRepeat("ha", 5)

Output:

hahahahaha

An alternative method:

Public Function StrRepeat(sText As String, n As Integer) As String
	StrRepeat = Replace(String(n, "*"), "*", sText)
End Function

Repeat a character

Debug.Print String(5, "x")

Output:

xxxxx

Visual Basic .NET

Repeat a string

Debug.Print(Replace(Space(5), " ", "Ha"))

Output:

HaHaHaHaHa

Repeat a character

Debug.Print(StrDup(5, "x"))
Debug.Print("".PadRight(5, "x"))
Debug.Print("".PadLeft(5, "x"))

Output:

xxxxx
xxxxx
xxxxx

Visual FoxPro

Use the built in function REPLICATE(string, number):

? REPLICATE("HO", 3)

produces

HOHOHO

V (Vlang)

println('ha'.repeat(5))

Output

hahahahaha

VBScript

replace(string(5,"@"),"@","hello")

Output:

hellohellohellohellohello

Wart

def (s * n) :case (string? s)
  with outstring
    repeat n
      pr s

("ha" * 5)
=> "hahahahaha"

Wortel

@join "" @rep 5 "ha" ; returns "hahahahaha"

As a function:

^(\@join "" @rep)

Wren

System.print("ha" * 5)

Output:

hahahahaha

XPL0

cod T=12; int I; for I gets 1,5 do T(0,"ha")

Output:

hahahahaha

Yorick

array("ha", 5)(sum)

Z80 Assembly

PrintChar equ &BB5A ;Amstrad CPC BIOS call, prints the ascii code in the accumulator to the screen.

org &8000
ld b,5                 ; repeat 5 times

loop:
call PrintImmediate
byte "ha",0
djnz loop

ret                    ; return to basic
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
PrintImmediate:
pop hl                 ; get the return address into HL, it's the start of the embedded string.
call PrintString
; inc hl               ; if your strings are null-terminated you can omit this, since a 0 equals the "NOP" instruction
jp (hl)                ; acts as a ret, returning execution to the instruction just after the embedded string.

PrintString:
ld a,(hl)              ; read in a character from the string
or a                   ; if your strings are null-terminated you can use this as a shortcut, otherwise use the compare instruction
ret z                  ; exit once the terminator is reached.
call PrintChar         ; BIOS call, all regs are preserved.
inc hl                 ; next char
jr PrintString         ; back to start.

Output:

hahahahaha

zig

At compile-time:

const laugh = "ha" ** 5;

Note that to achieve this at run-time in zig (in order to avoid hidden overflows) you must manage the memory yourself.

const std = @import("std");
const warn = std.debug.warn;

const Allocator = std.mem.Allocator;

fn repeat(s: []const u8, times: u16, allocator: *Allocator) ![]u8 {
    const repeated = try allocator.alloc(u8, s.len*times);

    var i: usize = 0;
    while (i < s.len*times) : (i += 1) {
        repeated[i] = s[i % 2];
    }

    return repeated;
}

pub fn main() !void {
    const allocator = std.debug.global_allocator;
    const ex = try repeat("ha", 5, allocator);
    defer allocator.free(ex);
}

zkl

Same as Ruby

"ha" * 5  # --> "hahahahaha"