Repeat a string: Difference between revisions

 

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

<br><br>

 

=={{header|4DOS Batch}}==

echo %@repeat[*,5]

quit

enddo

echo.

Output shows:

<pre>hahahahaha

*****</pre>

 

=={{header|8th}}==

Output shows:

<pre>hahahahaha</pre>

This works for ABAP Version 7.40 and above

 

report z_repeat_string.

 

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

 

{{out}}

<pre>

hahahahaha

</pre>

 

=={{header|ActionScript}}==

 

===Iterative version===

{

var output:String = "";

output += string;

return output;

 

===Recursive version===

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

{

if(numTimes == 0) return "";

var tmp:String = repeatRecursive(string, numTimes/2);

return tmp + tmp;

 

===Flex===

trace(StringUtil.repeat("ha", 5));

Sample Output:

<pre>

=={{header|Ada}}==

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

with Ada.Text_IO; use Ada.Text_IO;

 

begin

Put_Line (5 * "ha");

Sample output:

<pre>

 

=={{header|Aime}}==

 

=={{header|ALGOL 68}}==

 

=={{header|APL}}==

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

Alternatively, define a function:

5 REPEAT 'ha'

 

=={{header|AppleScript}}==

set final_string to ""

repeat 5 times

set final_string to final_string & str

 

 

 

{{trans|JavaScript}}

 

-- Repetition by 'Egyptian multiplication' -

end repeat

return out & dbl

 

=={{header|Applesoft BASIC}}==

 

Output:

<pre>X X</pre>

 

=={{header|Arturo}}==

 

{{out}}

 

<pre>hahahahaha</pre>

 

=={{header|AutoHotkey}}==

 

Repeat(String,Times)

Output .= String

Return Output

 

=={{header|AutoIt}}==

 

 

=={{header|AWK}}==

{

for( ; i<n; i++ )

BEGIN {

print repeat( "ha", 5 )

 

=={{header|Babel}}==

 

Outputs:

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

 

=={{header|BaCon}}==

To repeat a string:

s$ = s$ & "ha"

DONE

{{out}}

<pre>

</pre>

To repeat one single character:

{{out}}

<pre>

xxxxx

</pre>

 

=={{header|Batch File}}==

Commandline implementation

if "%2" equ "" goto fail

setlocal enabledelayedexpansion

for /l %%i in (1,1,%num%) do set res=!res!%char%

echo %res%

 

'Function' version

set /p a=Enter string to repeat :

set /p b=Enter how many times to repeat :

set "c=%c%+=1"

if /i _"%c%"==_"%d%" (exit /b)

 

'Function' version 2

@FOR /L %%i in (0,1,9) DO @CALL :REPEAT %%i

@echo That's it!

@GOTO:EOF

 

 

=={{header|BBC BASIC}}==

 

=={{header|beeswax}}==

p0~1<}~< d@<

 

 

<code>s</code> tells the user that the program expects a string as input.

<code>i</code> tells the user that the program expects an integer as input.

 

=={{header|Befunge}}==

>29*+00p>~:"0"- #v_v $

v ^p0p00:-1g00< $ >

Input sample:

<pre>ha05</pre>

Output sample:

<pre>hahahahaha</pre>

 

=={{header|Bracmat}}==

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

 

string N rep

. !arg:(?string.?N)

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

& str$!rep

 

<pre> repeat$(ha.5)

=={{header|Brainf***}}==

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

[-> +++++ +++++<] we add 10 to second each loopround

 

 

and a newline because I'm kind and it looks good

 

=={{header|Brat}}==

 

=={{header|Burlesque}}==

blsq ) 'h5?*

"hhhhh"

blsq ) "ha"5.*\[

"hahahahaha"

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

free(result);

return 0;

A variation.

char *string_repeat(const char *str, int n)

{

while (pa>=dest) *pa-- = *pb--;

return dest;

 

To repeat a single character

#include <stdlib.h>

#include <string.h>

free(result);

return 0;

 

If you use [[GLib]], simply use <code>g_strnfill ( gsize length, gchar fill_char )</code> function.

 

=={{header|C sharp}}==

or (with .NET 2+)

or (with .NET 2+)

or (with .NET 4+)

 

To repeat a single character:

or (with .NET 2+)

 

=={{header|C++}}==

#include <iostream>

 

std::cout << repeat( "Ha" , 5 ) << std::endl ;

return 0 ;

 

To repeat a single character:

#include <iostream>

 

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

return 0 ;

 

=={{header|Ceylon}}==

print("ha".repeat(5));

 

=={{header|Clipper}}==

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

 

=={{header|Clojure}}==

 

=={{header|COBOL}}==

Virtually a one-liner.

PROGRAM-ID. REPEAT-PROGRAM.

DATA DIVISION.

MOVE ALL 'ha' TO HAHA.

DISPLAY HAHA.

{{out}}

<pre>hahahahaha</pre>

 

=={{header|ColdFusion}}==

<cfset word = 'ha'>

<Cfset n = 5>

<Cfloop from="1" to="#n#" index="i">#word#</Cfloop>

</Cfoutput>

 

=={{header|Common Lisp}}==

(with-output-to-string (stream)

 

A version which allocates the result string in one step:

 

&aux

(len (length string))

for i from 0 by len

do (setf (subseq result i (+ i len)) string))

 

 

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

 

 

 

 

A single character may be repeated using just the builtin <code>make-string</code>:

produces “XXXXX”.

 

=={{header|Crystal}}==

puts "ha" * 5

 

 

=={{header|D}}==

Repeating a string:

 

void main() {

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

Repeating a character with vector operations:

 

void main() {

chars[] = '*'; // set all characters in the string to '*'

writeln(chars);

 

=={{header|DCL}}==

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

{{out}}

<pre>$ @repeat_a_string_and_then_character

=={{header|Delphi}}==

Repeat a string

function RepeatString(const s: string; count: cardinal): string;

var

 

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

 

Repeat a character

 

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

 

Using recursion

 

function RepeatStr(const s: string; i: Cardinal): string;

begin

result := s + RepeatStr(s, i-1)

end;

 

Built in RTL function:

 

 

=={{header|DWScript}}==

Repeat a string

 

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

 

Repeat a character

 

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

 

=={{header|Dyalect}}==

 

=={{header|Déjà Vu}}==

{{out}}

<pre>"hahahahaha"</pre>

 

=={{header|E}}==

 

=={{header|ECL}}==

After version 4.2.2

STRING MyBaseString := 'abc';

RepeatedString := STD.Str.Repeat(MyBaseString,3);

 

Before version 4.2.2

rec := {STRING Str};

ds := DATASET(Cnt,TRANSFORM(rec,SELF.Str := InStr));

 

RepeatString('ha',3);

 

=={{header|Egison}}==

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

 

=={{header|Eiffel}}==

repeat_string(a_string: STRING; times: INTEGER): STRING

require

Result := a_string.multiply(times)

end

 

=={{header|Elena}}==

import extensions;

import extensions'text;

public program()

{

 

=={{header|Elixir}}==

String.duplicate("ha", 5)

 

=={{header|Emacs Lisp}}==

 

 

 

 

 

 

=={{header|Erlang}}==

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

 

=={{header|ERRE}}==

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

LOCAL I%

END FOR

END PROCEDURE

Note: If N% is less than 1, the result is the empty string "".If S$ is a one-character string

you can use the predefined function <code>STRING$</code> as <code>REP$=STRING$(S$,N%)</code>.

 

 

 

hahahahaha

 

 

=={{header|Explore}}==

 

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:<br>https://i.ibb.co/71x9rwn/Repeat-a-string-in-Explore-using-a-special-block.png

 

=={{header|F_Sharp|F#}}==

Or

 

=={{header|Factor}}==

 

 

=={{header|Forth}}==

0 dest c!

n 0 ?do src len dest +place loop ;

 

s" ha" pad 5 place-n

The same code without the use of locals:

: place-n ( src len dest n -- )

swap >r 0 r@ c!

 

s" ha" pad 5 place-n

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

 

=={{header|Fortran}}==

{{works with |Fortran|90 and later}}

 

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

 

Output:

hahahahaha

 

=={{header|Free Pascal}}==

Repetition of a single character:

If the repeated character happens to be the space character:

 

=={{header|FreeBASIC}}==

 

' A character is essentially a string of length 1 in FB though there is a built-in function, String,

Print

Print "Press any key to quit program"

 

{{out}}

 

=={{header|Frink}}==

println[repeat["ha", 5]]

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=bdd2a7a0f4f09ff67e9d78b5d9667bdb Click this link to run this code]'''

 

Print String$(5, "ha")

 

 

Output = hahahahaha

 

=={{header|GAP}}==

 

=={{header|Glee}}==

 

Str# => Len;

1..Len %% (Len * 5) => Idx;

 

 

=={{header|Go}}==

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

 

=={{header|Groovy}}==

 

=={{header|Harbour}}==

 

=={{header|Haskell}}==

For a string of finite length:

 

Or with list-monad (a bit obscure):

 

Or with Control.Applicative:

 

For an infinitely long string:

 

To repeat a single character:

 

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 s n =

let rep x = xs

 

main :: IO ()

{{Out}}

<pre>"hahahahaha"</pre>

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.List (unfoldr)

import Control.Monad (join)

-- TEST -----------------------------------------------------------------------

main :: IO ()

 

=={{header|HicEst}}==

 

 

=={{header|Icon}} and {{header|Unicon}}==

The procedure <tt>repl</tt> is a supplied function in Icon and Unicon.

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

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

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

return ns

 

=={{header|Idris}}==

strRepeat Z s = ""

strRepeat (S n) s = s ++ strRepeat n s

chrRepeat : Nat -> Char -> String

chrRepeat Z c = ""

 

=={{header|Inform 7}}==

 

To decide which indexed text is (T - indexed text) repeated (N - number) times:

When play begins:

say "ha" repeated 5 times;

 

=={{header|IS-BASIC}}==

100 DEF STRING$(S$,N)

105 LET ST$=""

130 NEXT

140 LET STRING$=ST$

 

=={{header|J}}==

*****

5 # 'ha' NB. repeat each item 5 times

5 ((* #) $ ]) 'ha' NB. repeat array 5 times

hahahahaha

 

=={{header|Java}}==

{{works with|Java|1.5+}}

 

 

StringBuilder sb = new StringBuilder(str.length() * times);

for (int i = 0; i < times; i++)

public static void main(String[] args) {

System.out.println(repeat("ha", 5));

 

Or even shorter:

 

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

 

In Apache Commons Lang, there is a [http://commons.apache.org/lang/api-2.6/org/apache/commons/lang/StringUtils.html#repeat%28java.lang.String,%20int%29 StringUtils.repeat()] method.

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

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

}

 

 

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

 

 

====Repetition by Egyptian multiplication====

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

 

'use strict';

 

 

return replicate(5000, "ha")

 

====Concat . replicate====

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

'use strict';

 

// TEST -------------------------------------------------------------------

return repeat(5, 'ha');

{{Out}}

<pre>hahahahaha</pre>

 

 

 

=={{header|Julia}}==

{{works with|Julia|1.0}}

 

 

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

 

=={{header|K}}==

 

,/5#,"ha"

"hahahahaha"

5#"*"

"*****"

 

=={{header|Kotlin}}==

println("ha".repeat(5))

Or more fancy:

 

 

=={{header|LabVIEW}}==

[[file:LabVIEW_Repeat_a_string.png]]

 

=={{header|Lasso}}==

 

 

=={{header|LFE}}==

(string:copies '"ha" 5)

 

=={{header|Liberty BASIC}}==

print StringRepeat$( a$, 5)

 

next i

StringRepeat$ =o$

 

=={{header|Lingo}}==

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

res = ""

repeat with i = 1 to n

end repeat

return res

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

 

=={{header|LiveCode}}==

put repeatString("ha", 5)

end mouseUp

end repeat

return t

 

=={{header|Logo}}==

if :n = 0 [output :acc]

output (copies :n-1 :thing combine :acc :thing)

or using cascade:

 

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

 

if :n = 0 [output :acc]

output (copies :n-1 :thing combine :acc :thing)

end

 

 

=={{header|Lua}}==

 

Or use native string library function

 

=={{header|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

 

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

 

 

=={{header|MATLAB}} / {{header|Octave}}==

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

 

Note 1: The repetition is returned, not displayed.

 

=={{header|Maxima}}==

infix("$*")$

 

"abc" $* 5;

 

=={{header|Mercury}}==

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

 

:- interface.

:- import_module string, char, int.

print(Stream, String, !S),

printn(Stream, N - 1, String, !S)

 

=={{header|min}}==

{{works with|min|0.19.3}}

{{out}}

<pre>

 

=={{header|MiniScript}}==

{{out}}

<pre>

 

=={{header|Mirah}}==

 

5.times do

end

 

 

=={{header|Monte}}==

var s := "ha " * 5

traceln(s)

 

=={{header|MontiLang}}==

Or with a loop

|ha| OUT .

 

Or ...

 

 

=={{header|MUMPS}}==

;Repeat a string S for N times

NEW I

F I=1:1:N W S

Q

 

 

This last example uses the [http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=RCOS_fpiece#RCOS_B57001 $PIECE] function.

;Even better (more terse)

S x="",$P(x,"-",10)="-"

W x

 

=={{header|Nanoquery}}==

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

 

=={{header|Neko}}==

var srep = function(s, n) {

var str = ""

}

 

 

{{out}}

=={{header|Nemerle}}==

Any of the methods shown in the [[Repeat_a_string#C.23|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.Console;

 

 

}

 

=={{header|NetRexx}}==

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

 

ha5 = 'ha'.copies(5)

 

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

 

sampleStr = 'ha' -- string to duplicate

say ' COPIES:' sampleStr.copies(5)

say ' SUBSTR:' ''.substr(1, 5, sampleChr)

say 'TRANSLATE:' '.....'.translate(sampleChr, '.')

 

=={{header|NewLISP}}==

 

=={{header|Nim}}==

 

=={{header|Objeck}}==

class Repeat {

function : Main(args : String[]) ~ Nil {

}

}

 

=={{header|Objective-C}}==

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.

 

- (NSString *) repeatStringByNumberOfTimes: (NSUInteger) times;

@end

return [@"" stringByPaddingToLength:[self length]*times withString:self startingAtIndex:0];

}

 

Now, let's put it to use:

// -repeatByNumberOfTimes: selector.

NSString *aString = [@"ha" repeatStringByNumberOfTimes:5];

 

// Display the NSString.

 

=={{header|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 len = Bytes.length s in

for i = 0 to pred n do

Bytes.blit s 0 res (i * len) len

done;

 

testing in the toplevel:

 

Alternately create an array initialized to s, and concat:

String.concat "" (Array.to_list (Array.make n s))

 

Or:

Array.fold_left (^) "" (Array.make n s)

 

To repeat a single character use:

 

=={{header|Oforth}}==

 

=={{header|OpenEdge/Progress}}==

 

=={{header|OxygenBasic}}==

 

'REPEATING A CHARACTER

 

print RepeatString "ABC",3 'result ABCABCABC

 

=={{header|Oz}}==

We have to write a function for this:

fun {Repeat Xs N}

if N > 0 then

end

in

 

=={{header|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|C]]) and pass that to GP.

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

 

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

 

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

if(n<4, return(concat(vector(n,i, s))));

if(n%2,

repeat(Str(s,s),n\2)

);

 

===Version #2. Simple loop based.===

for the heavy text processing.

 

\\ Repeat a string str the specified number of times ntimes and return composed string.

\\ 3/3/2016 aev

print1("6."); for(i=1,10000000, srepeat("e",10));

}

 

{{Output}}

 

=={{header|Perl}}==

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|Phixmonti}}==

enddef

 

 

=={{header|PHP}}==

 

=={{header|PicoLisp}}==

or:

 

=={{header|Pike}}==

 

=={{header|PL/I}}==

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

 

 

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

 

=={{header|Plorth}}==

 

=={{header|PostScript}}==

% where rcount is the repeat count, "o" is for orignal,

% "f" is for final, and iter is the for loop variable

} for

pop % fstring

 

=={{header|PowerBASIC}}==

 

=={{header|PowerShell}}==

 

=={{header|Processing}}==

String rep = repeat("ha", 5);

println(rep);

// and return as a new String

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

 

=={{header|Prolog}}==

repeat(Str,1,Str).

repeat(Str,Num,Res):-

Num1 is Num-1,

repeat(Str,Num1,Res1),

 

=={{header|Pure}}==

repeating it more than 0 times results in the concatenation of the string and (n-1) further repeats.

 

> 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:[]);

 

=={{header|PureBasic}}==

Protected i, ret$=""

 

EndProcedure

 

 

=={{header|Python}}==

"Characters" are just strings of length one.

 

the other way also works:

 

=={{header|R}}==

 

=={{header|Racket}}==

#lang racket

;; fast

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

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

 

To repeat a single character:

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

 

=={{header|Raku}}==

(formerly Perl 6)

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

 

=={{header|RapidQ}}==

'For a single char

showmessage String$(10, "-")

 

showmessage Repeat$("ha", 5)

 

=={{header|REALbasic}}==

Dim output As String

For i As Integer = 0 To count

Return output

End Function

 

=={{header|REBOL}}==

 

=={{header|Red}}==

>> insert/dup str "ha" 3

== "hahahaAdd duplicates to string"

>> insert/dup tail str "ha" 3

 

=={{header|Retro}}==

: repeatString ( $n-$ )

1- [ dup ] dip [ over prepend ] times nip ;

 

 

=={{header|REXX}}==

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

 

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

parse value y||y||y||y||y with z

 

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

<br><br>

 

=={{header|Ring}}==

 

=={{header|Ruby}}==

 

=={{header|Run BASIC}}==

for i = 1 to 5

a1$ = a1$ + a$

next i

a$ = a1$

 

=={{header|Rust}}==

 

Since 1.16:

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

with SRFI 1:

(fold string-append "" (make-list n str)))

 

To repeat a single character:

 

=={{header|Scratch}}==

=={{header|sed}}==

Number of ampersands indicates number of repetitions.

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

hahahahaha

 

=={{header|Seed7}}==

 

const proc: main is func

begin

writeln("ha" mult 5);

 

Output:

 

=={{header|SenseTalk}}==

put "Ho!" repeated 3 times

 

put "Merry" repeated to length 12

Output:

<pre>

 

=={{header|Sidef}}==

 

=={{header|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.

20 LET N=5

30 GOSUB 60

80 LET T$=T$+S$

90 NEXT I

 

=={{header|Smalltalk}}==

 

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

 

{{works with|Pharo|1.4}}

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

 

or:{{works with|Smalltalk/X}}

{{works with|VisualWorks Smalltalk}}

 

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

 

n timesRepeat: [ws nextPutAll: 'ha'].

alternatively:

 

all evaluate to:

 

A string containing a repeated character is generated with:

 

{{works with|VA Smalltalk}}

 

=={{header|SNOBOL4}}==

 

=={{header|Sparkling}}==

 

=={{header|SQL}}==

 

=={{header|SQL PL}}==

{{works with|Db2 LUW}}

VALUES REPEAT('ha', 5);

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

Output:

<pre>

 

=={{header|Standard ML}}==

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

 

testing in the interpreter:

 

To repeat a single character:

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

 

=={{header|Stata}}==

. scalar b=a*5

. display b

 

=={{header|Suneido}}==

 

=={{header|Swift}}==

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

 

// Slower version

func repeatString(n: Int) -> String {

 

print( "ha".repeatString(5) )

{{out}}

<pre>

 

To repeat a single 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).

The following version is an enhanced version of the [http://rosettacode.org/mw/index.php?title=Repeat_a_string#Recursive_version 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.

 

func repeatBiterative(count: Int) -> String {

var reduceCount = count

}

 

{{out}}

<pre>

 

=={{header|Tailspin}}==

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

{{out}}

<pre>hahahahaha</pre>

 

=={{header|Tcl}}==

 

=={{header|TorqueScript}}==

--[[User:Eepos|Eepos]]

{

for(%i = 0; %i < %int; %i++)

 

return %rstr;

 

=={{header|Tosh}}==

set String to "meow"

set Count to 4

set Repeated to (join (Repeated) (String))

end

 

=={{header|Transact-SQL}}==

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

repeatstring=REPEAT ("ha",5)

 

=={{header|UNIX Shell}}==

{{works with|ksh93}}

{{works with|zsh}}

 

With ksh93 and zsh, the count can vary.

{{works with|ksh93}}

{{works with|zsh}}

 

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

{{works with|ksh93}}

{{works with|zsh}}

 

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

{{works with|ksh93}}

{{works with|zsh}}

typeset e="$(sed -e 's,%,%%,g' -e 's,\\,\\\\,g' <<<"$1")"

eval 'printf "$e"%.0s '"{1..$2}"

}

 

=== Using repeat ===

{{works with|csh}}

 

len=12; str='='

repeat $len printf "$str"

 

===Using head -c===

{{works with|Bourne Shell}}

 

 

=={{header|Ursala}}==

 

repeat = ^|DlSL/~& iota

#cast %s

 

output:

<pre>'hahahahaha'</pre>

=={{header|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');

 

=={{header|VBA}}==

<br>'''Repeat a string'''<br>

Dim bString As String, i As Integer

bString = ""

End Function

 

{{out}}

<pre>

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

<p>An alternative method:

RepeatString = Replace(String(iQty, "x"), "x", stText)

<br>'''Repeat a character'''<br>

{{out}}

<pre>xxxxx</pre>

=={{header|VBScript}}==

{{works with|Windows Script Host|*}}

' 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 Replace(Space(10), " ", "Ha")

WScript.Echo Replace(String(10, "X"), "X", "Ha")

 

=={{header|Vedit macro language}}==

 

=={{header|Visual Basic}}==

{{works with|Visual Basic|VB6 Standard}}

<br>'''Repeat a string'''<br>

Dim r As String, i As Integer

r = ""

End Function

{{out}}

<pre>hahahahaha</pre>

 

An alternative method:

StrRepeat = Replace(String(n, "*"), "*", sText)

 

<br>'''Repeat a character'''<br>

{{out}}

<pre>xxxxx</pre>

=={{header|Visual Basic .NET}}==

<br>'''Repeat a string'''<br>

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

{{out}}

<pre>

 

<br>'''Repeat a character'''<br>

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

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

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

{{out}}

<pre>

=={{header|Visual FoxPro}}==

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

 

produces

<pre>HOHOHO</pre>

 

=={{header|Wart}}==

with outstring

repeat n

 

("ha" * 5)

 

=={{header|Wortel}}==

As a function:

 

=={{header|XPL0}}==

{{out}}

<pre>hahahahaha</pre>

 

=={{header|Yorick}}==

 

=={{header|zig}}==

At compile-time:

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

const warn = std.debug.warn;

 

const ex = try repeat("ha", 5, allocator);

defer allocator.free(ex);

 

=={{header|zkl}}==

Same as [[#Ruby|Ruby]]