Background

This is a standard textbook example to demonstrate for loops.

This is one of the first programs I learnt when I started learning programming ~10 years ago.

You are to print this exact text:

**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Specs

• You may have extra trailing newlines.
• You may have extra trailing spaces (U+0020) at the end of each line, including the extra trailing newlines.

Scoring

This is . Shortest answer in bytes wins.

• @DylanMeeus "You are to print this exact text:" Commented Aug 4, 2016 at 12:56
• @DylanMeeus Since that is to do with the dev tools hiding repeated console outputs, and isn't native to JavaScript consoles as a whole and is not in the JavaScript spec - as well as the fact that feature can be turned off - i think it should be acceptable. Not all browsers will collapse it like that. Commented Aug 4, 2016 at 12:58
• One of the most interesting things about this challange is that depending on your language ********** can be shorter then a loop. Makes me wonder when it's better for a given language to switch between 1 or 2 loops. Commented Aug 5, 2016 at 9:14
• you say trailing new lines are acceptable. Are leading newlines acceptable too? Commented Feb 10, 2017 at 2:34

ArnoldC, 171 bytes

IT'S SHOWTIME
HEY CHRISTMAS TREE i
YOU SET US UP 10
STICK AROUND i
TALK TO THE HAND "**********"
GET TO THE CHOPPER i
GET DOWN 1
ENOUGH TALK
CHILL
YOU HAVE BEEN TERMINATED

Just for the fun of it. Nothing fancy going on here, just loops 10 times printing ********** each time.

• I think you're missing a HERE IS MY INVITATION i between lines 6 and 7. Commented Sep 4, 2017 at 3:54

Chef, 252 bytes

Was purely for fun trying to learn Chef.

Try it online!

a.

Ingredients.
42 b
10 c
10 d
13 e

Method.
Put e into mixing bowl.
F the c.
Put b into mixing bowl.
F the c until fed.
Liquefy contents of the mixing bowl.
G the d.
Pour contents of the mixing bowl into the baking dish.
G the d until ged.

Serves 1.
• Nice answer! Welcome to the site :) Commented Dec 20, 2017 at 21:10

TSQL, 45 bytes

SELECT TOP 10 REPLICATE('*',10) FROM systypes

Above query use TSQL REPLICATE function to replicate * 10 times and systypes is a system view in SQL Server which list out system specified and user defined data types.

Try it here

This is my answer on Code Golf and I hope I am doing it correctly.

• Welcome to PPCG! I would say you need to count those spaces in your bytecount, since they are required to execute your code Commented Aug 4, 2016 at 15:30
• @applejacks01 Thanks for your input. I have modified it. Commented Aug 4, 2016 at 15:32
• Couldn't you just do Select top 10 '**********' from systypes? Commented Aug 6, 2016 at 14:41
• Didn't see there was already a TSQL answer. You can do it in 24 bytes by just using Print and "Go 10"
– Paul
Commented Feb 12, 2018 at 11:25

Backhand, 28 bytes

aH~0}|{:& [a ^v&v"*******" ^

Try it online!

It may seem weird that the quotes only contain 7 asterisks, but there's a reason for it.

Explanation:

Note that the pointer usually moves in steps of 3

a         Push 10 as the counter
0 |{   Push 0 to not get reflected and enter the loop
&           Store the counter in the register
a        Push a newline
v v  Decrease the step value to 1
"*******"    Push 7 asterisks
^  Increase the step value to 2 and reflect
" * * * "    Push 3 asterisks
&   Restore the counter
^      Increase the step counter to 3
[         Decrement the counter
:    Duplicate the counter
}|      Repeat the loop if the counter is not zero
~     Otherwise, pop the excess copy of the counter
H      And terminate, printing the contents of the stack

Rust, 49 bytes

fn main(){print!("{}","**********\n".repeat(10))}

• Welcome to the site! You might want to add a link to Try It Online with your code, so other people can test your program. Commented Jan 22, 2020 at 14:06

Charcoal, 4 bytes

Ｇ+α*

Try it online!

The code translates as: draw a filled polygon (); give it four equal sides going in the four cardinal directions (+); each side should be 10 characters (α, a variable preinitialized to 10); use asterisks (*).

• Commented Sep 3, 2017 at 23:01

swift 5, 35 bytes

(0...9).map{$0;print("**********")} The$0 is only needed to prevent a compiler error.

[Update]

Try it online:

https://tio.run/##Ky7PTCsx@f9fw0BPT89SUy83saBaxcC6oCgzr0RDSQsOlDRr//8HAA

• Welcome to Code Golf! Nice first answer. Commented Mar 13, 2021 at 23:02
• It's also nice to include a link to an online testing environment. We mostly use Try It Online! for that - it even has a CodeGolf submission template. It only has Swift 4, but as I can see, your answer still works just fine Commented Mar 15, 2021 at 9:47

Factor, 30 bytes

10 [ "**********"print ] times

Try it online!

Okay, is there a factor vocabulary to print string $$\n\$$ times? I couldn't find a documentation?

Commodore BASIC (C64/128, PET, VIC-20, C16/+4, THEC64/Mini, Ultimate64) ~35 tokenised BASIC bytes

0a$="**********":fori=.to9:?a$:next

Very simply, a string is created called a$; this is of 10 asterisks. This is printed to the screen in a for/next loop, which is from zero to nine inclusive. Each string is printed onto a new row on the screen. A few tokenised BASIC bytes could be saved with: 0fori=.to9:?"**********":next Though I think this would be less performant (not that performance will matter with such a trivial BASIC listing). • A minor tweak and it's also valid Applesoft Basic 0a$="**********":fori=0to9:?a$:next Commented Aug 26, 2021 at 2:55 • You can also do 0?"**********":a=a+1:ifa<10thengoto in Commodore BASIC; without a line number following the goto command, Commodore BASIC will goto 0 as long as there is a line zero Commented Aug 26, 2021 at 12:58 Python 3, 25 24 23 bytes Newest answer print(('*'*10+'\n')*10) I'm an idjot, I don't need so many parentheses. 2nd answer print('**********\n'*10) I shaved off a byte doing it more simply. 1st answer print((('*'*10)+'\n')*10) Python can multiply strings, but most of your saving are eaten by print(), so it goes like this: print((('*'*10)+'\n')*10) print( # Print to console (('*'*10) # Put 10 '*' in a row +'\n' # Append a new line character at the end of the 10 '*' )*10) # Now do it 10 more times • Welcome to Code Golf, and nice first answer! Commented Aug 24, 2021 at 1:42 Python 3, 25 bytes exec("print('*'*10);"*10) Headascii, 44 43 bytes +++++^^DONE.U^[]]]]++[{]PPPPPPPPPPRPD-^)!:} Try it here! Code will need to be copied, and executed like this: erun("+++++^^DONE.U^[]]]]++[{]PPPPPPPPPPRPD-^)!:}") My first code golf answer. One trailing newline. Thanks to @Aaroneous Miller for -1 by showing me N is valid for no input programs. Explanation: +++++^^DONE.U^[]]]]++[{]PPPPPPPPPPRPD-^)!:} +++++ # add 5 to r0 ^^ # add r0 to r1 twice D # set r0 to r1 (10) O # push r0 to array N # set r0 to 1 if no input E. # jump to r0th . and set non string registers to 0 U # set r0 to first item in array (10) ^ # add r0 to r1 [ # set r2 to r0 and set r0 to 0 ]]]] # add r2 to r0 4 times (40) ++ # add 2 to r0 [ # set r2 to r0 (42) and set r0 to 0 { } # loop ] # add r2 to r0 (42) PPPPPPPPPP # concatenate r0 (*) to the string register 10 times (**********) RP # set r0 to the first item of the array again (10) and concatenate r0 (\n) to the string register (**********\n) D-^ # decrement r1 and set r0 to r1 ) # if r0 != r3 (0), jump past next :. either way, set r0 to r3 (0) ! # print string register : # jump to next ; (eof halt) If there's a better way to format these, let me know, I just saw everyone else doing it haha • Welcome to Code Golf, and nice first answer! For a question like this, you can typically assume that there's no input, so the shorter solution is perfectly valid. :) Commented Oct 6, 2021 at 20:05 • @AaroneousMiller oh yay :D thank you! Also, I may edit this to include an explanation later on Commented Oct 6, 2021 at 20:10 • No problem! I can't wait to read the explanation; this language looks pretty neat! Commented Oct 6, 2021 at 20:11 • @AaroneousMiller using this comment to both express my gratitude and also let you know the explanation is there :] Commented Oct 6, 2021 at 21:22 Nibbles, 4.5 bytes (9 nibbles) /10^$"*"

Attempt This Online!

^       # replicate
"*"   # an asterisk
$# 100x # (this is a default value for$
# when the program receives no input)
/          # split into chunks of
10        # 10

Cheddar, 24 bytes

print(['*'*10]*10).vfuse

'*'*10 builds the string **********.

Then, ['**********']*10 creates 10 copies of that string.

Then, vfuse joins by newline.

SpecBAS - 18 bytes

?(("*"*10)+#13)*10

? is shorthand for PRINT, #13 is the equivalent of \n in other languages.

Perl, 17 bytes

Requires -E at no extra cost.

say"*"x10for 0..9

Usage

perl -E 'say"*"x10for 0..9'
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Saved a byte thanks to @manatwork!

• Keywords may touch the preceding digits. Commented Aug 4, 2016 at 12:27
• @manatwork Ahhh... I always forget that works, expecially as for0.. doesn't! Thanks! Commented Aug 4, 2016 at 12:29
• I literally typed out the same program :) Commented Aug 4, 2016 at 14:14
• Try it online!
– mik
Commented Mar 15, 2021 at 11:52

ab*1-:?!v:20.
>'*'o72.~
^?%b;!?l<oa

Try it online!

dc, 22 18 bytes

[**********]ddddff

Invoked in bash as

echo [**********]ddddff | dc

Explanation:

[**********] # This is dc's way of making a string, which is then pushed onto the stack
dddd         # d is for duplicate, so we duplicate it 4 times on the stack
ff           # print the whole stack twice, which contains 5 repetitions of 10 *'s (x2)

Thanks to LeakyNun for saving 5 4 bytes; Edited from 5 since I can't count.

• Ah, right! f doesn't clear the stack. Alternatively, ...dfffff would accomplish it as well with the same byte count. Come to think, ...ddfffp would work just as well (3 sets of three and then just one). There are a lot of ways to get 10 reps with 6 bytes. Commented Aug 4, 2016 at 17:45

C#, 53,122 108 bytes

Seeing that I'm seriously new to code golf... I'll give it a shot in c#

public class Program{public static void Main(){for (var i=0;i<10;i++)System.Console.Write("**********\n");}}

try it online

• for(var i=0;i++<10;)Console.Write("**********\n"); is shorter, also, you need a full program or function. Commented Aug 4, 2016 at 11:08
• @MarsUltor - thanks for the feedback. As mentioned, I'm seriously new to this and not exactly sure what is allowed and what not. Could you please elaborate on full program? Would this include literary all the code, such as using, namespaces, main etc. Thanks! Commented Aug 4, 2016 at 11:12
• class a{static void Main{for(var i=0;i++<10;)Console.Write("**********\n");}} is acceptable (not entirely sure it works though, you should test it, maybe you need System before Console) Commented Aug 4, 2016 at 11:21
• You can get rid of using System; and use System.Console.WriteLine("**********");. It saves you 6 bytes. Also, you can get rid of some spaces for extra savings - the ones around the for cycle. Commented Aug 4, 2016 at 17:23
• It's a shame Enumerable.Repeat() is so many bytes... C# could move up a lot of these with a shorthand for that function. Commented Aug 8, 2016 at 19:28

Python 3, 25 23 bytes

Hey I actually outgolfed someone :).

print(("*"*9+"*\n")*10)

if stderr is valid, 22 bytes

exit(("*"*9+"*\n")*10)

realised that execing didn't actually golf it down :(

exec("print('*'*10);"*10)

Works by concatenating ten copies of print('*'*10); and execing, which in turn works by concatenating '*' 10 times and printing

• I think you're missing parentheses: print(("*"*9+"*\n")*10) Commented Aug 4, 2016 at 9:46
• I think you're missing my update Commented Aug 4, 2016 at 9:48
• I mean your 21-byte solution gives a wrong output. Commented Aug 4, 2016 at 9:52
• I'm not sure chronologically which came first the comment or my edit anymore Commented Aug 4, 2016 at 10:25
• I didn't even know about that stderr trick, neat! Commented Feb 17, 2017 at 6:11

MSX BASIC, 40 30 bytes

1FORR=1TO10:FORC=1TO10:?"*";:NEXT:?:NEXT

Update: D'oh... much shorter if I just print whole rows:

1FORR=1TO10:?"**********":NEXT
• -1 byte: 1FORR=0TO9:?"**********":NEXT Commented Jul 2, 2018 at 9:55

Same, 239 bytes

ЕEЕEЕEЕEЕEEЕЕEЕEЕEЕЕEΕЕEЕEEЕЕЕΕЕЕEЕEЕEЕEЕEЕEЕEЕEЕEЕEΕEEΕEЕΕЕEEЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕΕЕЕEЕEЕEЕEЕEЕEЕEЕEЕEЕEЕЕЕЕEΕEEΕЕЕΕΕΕ

Samebly code used to generate this:

mstore
mult
mstore
clear
while
minc
mstore
mdec
outc
outc
outc
outc
outc
outc
outc
outc
outc
outc
clear
outc
minc
mdec
dec
end
• The github link in the language name is a 404 for me. Commented Aug 14, 2021 at 13:52

><>, 22 15 bytes

'*o'l),lb%a$?$o

The program exits with an error and the output has no trailing newlines. Try it online!

'*o'                  Push 42 '*' and 111
l),               Divide the 42 by (111 > length of stack) - this is a no-op
initially and a division by zero error later on
lb%            Push (length of stack) % 11
a$Put 10 '\n' beneath that ?$        If (length of stack) % 11 is nonzero, swap top two chars,
moving the '*' above the '\n'
o       Output top char, leaving the other char and hence
increasing the length of the stack by 1

><> is a toroidal 2D language, so the above runs in a loop until the division by zero causes the program to error out.

Alternative 15s (which work for different reasons):

'*o'l),lb%?!{oa
'*o'l),lb%?!}oa

Awk, 37 35 characters

BEGIN{for(OFS="*";++i<NF=11;)print}

Thanks to:

• Cabbie407 for combining the OFS and loop-based solutions (-2 characters)

Sample run:

bash-4.3\$ awk 'BEGIN{for(OFS="*";++i<NF=11;)print}'
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********
• I managed to shorten it by 2 bytes by combining both approaches BEGIN{for(OFS="*";++i<NF=11;)print} Commented Aug 12, 2016 at 19:13
• Wow! Great catch, @Cabbie407. Thank you. Commented Aug 13, 2016 at 10:12
• changing BEGIN to END shaves off 2 bytes, at the expense of requiring empty input (which can be justified, IMO), Try it online!
– mik
Commented Mar 15, 2021 at 12:25
• As far as I remember, that time was only allowed for languages where was absolutely no way to make them work without input, for example sed. Commented Mar 15, 2021 at 13:53
• Just found this, which says that "Programs may assume that input is empty", but I am not sure to which languages it applies.
– mik
Commented Mar 15, 2021 at 15:47

Racket, 43 36 bytes

It's nice to see friendly Racket competition on here :).

(for([i 10])(displayln"**********"))
• Can be shorter with just (i 10) rather than (i (range 10)).
– rnso
Commented Sep 6, 2016 at 23:11

QBIC, 18 bytes

[1,z:?@**********|

Explanation

[ starts a for-loop
@**********| introduces the string literal "**********" and ? prints it
z is short for 10
FOR-loops are auto-closed at the end of the program code.

If you'd like me to demonstrate more features of QBIC, upvote this: Showcase of Languages

QBIC's a work-in-progress. The current state would allow us to solve this in 15 bytes:

[|?@**********`

[ starts a FOR-loop, but the number of arguments is flexible. When | directly follows [, the FOR loop runs from 1 to 10. One argument makes it go from 1 to N, two args runs from M to N and three args introduces an increment:

[3,11,2| --> FOR a=3 TO 11 STEP 2 (or JS-style: for(a=3;a<11;a=a+2){} )
• Maybe put a link to QBIC, for those who aren't familiar with a language? Commented Aug 4, 2016 at 9:57
• @zyabin101 I've added a link. Commented Aug 4, 2016 at 10:42

Brain-Flak, 77 bytes

(((()()()()()){})<>){({}<((((((((((<>(((({})<>)){}){}()()))))))))))>[()])}{}

Try it online!

The naive approach is 91 bytes:

((()()()()()){}){({}<((((((((((((((()()()){}()){})){}{}))))))))))((()()()()()){})>[()])}{}

But this approach holds an extra ten on the alternate stack to create large numbers easier. Unfortunately, since looping is so expensive in brain-flak, it's actually shorter to just push * 10 times directly rather then setting up a loop to do it.

I'm sure this could be made shorter.

Javascript: 65 bytes

s="";for(i=1;i<=100;i++){s+="*";if(i%10==0)s+="\n"}console.log(s)

-- After it has been pointed out to me in the comments on the question, that we don't have to care about the dev-tools combining repeated output (as it can be turned off) I rewrote it as following

Javascript: 42 40 bytes

i=10;while(i--)console.log("**********")

(Saved 2 bytes thanks to @kamoroso94)

• Better change that if into ternary operator and combine it with previous concatenation: s+="*"+(i%10?"":"\n"). This way, having a single instruction, you can remove the surrounding braces too. Commented Aug 4, 2016 at 12:52
• Only do the loop to 10, and remove the if.... to add the new line. Spell out the *s and the \n in one string. Commented Aug 4, 2016 at 12:56
• Replace the for loop with i=10;while(i--) to save 2 bytes. Commented Aug 4, 2016 at 22:56
• for(i=10;i--;) is even shorter Commented Aug 4, 2016 at 23:58

JVM Bytecode, 309 bytes

Hexdump output because the entire file is hex:

00000000  ca fe ba be 00 03 00 2d  00 15 01 00 16 28 5b 4c  |.......-.....([L|
00000010  6a 61 76 61 2f 6c 61 6e  67 2f 53 74 72 69 6e 67  |java/lang/String|
00000020  3b 29 56 01 00 08 74 6f  53 74 64 6f 75 74 07 00  |;)V...toStdout..|
00000030  13 07 00 0c 01 00 26 28  4c 6a 61 76 61 2f 6c 61  |......&(Ljava/la|
00000040  6e 67 2f 53 74 72 69 6e  67 3b 29 4c 6a 61 76 61  |ng/String;)Ljava|
00000050  2f 6c 61 6e 67 2f 53 74  72 69 6e 67 3b 01 00 06  |/lang/String;...|
00000060  63 6f 6e 63 61 74 01 00  04 43 6f 64 65 01 00 04  |concat...Code...|
00000070  6d 61 69 6e 01 00 0a 53  6f 75 72 63 65 46 69 6c  |main...SourceFil|
00000080  65 0c 00 06 00 05 0c 00  02 00 12 01 00 10 6a 61  |e.............ja|
00000090  76 61 2f 6c 61 6e 67 2f  53 74 72 69 6e 67 0a 00  |va/lang/String..|
000000a0  03 00 0b 01 00 0b 2a 2a  2a 2a 2a 2a 2a 2a 2a 2a  |......**********|
000000b0  0a 08 00 0e 0a 00 04 00  0a 07 00 07 01 00 15 28  |...............(|
000000c0  4c 6a 61 76 61 2f 6c 61  6e 67 2f 53 74 72 69 6e  |Ljava/lang/Strin|
000000d0  67 3b 29 56 01 00 15 73  75 6e 2f 6d 69 73 63 2f  |g;)V...sun/misc/|
000000e0  4d 65 73 73 61 67 65 55  74 69 6c 73 01 00 00 00  |MessageUtils....|
000000f0  20 00 11 00 03 00 00 00  00 00 01 00 09 00 08 00  | ...............|
00000100  01 00 01 00 07 00 00 00  22 00 03 00 01 00 00 00  |........".......|
00000110  16 12 0f 59 b6 00 10 59  59 b6 00 10 59 b6 00 10  |...Y...YY...Y...|
00000120  b6 00 10 b8 00 0d b1 00  00 00 00 00 01 00 09 00  |................|
00000130  00 00 02 00 14                                    |.....|
00000135

To minimize size, I:

• Used the classs name "Code" to avoid putting another entry into the constant table
• Set the SourceFile to an empty string

• Used sun.misc.MessageUtils.toStdout() rather than System.out.println() to avoid an extra get static instruction, which also let me avoid having to juggle to keep it on the stack

• Used exponentially growing dups and String.concat() rather than having a loop
• Extended the class from sun.misc.MessageUtils to avoid having an entry for java.lang.Object on the stack

The jasmin assembler code used to generate this class is:

.source ""
.class Code
.super sun/misc/MessageUtils
.method public static main([Ljava/lang/String;)V
.limit stack 3
ldc "**********\n"
dup
invokevirtual java/lang/String/concat(Ljava/lang/String;)Ljava/lang/String;
dup
dup
invokevirtual java/lang/String/concat(Ljava/lang/String;)Ljava/lang/String;
dup
invokevirtual java/lang/String/concat(Ljava/lang/String;)Ljava/lang/String;
invokevirtual java/lang/String/concat(Ljava/lang/String;)Ljava/lang/String;
invokestatic sun/misc/MessageUtils/toStdout(Ljava/lang/String;)V
return
.end method

and the CFR decompiler output for this class is:

/*
* Decompiled with CFR 0_125.
*/
import sun.misc.MessageUtils;

class Code
extends MessageUtils {
public static void main(String[] arrstring) {
String string = "**********\n".concat("**********\n");
String string2 = string.concat(string);
MessageUtils.toStdout(string.concat(string2.concat(string2)));
}
}

Wumpus, 22 bytes

)"*"9&=l(&o
}@?!-)9=N}

Try it online!

Explanation:

) increment the counter
"*" push an asterisk to the stack
9&= Duplicate it 9 times (leaving 10 copies)
l(&o Print length of stack-1 times
Reflect off the end of the line and go South-West
} Turn right by 60 degrees, now going West along the second line
N  Print a newline
=  Duplicate the counter
!-)9  Check if it is equal to 10
@? If so, end the program
} Else turn right and go back to the start of the first line