Print a 10 by 10 grid of asterisks

Question

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.

Task

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 code-golf. Shortest answer in bytes wins.

Answer 1

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.

Answer 2

Racket, 43 36 bytes

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

(for([i 10])(displayln"**********"))

Answer 3

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.

Answer 4

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.

Answer 5

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

Answer 6

Rust, 49 bytes

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

My first code golf answer!

Answer 7

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

Answer 8

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

Answer 9

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?

Answer 10

GForth 36 Bytes

: A 10 0 do ." **********" CR loop ;

Answer 11

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

Answer 12

Python 3, 25 24 23 bytes

Newest answer

print(('*'*10+'\n')*10)

I'm an idjot, I don't need so many parentheses.

---

2^nd answer

print('**********\n'*10)

I shaved off a byte doing it more simply.

---

1^st 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

Answer 13

Python 3, 25 bytes

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

Answer 14

V (vim), -v 11 bytes

i*<esc>yl9pyy9p

Try it online!

Insert a * and copy it 9 times towards left and copy the line and paste it nine times.

Also I am a sock of someone :P

-4 as I am an idot.

Answer 15

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

Answer 16

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

Answer 17

Cheddar, 24 bytes

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

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

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

Then, vfuse joins by newline.

Answer 18

SpecBAS - 18 bytes

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

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

Answer 19

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!

Answer 20

><>, 35 bytes

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

Try it online!

Answer 21

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.

Answer 22

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

Answer 23

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

---

25 bytes answer

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

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

Answer 24

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

Answer 25

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:

add 5
mstore
add 3
mult
add 2
mstore
clear
add 10
while
    minc
    mstore
    mdec
    mread
    outc
    outc
    outc
    outc
    outc
    outc
    outc
    outc
    outc
    outc
    clear
    add 10
    outc
    minc
    mread
    mdec
    dec
end

Answer 26

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

Answer 27

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}'
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Answer 28

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

Answer 29

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.

Answer 30

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)