Repeat a string

From Rosetta Code
Task
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) => "*****").


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

<lang 11l>print(‘ha’ * 5)</lang>

Output:
hahahahaha

360 Assembly

<lang 360asm>* 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 </lang>
Output:
xyz xyz xyz xyz xyz xyz
abc abc abc abc abc abc

4DOS Batch

<lang 4dos>gosub repeat ha 5 echo %@repeat[*,5] quit

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

return</lang> Output shows: 

hahahahaha
*****

6502 Assembly

<lang 6502asm>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</lang>

Output:
READY.
LOAD"*",8,1:

SEARCHING FOR *
LOADING
READY.
RUN
HAHAHAHAHA
READY.


8th

<lang forth>"ha" 5 s:* . cr</lang> Output shows: 

hahahahaha

ABAP

This works for ABAP Version 7.40 and above

<lang ABAP> report z_repeat_string.

write repeat( val = `ha` occ = 5 ). </lang>

Output:
hahahahaha

Action!

<lang Action!>Proc Main() 

byte REPEAT

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

Return</lang>

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

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

Recursive version

The following double-and-add method is much faster when repeating a string many times. <lang ActionScript>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; }</lang>

Flex

<lang ActionScript>import mx.utils.StringUtil; trace(StringUtil.repeat("ha", 5)); </lang> Sample Output: 

hahahahaha

Ada

In Ada multiplication of an universal integer to string gives the desired result. Here is an example of use: <lang Ada>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;</lang> Sample output: 

hahahahaha

Aime

<lang aime>call_n(5, o_text, "ha");</lang>

ALGOL 68

<lang algol68>print (5 * "ha") </lang>

Amazing Hopper

<lang Amazing Hopper>

  1. !/usr/bin/hopper
  2. include <hopper.h>

main: 

 {"ha"}replyby(5),    println
 {"ha",5}replicate,   println

{0}return </lang> 

hahahahaha
hahahahaha

APL

Fill up a string of length 10 with 'ha': <lang apl> 10⍴'ha' hahahahaha</lang> Alternatively, define a function: <lang apl> REPEAT←{(⍺×⍴⍵)⍴⍵} 

     5 REPEAT 'ha'

hahahahaha</lang>

AppleScript

<lang AppleScript>set str to "ha" set final_string to "" repeat 5 times 

   set final_string to final_string & str

end repeat</lang>


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

<lang AppleScript>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</lang>

Applesoft BASIC

<lang ApplesoftBasic>FOR I = 1 TO 5 : S$ = S$ + "HA" : NEXT

? "X" SPC(20) "X"</lang> Output: 

X                    X

Arturo

<lang rebol>print repeat "ha" 5</lang>

Output:
hahahahaha

AutoHotkey

<lang AutoHotkey>MsgBox % Repeat("ha",5)

Repeat(String,Times) { 

 Loop, %Times%
   Output .= String
 Return Output

}</lang>

AutoIt

<lang AutoIt>#include <String.au3>

ConsoleWrite(_StringRepeat("ha", 5) & @CRLF)</lang>

AWK

<lang awk>function repeat( str, n, rep, i ) { 

   for( ; i<n; i++ )
       rep = rep str   
   return rep

}

BEGIN { 

   print repeat( "ha", 5 )

}</lang>

Babel

<lang babel>main: { "ha" 5 print_repeat }

print_repeat!: { <- { dup << } -> times }</lang> Outputs: <lang babel>hahahahaha</lang> 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: <lang qbasic>DOTIMES 5 

   s$ = s$ & "ha"

DONE PRINT s$</lang>

Output:
hahahahaha

To repeat one single character: <lang qbasic>PRINT FILL$(5, ASC("x"))</lang>

Output:
xxxxx


BASIC

BASIC256

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

QBasic

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

True BASIC

<lang qbasic>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</lang>

Yabasic

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


Batch File

Commandline implementation <lang dos>@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</lang>

'Function' version <lang dos>@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</lang>

'Function' version 2 <lang dos>@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</lang>

BBC BASIC

<lang bbcbasic> PRINT STRING$(5, "ha")</lang>

beeswax

<lang beeswax> p < 

     p0~1<}~< d@<

_VT@1~>yg~9PKd@M'd;</lang>


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

<lang Befunge>v> ">:#,_v >29*+00p>~:"0"- #v_v $ 

v      ^p0p00:-1g00< $            >
v    p00&p0-1g00+4*65< >00g1-:00p#^_@</lang>

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.

<lang bqn>Repeat ← ×⟜≠ ⥊ ⊢

•Show 5 Repeat "Hello"</lang><lang>"HelloHelloHelloHelloHello"</lang>

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.

<lang bracmat>(repeat= 

 string N rep

. !arg:(?string.?N) 

 & !string:?rep
 &   whl
   ' (!N+-1:>0:?N&!string !rep:?rep)
 & str$!rep

);</lang> 

 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. <lang bf>+++++ +++++ 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 +++++ +++++ +++ . --- .</lang>

Brat

<lang brat>p "ha" * 5 #Prints "hahahahaha"</lang>

Burlesque

<lang burlesque> blsq ) 'h5?* "hhhhh" blsq ) "ha"5.*\[ "hahahahaha" </lang>

C

<lang c>#include <stdio.h>

  1. include <stdlib.h>
  2. 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;

}</lang> A variation. <lang c>... 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;

}</lang>

To repeat a single character <lang c>#include <stdio.h>

  1. include <stdlib.h>
  2. 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;

}</lang>

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

C#

<lang csharp>string s = "".PadLeft(5, 'X').Replace("X", "ha");</lang> or (with .NET 2+) <lang csharp>string s = new String('X', 5).Replace("X", "ha");</lang> or (with .NET 2+) <lang csharp>string s = String.Join("ha", new string[5 + 1]);</lang> or (with .NET 4+) <lang csharp>string s = String.Concat(Enumerable.Repeat("ha", 5));</lang>

To repeat a single character: <lang csharp>string s = "".PadLeft(5, '*');</lang> or (with .NET 2+) <lang csharp>string s = new String('*', 5);</lang>

C++

<lang cpp>#include <string>

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

}</lang>

To repeat a single character: <lang cpp>#include <string>

  1. include <iostream>

int main( ) { 

  std::cout << std::string( 5, '*' ) << std::endl ;
  return 0 ;

}</lang>

recursive version

<lang cpp>#include <string>

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

}</lang>

Ceylon

<lang ceylon>shared void repeatAString() { print("ha".repeat(5)); }</lang>

Clipper

Also works with Harbour Project compiler Harbour 3.0.0 (Rev. 16951) <lang visualfoxpro> Replicate( "Ha", 5 )</lang>

Clojure

<lang lisp>(apply str (repeat 5 "ha"))</lang>

COBOL

Virtually a one-liner. <lang cobol>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.</lang>
Output:
hahahahaha

ColdFusion

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

Common Lisp

<lang lisp>(defun repeat-string (n string) 

 (with-output-to-string (stream)
   (loop repeat n do (write-string string stream))))</lang>

A version which allocates the result string in one step:

<lang lisp>(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)</lang>


For those who love one-liners, even at the expense of readability: <lang lisp>(defun repeat-string (n string) 

 (format nil "~V@{~a~:*~}" n string))</lang>


<lang lisp>(princ (repeat-string 5 "hi"))</lang>


A single character may be repeated using just the builtin make-string: <lang lisp>(make-string 5 :initial-element #\X)</lang> produces “XXXXX”.

Crystal

<lang Ruby> puts "ha" * 5 </lang> 

hahahahaha

D

Repeating a string: <lang d>import std.stdio, std.array;

void main() { 

   writeln("ha".replicate(5));

}</lang> Repeating a character with vector operations: <lang d>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);

}</lang>

DCL

Not exactly what the task asks for but at least it is something; <lang DCL>$ write sys$output f$fao( "!AS!-!AS!-!AS!-!AS!-!AS", "ha" ) $ write sys$output f$fao( "!12*d" )</lang>

Output:
$ @repeat_a_string_and_then_character
hahahahaha
dddddddddddd

Delphi

Repeat a string <lang Delphi> 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)); </lang>

Repeat a character

<lang Delphi> Writeln( StringOfChar('a',5) ); </lang>

Using recursion

<lang Delphi> function RepeatStr(const s: string; i: Cardinal): string; begin 

 if i = 0 then
   result := 
 else
  result := s + RepeatStr(s, i-1)

end; </lang>

Built in RTL function:

<lang Delphi>StrUtils.DupeString</lang>

DWScript

Repeat a string

<lang Delphi> PrintLn( StringOfString('abc',5) ); </lang>

Repeat a character

<lang Delphi> PrintLn( StringOfChar('a',5) ); </lang>

Dyalect

<lang dyalect>String.Repeat("ha", 5)</lang>

Déjà Vu

<lang dejavu>!. concat( rep 5 "ha" )</lang>

Output:
"hahahahaha"

E

<lang e>"ha" * 5</lang>

ECL

After version 4.2.2 <lang>IMPORT STD; //Imports the Standard Library

STRING MyBaseString := 'abc'; RepeatedString := STD.Str.Repeat(MyBaseString,3); RepeatedString; //returns 'abcabcabc'</lang>

Before version 4.2.2 <lang>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);</lang>

Egison

<lang egison> (S.concat (take 5 (repeat1 "ha"))) </lang>

Eiffel

<lang eiffel> 

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

</lang>

Elena

ELENA 4.x : <lang elena>import system'routines; import extensions; import extensions'text;

public program() { 

   var s := new Range(0, 5).selectBy:(x => "ha").summarize(new StringWriter())

}</lang>

Elixir

<lang elixir> String.duplicate("ha", 5) </lang>

Emacs Lisp

Going via a list to repeat the desired string:

<lang lisp>(apply 'concat (make-list 5 "ha"))</lang>

A single character can be repeated with make-string:

<lang lisp>(make-string 5 ?x)</lang>

The cl-loop macro can repeat and concatenate:

Library: cl-lib

<lang lisp>(require 'cl-lib) (cl-loop repeat 5 concat "ha")</lang>

Erlang

<lang erlang>repeat(X,N) -> 

   lists:flatten(lists:duplicate(N,X)).</lang>

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

ERRE

<lang ERRE> PROCEDURE REPEAT_STRING(S$,N%->REP$) 

  LOCAL I%
  REP$=""
  FOR I%=1 TO N% DO
      REP$=REP$+S$
  END FOR

END PROCEDURE </lang> 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: <lang Euphoria> sequence s = "" for i = 1 to 5 do s &= "ha" end for puts(1,s)

hahahahaha </lang>

For repeating a single character: <lang Euphoria> sequence s = repeat('*',5)

</lang>

For repeating a string or sequence of numbers: <lang Euphoria> 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} </lang>

But wait, here's another way: <lang Euphoria> include std/console.e -- for display include std/sequence.e -- for flatten sequence s = flatten(repeat("ha",5)) display(s) </lang>

note: repeat creates a sequence of ha's as shown below; flatten concatenates them. <lang Euphoria> { 

"ha",
"ha",
"ha",
"ha",
"ha"

} </lang>

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#

<lang fsharp>> String.replicate 5 "ha";; val it : string = "hahahahaha"</lang> Or <lang fsharp>> String.Concat( Array.create 5 "ha" );; val it : string = "hahahahaha"</lang>

Factor

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

"ha" 5 repeat-string print</lang>

Forth

<lang 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</lang> The same code without the use of locals: <lang forth>

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</lang> Filling a string with a single character is supported by ANS-Forth: <lang forth>pad 10 char * fill \ repeat a single character pad 10 type \ **********</lang>

Fortran

Works with: Fortran version 90 and later

<lang fortran>program test_repeat 

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

end program test_repeat</lang> Output: 

hahahahaha

Free Pascal

<lang pascal>strUtils.dupeString('ha', 5)</lang> Repetition of a single character: <lang pascal>stringOfChar('*', 5)</lang> If the repeated character happens to be the space character: <lang pascal>space(5)</lang>

FreeBASIC

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

Output:
rosetta
hahahahaha
*****

Frink

<lang frink> println[repeat["ha", 5]] </lang>

Gambas

Click this link to run this code <lang>Public Sub Main()

Print String$(5, "ha")

End</lang>

Output = hahahahaha

GAP

<lang gap>Concatenation(ListWithIdenticalEntries(10, "BOB ")); "BOB BOB BOB BOB BOB BOB BOB BOB BOB BOB "</lang>

Glee

<lang glee>'*' %% 5</lang>

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

<lang glee>'ha'=>S[1..(S#)%%(S# *5)]</lang>

Go

<lang go>fmt.Println(strings.Repeat("ha", 5)) // ==> "hahahahaha"</lang> There is no special way to repeat a single character, other than to convert the character to a string. The following works: <lang go>fmt.Println(strings.Repeat(string('h'), 5)) // prints hhhhh</lang>

Groovy

<lang groovy> println 'ha' * 5</lang>

Harbour

<lang visualfoxpro>? Replicate( "Ha", 5 )</lang>

Haskell

For a string of finite length: <lang haskell>concat $ replicate 5 "ha"</lang>

Or with list-monad (a bit obscure): <lang haskell>[1..5] >> "ha"</lang>

Or with Control.Applicative: <lang haskell>[1..5] *> "ha"</lang>

For an infinitely long string: <lang haskell>cycle "ha"</lang>

To repeat a single character: <lang haskell>replicate 5 '*'</lang>

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: <lang haskell>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</lang>

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

<lang haskell>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"</lang>

HicEst

<lang HicEst>CHARACTER out*20

EDIT(Text=out, Insert="ha", DO=5)</lang>

Icon and Unicon

The procedure repl is a supplied function in Icon and Unicon. <lang Icon>procedure main(args) 

   write(repl(integer(!args) | 5))

end</lang> If it weren't, one way to write it is: <lang Icon>procedure repl(s, n) 

   every (ns := "") ||:= |s\(0 <= n)
   return ns

end</lang>

Idris

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

Inform 7

<lang inform7>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.</lang>

IS-BASIC

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

J

<lang 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. boxing is used to treat the array as a whole

hahahahaha</lang>

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.

<lang java5>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));

}</lang>

Or even shorter:

<lang java5>public static String repeat(String str, int times) { 

  return new String(new char[times]).replace("\0", str);

}</lang>

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. <lang javascript>String.prototype.repeat = function(n) { 

   return new Array(1 + (n || 0)).join(this);

}

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

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

<lang javascript> console.log("ha".repeat(5)); // hahahahaha</lang>

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.

<lang javascript>(() => { 

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

})();</lang>

Concat . replicate

Or, more generically, we could derive repeat as the composition of concat and replicate <lang JavaScript>(() => { 

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

})();</lang>

Output:
hahahahaha

jq

<lang jq>"a " * 3' # => "a a a "</lang>

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

Julia

Works with: Julia version 1.0

<lang julia>@show "ha" ^ 5

  1. The ^ operator is really just call to the `repeat` function

@show repeat("ha", 5)</lang>

K

<lang k> 

 ,/5#,"ha"

"hahahahaha" 

 5#"*"

"*****" </lang>

Kotlin

<lang scala>fun main(args: Array<String>) { 

   println("ha".repeat(5))

}</lang> Or more fancy: <lang scala>operator fun String.times(n: Int) = this.repeat(n)

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

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

<lang scheme> {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>

langur

This example looks like Perl, but the x operator doesn't just multiply strings in langur. <lang langur>"ha" x 5</lang>

Lasso

<lang Lasso>'ha'*5 // hahahahaha</lang>

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

LFE

<lang lisp> (string:copies '"ha" 5) </lang>

Liberty BASIC

<lang lb>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</lang>

Lingo

  • Take a string and repeat it some number of times.

<lang lingo>on rep (str, n) 

 res = ""
 repeat with i = 1 to n
   put str after res
 end repeat
 return res

end</lang> <lang lingo>put rep("ha", 5) -- "hahahahaha"</lang>

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

<lang lingo>put bytearray(5, chartonum("*")).readRawString(5) -- "*****"</lang>

LiveCode

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

<lang logo>to copies :n :thing [:acc "||] 

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

end</lang> or using cascade: <lang logo>show cascade 5 [combine "ha ?] "||  ; hahahahaha</lang>

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

<lang logo>to copies :n :thing :acc 

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

end

print copies 5 "ha "||</lang>

Lua

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

Or use native string library function <lang lua>string.rep(s,n)</lang>

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. <lang Maple> > use StringTools in > Repeat( "abc", 10 ); # repeat an arbitrary string > Fill( "x", 20 ) # repeat a character > end use; 

                   "abcabcabcabcabcabcabcabcabcabc"

                        "xxxxxxxxxxxxxxxxxxxx"

</lang> 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. <lang Maple> > cat( "abc" $ 10 ); 

                   "abcabcabcabcabcabcabcabcabcabc"

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

                   "abcabcabcabcabcabcabcabcabcabc"

</lang> You can build up a string in a loop, but this is highly inefficient (quadratic); don't do this. <lang Maple> > s := "": > to 10 do s := cat( s, "abc" ) end: s; 

                   "abcabcabcabcabcabcabcabcabcabc"

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

<lang Mathematica>(* 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]:=StringJoin@@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]</lang>

MATLAB / Octave

<lang MATLAB>function S = repeat(s , n) 

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

return</lang>

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

Maxima

<lang maxima>"$*"(s, n) := apply(sconcat, makelist(s, n))$ infix("$*")$

"abc" $* 5; /* "abcabcabcabcabc" */</lang>

Mercury

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

<lang Mercury>:- 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 ).</lang>

min

Works with: min version 0.19.3

<lang min>"ha" 5 repeat print</lang>

Output:
hahahahaha

MiniScript

<lang MiniScript>str = "Lol" print str * 5</lang>

Output:
LolLolLolLolLol

Mirah

<lang mirah>x = StringBuilder.new

5.times do 

   x.append "ha"

end

puts x # ==> "hahahahaha"</lang>

Monte

<lang Monte> var s := "ha " * 5 traceln(s) </lang>

MontiLang

<lang MontiLang>|ha| 5 * PRINT .</lang> Or with a loop <lang MontiLang>FOR 5 

   |ha| OUT .

ENDFOR || PRINT .</lang>

Or ...

<lang MontiLang>|ha| FOR 5 OUT ENDFOR . || PRINT .</lang>

MUMPS

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

</lang>


This last example uses the $PIECE function. <lang MUMPS> 

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

</lang>

Nanoquery

In Nanoquery, multiplying strings by an integer returns a new string with the original value repeated. <lang Nanoquery>"ha" * 5</lang>

Neko

<lang actionscript>/* 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")</lang>

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). <lang Nemerle>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

   }

}</lang>

NetRexx

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

ha5 = 'ha'.copies(5) </lang>

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

<lang NetRexx>/* 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, '.') </lang>

NewLISP

<lang NewLISP>(dup "ha" 5)</lang>

Nim

<lang nim>import strutils

  1. Repeat a char.

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

  1. Repeat a string.

echo repeat("ha", 5) # -> "hahahahaha".</lang>

Objeck

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

}</lang>

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.

<lang objc>@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</lang>

Now, let's put it to use: <lang objc> // Instantiate an NSString by sending an NSString literal our new 

   // -repeatByNumberOfTimes: selector.
   NSString *aString = [@"ha" repeatStringByNumberOfTimes:5];

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

OCaml

Since Ocaml 4.02 strings are immutable, as is convenient for a functional language. Mutable strings are now implemented in the module Bytes. <lang ocaml>let string_repeat s n = 

 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 (* not stricly necessary, the bytes type is equivalent to string except mutability *)
</lang>

which gives the signature<lang ocaml> val string_repeat : bytes -> int -> string = <fun></lang>

testing in the toplevel: <lang ocaml># string_repeat "Hiuoa" 3 ;; - : string = "HiuoaHiuoaHiuoa"</lang>

Alternately create an array initialized to s, and concat: <lang ocaml>let string_repeat s n = 

 String.concat "" (Array.to_list (Array.make n s))
</lang>

Or: <lang ocaml>let string_repeat s n = 

 Array.fold_left (^) "" (Array.make n s)
</lang>

To repeat a single character use: <lang ocaml>String.make 5 '*'</lang>

Oforth

<lang Oforth>StringBuffer new "abcd" <<n(5)</lang>

OpenEdge/Progress

<lang Progress (OpenEdge ABL)>MESSAGE FILL( "ha", 5 ) VIEW-AS ALERT-BOX.</lang>

OxygenBasic

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

Oz

We have to write a function for this: <lang oz>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}}</lang>

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. <lang parigp>repeat(s,n)={ 

 if(n, Str(repeat(s, n-1), s), "")

};</lang>

concat() joins together a vector of strings, in this case a single string repeated. <lang parigp>repeat(s,n)=concat(vector(n,i, s));</lang>

This solution is recursive and slightly less bad than the others for large n. <lang parigp>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)
 );

}</lang>

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.

<lang parigp> \\ 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)); } </lang>

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

<lang perl>"ha" x 5</lang>

Phix

?repeat('*',5)
?join(repeat("ha",5),"")
Output:
"*****"
"hahahahaha"

Phixmonti

<lang Phixmonti>def rep /# s n -- s #/ 

    "" swap
    for drop

over chain 

    endfor
    nip

enddef

"ha" 5 rep print</lang> Same result (simple character): <lang Phixmonti>65 5 rep 65 5 repeat 'A' 5 repeat</lang>

PHP

<lang php>str_repeat("ha", 5)</lang>

PicoLisp

<lang PicoLisp>(pack (need 5 "ha")) -> "hahahahaha"</lang> or: <lang PicoLisp>(pack (make (do 5 (link "ha")))) -> "hahahahaha"</lang>

Pike

<lang pike>"ha"*5;</lang>

PL/I

<lang 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. */ </lang>

Plain English

<lang plainenglish>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.</lang>

Output:
hahahahaha
*****

Plorth

<lang plorth>"ha" 5 *</lang>

PostScript

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

PowerBASIC

<lang powerbasic>MSGBOX REPEAT$(5, "ha")</lang>

PowerShell

<lang powershell>"ha" * 5 # ==> "hahahahaha"</lang>

Processing

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

}</lang>

Processing Python mode

<lang python>def setup(): 

   rep = repeat("ha", 5)
   println(rep)

def repeat(s, times): 

   return s * times</lang>

Prolog

<lang 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).</lang>

alternative using DCG strings

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

Works with: SWI-Prolog version 7

<lang prolog>

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

</lang>

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.

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

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

<lang pure> str_repeat n::int s::string = string $ take n $ cycle (s:[]); </lang>

PureBasic

<lang PureBasic>Procedure.s RepeatString(count, text$=" ") 

  Protected i, ret$=""

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

EndProcedure

Debug RepeatString(5, "ha")</lang>

Python

<lang python>"ha" * 5 # ==> "hahahahaha"</lang> "Characters" are just strings of length one.

the other way also works: <lang python>5 * "ha" # ==> "hahahahaha"</lang>

Using a Function

<lang python>def repeat(s, times): 

   return s * times

print(repeat("ha", 5))</lang>

Output:
hahahahaha

Using Lambda

<lang python>x = lambda a: a * 5 print(x("ha"))</lang>

Output:
hahahahaha

Quackery

<lang Quackery>$ "ha" 5 of echo$</lang> Output: 

hahahahaha

R

<lang ruby>strrep("ha", 5)</lang>

Racket

<lang racket>

  1. lang racket
fast

(define (string-repeat n str) 

 (string-append* (make-list n str)))

(string-repeat 5 "ha") ; => "hahahahaha" </lang>

To repeat a single character: <lang racket> (make-string 5 #\*) => "*****" </lang>

Raku

(formerly Perl 6) <lang perl6>print "ha" x 5</lang> (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

<lang vb> '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) </lang>

REALbasic

<lang vb>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 </lang>

REBOL

<lang rebol>head insert/dup "" "ha" 5</lang>

Red

<lang 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"</lang>

ReScript

<lang ReScript>Js.log(Js.String2.repeat("ha", 5))</lang>

Retro

<lang Retro>with strings'

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

"ha" 5 repeatString</lang>

REXX

Since the REXX language only supports the "character" type, it's not surprising that there are so many ways to skin a cat. <lang REXX>/*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.*/</lang> Some older REXXes don't have a changestr bif, so one is included here ──► CHANGESTR.REX.

Ring

<lang ring> Copy("ha" , 5) # ==> "hahahahaha"</lang>

Ruby

<lang ruby>"ha" * 5 # ==> "hahahahaha"</lang>

Run BASIC

<lang runbasic>a$ = "ha " for i = 1 to 5 

 a1$ = a1$ + a$

next i a$ = a1$ print a$</lang>

Rust

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

Since 1.16: <lang rust>"ha".repeat(5); // ==> "hahahahaha"</lang>

Scala

<lang scala>"ha" * 5 // ==> "hahahahaha"</lang>

Scheme

<lang scheme>(define (string-repeat n str) 

 (apply string-append (vector->list (make-vector n str))))</lang>

with SRFI 1: <lang scheme>(define (string-repeat n str) (fold string-append "" (make-list n str))) (string-repeat 5 "ha") ==> "hahahahaha"</lang>

To repeat a single character: <lang scheme>(make-string 5 #\*)</lang>

Scratch

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

sed

Number of ampersands indicates number of repetitions. <lang sed> $ echo ha | sed 's/.*/&&&&&/' hahahahaha </lang>

Seed7

<lang seed7>$ include "seed7_05.s7i";

const proc: main is func 

 begin
   writeln("ha" mult 5);
 end func;</lang>

Output: 

hahahahaha

SenseTalk

<lang sensetalk> put "Ho!" repeated 3 times

put "Merry" repeated to length 12 </lang> Output: 

Ho!Ho!Ho!
MerryMerryMe

Sidef

<lang ruby>'ha' * 5; # ==> 'hahahahaha'</lang>

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. <lang basic> 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</lang>

Smalltalk

If n is a small constant, then simply concatenating n times will do; for example, n=5:: <lang smalltalk>v := 'ha'. v,v,v,v,v</lang>

Works with: Pharo version 1.4
Works with: Smalltalk/X

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

<lang smalltalk>((1 to: n) collect: [:x | 'ha']) joinUsing: .</lang>

or:

Works with: Smalltalk/X
Works with: VisualWorks Smalltalk

<lang smalltalk>(Array new:n withAll:'ha') asStringWith:.</lang> By creating a WriteStream, and putting N times the string 'ha' into it:

<lang smalltalk>ws := writeStream. n timesRepeat: [ws nextPutAll: 'ha']. ws contents.</lang> alternatively: <lang smalltalk>(String streamContents:[:ws | n timesRepeat: [ws nextPutAll: 'ha']])</lang>

all evaluate to: 

hahahahaha

A string containing a repeated character is generated with: <lang smalltalk>String new:n withAll:$*</lang>

Works with: VA Smalltalk

<lang smalltalk>(String new:n) atAllPut:$*</lang>

SNOBOL4

<lang snobol4> output = dupl("ha",5) end</lang>

Sparkling

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

SQL

<lang sql>select rpad(, 10, 'ha')</lang>

SQL PL

Works with: Db2 LUW

<lang sql pl> VALUES REPEAT('ha', 5); VALUES RPAD(, 10, 'ha'); </lang> 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

<lang sml>fun string_repeat (s, n) = 

 concat (List.tabulate (n, fn _ => s))
</lang>

testing in the interpreter: <lang sml>- string_repeat ("Hiuoa", 3) ; val it = "HiuoaHiuoaHiuoa" : string</lang>

To repeat a single character: <lang sml>fun char_repeat (c, n) = 

 implode (List.tabulate (n, fn _ => c))
</lang>

Stata

<lang stata>. scalar a="ha" . scalar b=a*5 . display b hahahahaha</lang>

Suneido

<lang Suneido>'ha'.Repeat(5) --> "hahahahaha" '*'.Repeat(5) --> "*****"</lang>

Swift

The Builtin Way

<lang swift>print(String(repeating:"*", count: 5))</lang>

Output:

*****

Functions

<lang swift>func * (left:String, right:Int) -> String { 

    return String(repeating:left, count:right)

}

print ("HA" * 5) </lang>

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.

<lang swift>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) )</lang>

Output:
hahahahaha
hehehehehe

To repeat a single character: <lang swift>String(count:5, repeatedValue:"*" as Character) </lang>

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.

<lang swift>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)</lang>

Output:
"HeHeHeHeHe"

Tailspin

<lang tailspin> '$:1..5 -> 'ha';' -> !OUT::write </lang>

Output:
hahahahaha

Tcl

<lang tcl>string repeat "ha" 5  ;# => hahahahaha</lang>

TorqueScript

--Eepos <lang TorqueScript>function strRep(%str,%int) { for(%i = 0; %i < %int; %i++) { %rstr = %rstr@%str; }

return %rstr; }</lang>

Tosh

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

Transact-SQL

<lang tsql>select REPLICATE( 'ha', 5 )</lang>

TUSCRIPT

<lang tuscript> $$ MODE TUSCRIPT repeatstring=REPEAT ("ha",5) </lang>

UNIX Shell

Using printf

Works with: bash
Works with: ksh93
Works with: zsh

<lang bash>printf "ha"%.0s {1..5}</lang>

With ksh93 and zsh, the count can vary.

Works with: ksh93
Works with: zsh

<lang bash>i=5 printf "ha"%.0s {1..$i}</lang>

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

<lang bash>i=5 eval "printf 'ha'%.0s {1..$i}"</lang>

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

<lang bash>reprint() { 

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

} reprint '% ha \' 5</lang>

Using repeat

Works with: zsh
Works with: csh

<lang bash> len=12; str='=' repeat $len printf "$str" </lang>

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

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

Ursala

<lang Ursala>#import nat

repeat = ^|DlSL/~& iota

  1. cast %s

example = repeat('ha',5)</lang> output: 

'hahahahaha'

Vala

Repeat a string 5 times: <lang vala> string s = "ha"; string copy = ""; for (int x = 0; x < 5; x++) copy += s; </lang>

Fill a string with a char N times: <lang vala> string s = string.nfill(5, 'c'); </lang>

VBA


Repeat a string
<lang VBA>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)</lang>

Output:
hahahahaha

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

An alternative method: <lang vba>Public Function RepeatString(stText As String, iQty As Integer) As String RepeatString = Replace(String(iQty, "x"), "x", stText) End Function</lang>
Repeat a character
<lang VBA>Debug.Print String(5, "x")</lang>

Output:
xxxxx

VBScript

Works with: Windows Script Host version *

<lang VBScript> ' 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") </lang>

Vedit macro language

<lang vedit>Ins_Text("ha", COUNT, 5) </lang>

Visual Basic

Works with: Visual Basic version VB6 Standard


Repeat a string
<lang vb>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)</lang>

Output:
hahahahaha

An alternative method: <lang vb>Public Function StrRepeat(sText As String, n As Integer) As String StrRepeat = Replace(String(n, "*"), "*", sText) End Function</lang>


Repeat a character
<lang VBA>Debug.Print String(5, "x")</lang>

Output:
xxxxx

Visual Basic .NET


Repeat a string
<lang vb> Debug.Print(Replace(Space(5), " ", "Ha")) </lang>

Output:
HaHaHaHaHa


Repeat a character
<lang vb> Debug.Print(StrDup(5, "x")) Debug.Print("".PadRight(5, "x")) Debug.Print("".PadLeft(5, "x")) </lang>

Output:
xxxxx
xxxxx
xxxxx

Visual FoxPro

Use the built in function REPLICATE(string, number): <lang vfp>? REPLICATE("HO", 3)</lang>

produces 

HOHOHO

Vlang

<lang go>// Repeat a string, in V // Tectonics: v run repeat-a-string.v module main import strings

// starts here pub 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))

}</lang>

Output:
prompt$ v run rosetta/repeat-a-string.v
hahahahaha
*****

Wart

<lang wart>def (s * n) :case (string? s) 

 with outstring
   repeat n
     pr s

("ha" * 5) => "hahahahaha"</lang>

Wortel

<lang wortel>@join "" @rep 5 "ha" ; returns "hahahahaha"</lang> As a function: <lang wortel>^(\@join "" @rep)</lang>

Wren

<lang ecmascript>System.print("ha" * 5)</lang>

Output:
hahahahaha

XPL0

<lang XPL0>cod T=12; int I; for I gets 1,5 do T(0,"ha")</lang>

Output:
hahahahaha

Yorick

<lang yorick>array("ha", 5)(sum)</lang>

Z80 Assembly

<lang z80>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.</lang>

Output:
hahahahaha

zig

At compile-time: <lang zig>const laugh = "ha" ** 5;</lang> Note that to achieve this at run-time in zig (in order to avoid hidden overflows) you must manage the memory yourself. <lang zig>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);

}</lang>

zkl

Same as Ruby <lang zkl>"ha" * 5 # --> "hahahahaha"</lang>

Retrieved from "https://rosettacode.org/wiki/Repeat_a_string?oldid=130544"