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

 

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

echo %@repeat[*,5]

quit

enddo

echo.

Output shows:

<pre>hahahahaha

*****</pre>

 

=={{header|ActionScript}}==

 

In Flex, there is the method [http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/mx/utils/StringUtil.html#repeat%28%29 mx.utils.StringUtil.repeat()].

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

hahahahaha

</pre>

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

 

 

=={{header|AppleScript}}==

set final_string to ""

repeat 5 times

 

 

=={{header|AutoHotkey}}==

 

Repeat(String,Times)

Output .= String

Return Output

=={{header|AWK}}==

{

for( ; i<n; i++ )

BEGIN {

print repeat( "ha", 5 )

 

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

 

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

 

 

 

 

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

 

 

=={{header|Brat}}==

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

 

int main() {

puts(result);

free(result);

return 0;

A variation.

{

char *pa, *pb;

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

return dest;

 

To repeat a single character

#include <stdlib.h>

#include <string.h>

free(result);

return 0;

 

=={{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|Clojure}}==

 

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

(with-output-to-string (stream)

 

 

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

produces “XXXXX”.

 

=={{header|D}}==

Repeating a string:

 

void main() {

Repeating a character with vector operations:

 

void main() {

chars.length = 5; // set the length

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

 

 

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

 

 

Built in RTL function:

 

 

=={{header|DWScript}}==

Repeat a string

 

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

 

Repeat a character

 

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

 

=={{header|E}}==

 

=={{header|Erlang}}==

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

 

=={{header|Euphoria}}==

 

 

 

=={{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|Frink}}==

println[repeat["ha", 5]]

 

=={{header|GAP}}==

 

=={{header|Go}}==

 

=={{header|Groovy}}==

 

=={{header|Haskell}}==

For a string of finite length:

 

Or with list-monad (a bit obscure):

 

For an infinitely long string:

 

To repeat a single character:

 

=={{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|Inform 7}}==

 

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

When play begins:

say "ha" repeated 5 times;

 

=={{header|J}}==

*****

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

hhhhhaaaaa

hahahahaha

 

=={{header|Java}}==

{{works with|Java|1.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.

 

=={{header|JavaScript}}==

}

 

 

 

=={{header|K}}==

 

,/5#,"ha"

"hahahahaha"

5#"*"

"*****"

 

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

print StringRepeat$( a$, 5)

 

next i

StringRepeat$ =o$

 

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

 

 

 

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

 

Note 1: The repetition is returned, not displayed.

<br>

Note 2: To repeat a string, use single quotes. Example: S=repeat('ha',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|Mirah}}==

 

5.times do

end

 

 

=={{header|MUMPS}}==

;Repeat a string S for N times

NEW I

RPTSTR1(S,N) ;Functionally equivalent, but denser to read

F I=1:1:N W S

 

 

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

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

for i = 0 to pred n do

done;

 

testing in the toplevel:

 

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

 

Or:

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

 

 

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

 

=={{header|Oz}}==

We have to write a function for this:

fun {Repeat Xs N}

if N > 0 then

end

in

 

=={{header|PARI/GP}}==

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

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

 

 

=={{header|PHP}}==

 

=={{header|PicoLisp}}==

or:

 

=={{header|Pike}}==

 

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

 

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

 

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

 

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

 

=={{header|PureBasic}}==

Protected i, ret$=""

 

EndProcedure

 

 

=={{header|Python}}==

"Characters" are just strings of length one.

 

the other way also works:

 

=={{header|R}}==

 

=={{header|Racket}}==

(define (string-repeat n str)

 

To repeat a single character:

 

=={{header|REBOL}}==

 

=={{header|Retro}}==

: repeatString ( $n-$ )

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

 

 

=={{header|REXX}}==

 

 

y='ha'

z=copies(y,5)

y='ha'

z=y||y||y||y||y

y='ha'

z=''

 

 

 

z=

z=z||y

end

 

 

=={{header|Ruby}}==

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

with SRFI 1:

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

 

To repeat a single character:

 

=={{header|Scratch}}==

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

 

[[File:Scratch_Repeat_a_String.png]]

 

=={{header|Seed7}}==

 

const proc: main is func

begin

writeln("ha" mult 5);

 

Output:

hahahahaha

</pre>

 

=={{header|SNOBOL4}}==

 

=={{header|SQL}}==

 

=={{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|Suneido}}==

 

=={{header|Tcl}}==

 

=={{header|TUSCRIPT}}==

 

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

 

 

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

End Function

 

<pre>

</pre>

 

 

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

 

 

<pre>

 

=={{header|Yorick}}==

 

[[Category: String manipulation]]