Repeat a string: Difference between revisions

=={{header|11l}}==

{{out}}

=={{header|360 Assembly}}==

REPEATS CSECT

USING REPEATS,R13 base register

PG DC CL80' ' pg

REGEQU

{{out}}

<pre>

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

echo %@repeat[*,5]

quit

enddo

echo.

Output shows:

<pre>hahahahaha

=={{header|6502 Assembly}}==

org $0801

TestStr:

{{out}}

<pre>

=={{header|68000 Assembly}}==

Easiest way to do this is with a loop.

RepString:

LEA A3, MyString

MyString:

DC.B "ha",0

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

=={{header|Action!}}==

byte REPEAT

Do

{{out}}

<pre>hahahahaha</pre>

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

#!/usr/bin/hopper

#include <hopper.h>

{"ha",5}replicate, println

{0}return

hahahahaha

hahahahaha

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

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

=={{header|BASIC}}==

==={{header|BASIC256}}===

cad$ = ""

for i = 1 to n

print StringRepeat$("ha", 5)

print StringRepeat$("*", 5)

==={{header|QBasic}}===

cad$ = ""

FOR i = 1 TO n

PRINT StringRepeat$("ha", 5)

PRINT StringRepeat$("*", 5)

==={{header|True BASIC}}===

LET cad$ = ""

FOR i = 1 TO n

PRINT StringRepeat$("ha", 5)

PRINT StringRepeat$("*", 5)

==={{header|Yabasic}}===

cad$ = ""

for i = 1 to n

print StringRepeat$("ha", 5)

print StringRepeat$("*", 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)

'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@<

=={{header|Befunge}}==

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

v ^p0p00:-1g00< $ >

Input sample:

<pre>ha05</pre>

<code>⥊</code>(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.

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

=== recursive version ===

#include <iostream>

std::cout << repeat( "Ha" , 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

<pre>hahahahaha</pre>

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

ELENA 4.x :

import extensions;

import extensions'text;

{

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

=={{header|Elixir}}==

String.duplicate("ha", 5)

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

Going via a list to repeat the desired string:

A single character can be repeated with <code>make-string</code>:

The <code>cl-loop</code> macro can repeat and concatenate:

{{libheader|cl-lib}}

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

=={{header|Euphoria}}==

A simple loop will do:

sequence s = ""

for i = 1 to 5 do s &= "ha" end for

hahahahaha

For repeating a single character:

sequence s = repeat('*',5)

*****

For repeating a string or sequence of numbers:

include std/console.e -- for display

include std/sequence.e -- for repeat_pattern

hahahahaha

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

But wait, here's another way:

include std/console.e -- for display

include std/sequence.e -- for flatten

sequence s = flatten(repeat("ha",5))

display(s)

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

{

"ha",

"ha"

}

=={{header|Explore}}==

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

hahahahaha

5 ;@# < 'ha' NB. using boxing to treat the array as a whole

=={{header|Java}}==

There's no method or operator to do this in Java, so you have to do it yourself.

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

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

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

=={{header|Lambdatalk}}==

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

-> ha ha ha ha ha ha ha ha ha ha

{repeat ha 10}

-> hahahahahahahahahahaha

=={{header|langur}}==

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

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