I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Repeat a string

(Redirected from Repeating a string)
Repeat a string
You are encouraged to solve this task according to the task description, using any language you may know.

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

## 11l

`print(‘ha’ * 5)`
Output:
```hahahahaha
```

## 360 Assembly

`*        Repeat a string           - 19/04/2020REPEATS  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 saveREPEAT   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 returnLOOP     EX     R7,MVCX            move a to b len R6         AR     R2,R6              @b+=l         BCT    R8,LOOP            loop i timesRET      LM     R2,R8,REPEATSA     restore registers         BR     R14                returnPARMLST  DC     A(PG,CX,II)        parmlistREPEATSA DS     7F                 local saveareaMVCX     MVC    0(0,R2),0(R3)      move @ R3 to @ R2C24      DC     6C'xyz '           constant repeat - repeat('xyz ',6)LCX      DC     AL2(L'CX)          lengh(cc)CX       DC     CL4'abc '          cxII       DC     F'6'               iiPG       DC     CL80' '            pg         REGEQU         END    REPEATS `
Output:
```xyz xyz xyz xyz xyz xyz
abc abc abc abc abc abc
```

## 4DOS Batch

`gosub repeat ha 5echo %@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.

SEARCHING FOR *
RUN
HAHAHAHAHA
```

## 68000 Assembly

Easiest way to do this is with a loop.

`MOVE.W #5-1,D1RepString:LEA A3, MyStringMOVE.L A3,-(SP) ;PUSH A3JSR PrintString ;unimplemented hardware-dependent printing routine, assumed to not clobber D1MOVE.L (SP)+,A3 ;POP A3DBRA D1,RepStringRTS             ;return to basic or whatever MyString:DC.B "ha",0even`

## 8th

`"ha" 5 s:*. cr`

Output shows:

`hahahahaha`

## 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
```

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 isbegin   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 & strend 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 -> Stringon 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 & dblend replicate`

## Applesoft BASIC

`FOR I = 1 TO 5 : S\$ = S\$ + "HA" : NEXT ? "X" SPC(20) "X"`

Output:

`X                    X`

## 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"DONEPRINT 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`

### 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`

### 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`

### 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 offif "%2" equ "" goto failsetlocal enabledelayedexpansionset char=%1set num=%2for /l %%i in (1,1,%num%) do set res=!res!%char%echo %res%:fail`

'Function' version

`@echo offset /p a=Enter string to repeat :set /p b=Enter how many times to repeat :set "c=1"set "d=%b%":aecho %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<}~< [email protected]<[email protected]~>[email protected]'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.

## Befunge

`v>                ">:#,_v>29*+00p>~:"0"-    #v_v \$ v      ^p0p00:-1g00< \$            > v    p00&p0-1g00+4*65< >00g1-:00p#^[email protected]`

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 "[email protected]{~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`

## 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`

## 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);`

## 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 4.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 FOREND 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 forputs(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 displayinclude std/sequence.e -- for repeat_patternsequence 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 displayinclude std/sequence.e -- for flattensequence 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-npad count type    \ hahahahaha`

The same code without the use of locals:

` : place-n ( src len dest n -- )  swap >r 0 [email protected] c!  begin dup while -rot 2dup [email protected] +place rot 1- repeat  r> 2drop 2drop ; s" ha" pad 5 place-npad count type    \ hahahahaha`

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

`pad 10 char * fill   \ repeat a single characterpad 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 bufferEnd Function  Print repeat("rosetta", 1)Print repeat("ha", 5)Print repeat("*", 5)PrintPrint "Press any key to quit program"Sleep`
Output:
```rosetta
hahahahaha
*****
```

## Frink

` println[repeat["ha", 5]] `

## Gambas

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

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 -> StringrepString 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 -> StringrepString 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 nsend`

## Idris

`strRepeat : Nat -> String -> StringstrRepeat Z s = ""strRepeat (S n) s = s ++ strRepeat n s chrRepeat : Nat -> Char -> StringchrRepeat 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.`

## IS-BASIC

` 10 PRINT STRING\$("ha",5)100 DEF STRING\$(S\$,N)105   LET ST\$=""110   FOR I=1 TO N120     LET ST\$=ST\$&S\$130   NEXT140   LET STRING\$=ST\$150 END DEF`

## J

`   5 # '*'               NB. repeat each item 5 times*****   5 # 'ha'              NB. repeat each item 5 timeshhhhhaaaaa   5 ((* #) \$ ]) 'ha'    NB. repeat array 5 timeshahahahaha   5 ;@# < 'ha'          NB. using boxing to treat the array as a wholehahahahaha`

## Java

Works with: Java version 1.5+

There's no method or operator to do this in Java, so you have 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`

## jq

`"a " * 3' # => "a a a "`

Note that if the integer multiplicand is 0, then the result is 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.

## 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 `

## langur

This example looks like Perl, but the x operator doesn't just multiply strings in langur.

`"ha" x 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 resend`
`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 tend repeatString`

## Logo

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

`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

`(* solution 1 *)rep[n_Integer,s_String]:=Apply[StringJoin,ConstantArray[s,{n}]](* solution 2 -- @@ is the infix form of Apply[] *)rep[n_Integer,s_String]:[email protected]@Table[s,{n}](* solution 3 -- demonstrating another of the large number of looping constructs available *)rep[n_Integer,s_String]:=Nest[StringJoin[s, #] &,s,n-1]`

## 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 " * 5traceln(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 QUITRPTSTR1(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 duplicatesay '   COPIES:' sampleStr.copies(5)say 'CHANGESTR:' '.....'.changestr('.', sampleStr) sampleChr = '*' -- character to duplicatesay '     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)`

## Nim

`import strutils # Repeat a char.echo repeat('a', 5)     # -> "aaaaa". # Repeat a string.echo repeat("ha", 5)    # -> "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)`

## 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  nextend 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  endin  {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 aevsrepeat(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);} {\\ TESTSprint(" *** 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.

## 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     nipenddef "ha" 5 rep print`

Same result (simple character):

`65 5 rep65 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 * 5print(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 charshowmessage String\$(10, "-") 'For strings with more than one charfunction Repeat\$(Expr as string, Count as integer) as string    dim x as integer    for x = 1 to Count        Result = Result + Expr    nextend 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 outputEnd 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 gif length(g)>=5*length(y) then return greturn five(y||g)                           /*───────────────────────────────────────────*/y='something wicked this way comes.'z=y||y||y||y||y||y||y||y||y||y||y||y|\y||y||yz=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"`

## Ruby

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

## Run BASIC

`a\$ = "ha "for i = 1 to 5  a1\$ = a1\$ + a\$next ia\$ = 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 I100 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
`(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 bhahahahaha`

## 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 = %[email protected]%str;	} 	return %rstr;}`

## Tosh

`when flag clickedset String to "meow"set Count to 4set Repeated to ""repeat Count	set Repeated to (join (Repeated) (String))endstop this script`

## Transact-SQL

`select REPLICATE( 'ha', 5 )`

## TUSCRIPT

` \$\$ MODE TUSCRIPTrepeatstring=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=5printf "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=5eval "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" `

`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 = bStringEnd 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 = rEnd 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`

## Vlang

`// Repeat a string, in V// Tectonics: v run repeat-a-string.vmodule mainimport strings // starts herepub fn main() {    // A strings module function to repeat strings    println(strings.repeat_string("ha", 5))     // Another strings module function to repeat a byte    // This indexes the string to get the first byte of the rune array    println(strings.repeat("*"[0], 5))}`
Output:
```prompt\$ v run rosetta/repeat-a-string.v
hahahahaha
*****```

## 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 &8000ld b,5                 ; repeat 5 times loop:call PrintImmediatebyte "ha",0djnz 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" instructionjp (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 stringor a                   ; if your strings are null-terminated you can use this as a shortcut, otherwise use the compare instructionret z                  ; exit once the terminator is reached.call PrintChar         ; BIOS call, all regs are preserved.inc hl                 ; next charjr 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"`