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

Leaderboard

Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.

/* Configuration */

var QUESTION_ID = 88653; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 48934; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    if (/<a/.test(lang)) lang = jQuery(lang).text();
    
    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

Answer 1

Brainfuck, 47 bytes

++++++++++[->++++>+>+<<<]>++>[-<..........>>.<]

Try it online!

++++++++++[->++++>+>+<<<]   set the tape to 40 10 10
>++>                        set the tape to 42 10 10
[-<..........>>.<]          come on

Answer 2

C (gcc), 41 39 bytes

main(i){for(;++i<puts("**********"););}

Answer 3

Bash + coreutils, 19 bytes

I prefer to repeat stuff in Bash using 'yes'.

yes **********|head

I saved 2 bytes by @Neil's suggestion. But when the directory where you are running this command does not only contain files starting with a '.' dot you need to enclose the stars * with ".

Bash + coreutils, 21 bytes

yes "**********"|head

Answer 4

Vim, 13 8 bytes

Saved 5 bytes thanks to @Lynn

qqi*␛9.o␛q9@q 

10i*␛Y9p

10i*␛ insert 10 times *, and Y9p copy the line and paste it 9 times.

Answer 5

Pyth, 6 bytes

VT*T\*

T is 10 in Pyth, Vab executes statement b a times, \* is the asterisk character constant, and multiplying (*) a string and an integer repeats that string n times. Pyth's implicit printing with V means 10 lines are printed.

Answer 6

Hexagony, 37 35 34 31

10"+}(=${";<$<1}42/.0@_=<>\;>(_

Expanded:

   1 0 " +
  } ( = $ {
 " ; < $ < 1
} 4 2 / . 0 @
 _ = < > \ ;
  > ( _ . .
   . . . .

Try it online

Basically just has two for loops counting down from ten to zero, printing out an asterisk on the inner loop, and a newline on the outer loop.

Explanation:

This program consists of three main parts: initialisation of memory, a loop which prints ten asterisks and a loop which prints a newline. The loop which prints a newline also contains the loop which prints the asterisks.

First, the code runs the totally linear memory initialisation. The code works out to be: 10"+}42. This sets the memory of the nearby edges to look like:

10 \ / 10
    |
   42

42 is the ASCII code for the asterisk character, and the two tens will be used as our loop counters. Of note is that the memory pointer is currently pointing away from the two tens, so moving backwards will put us on one of the tens.

Next, we start the astersisk printing loop. Linearly, the code looks like: ;".._(. This prints out an asterisk, moves the memory pointer backwards and to the left and finally decrements the value there. After one iteration, the memory would look like:

10 \ / 9
    |
   42

Then we hit the loop condition: the bottom-leftmost >. If the edge we just decremented is still positive we bounce around and execute a { to move us back onto the 42. Then we hit a $ and return to the beginning of the printing loop, the ;, by skipping the <. If the value was zero, we head into the other loop.

The outer loop begins by resetting the recently zeroed memory edge to ten (this is the 10 in the code, going southwest). Then, we print out this ten as an ASCII character, which is a newline. Next, we move onto the other memory edge and decrement it with {( and then execute what amounts to a bunch of noops: =${_=. Now, after one iteration of this loop, memory would look like:

 9 \ / 10
    |
   42

This time, the memory is facing outwards from the edge storing a nine in the above diagram. Next we execute the < which acts as the loop condition for the outer loop. If the value was non-zero we bounce around off of some mirrors, then begin executing meaningful instructions again after entering the top of the hexagon at the " moving southwest. This causes us to move backwards and to the left, onto the 42 again, but facing inwards. Then the = flips our direction, resetting the state properly to begin the inner loop again. If the edge was set to zero, the instruction pointer goes on a little adventure which does nothing until it exits the program.

The adventure begins by the instruction pointer venturing northeast, perilously disregarding the safety of the cardinal directions. It bravely ignores a mirror that is aligned with its diretion (/) and heroically leaps off of a trampoline ($) entirely evading the deadly trap of another, totally identical trampoline. Staring out at the emptiness of uninitialised hexagon edges, the pointer, without faltering for a moment, adds the two blank edges it faces together, setting the current edge to their sum: 0 (the edge was actually zero beforehand, but the pointer likes to believe this was pretty important). Since the edge is zero, the pointer makes a left turn at the fork in the road, walking into a mysterious forest (of hexagons). There, it finds itself disoriented, moving forwards and backwards and forwards, until it winds up at the same place in memory as it started. Thinking that the problem must be that the current edge was set to zero last time, the pointer bravely plants a 1 into the current edge. Then, the noble pointer investigates another path, one laid with... a trap! The current edge is decremented and set back to zero! The pointer, dazed by the shocking turn of events, stumbles back into the trap setting the current edge to negative one. Infuriated, the pointer attempts to return to the comparatively pleasant forest, only to notice that since the current edge is not positive, the paths have yet again shifted and the pointer finds itself walking into a cave. And by a cave, I mean the mouth of a giant hexagonal worm. Helpless, the pointer curses the sexinity with its dying breath. Also, the program ends.

Answer 7

Emacs, 10 8 keystrokes

F3 C-1 0 * ENTER F4 C-9 F4

Explanation

F3             Starts a macro recording
C-1 0 *        Apply 10 times command '*': prints 10 asterix'
ENTER          Insert new line
F4             Stops the macro record
C-9 F4         Apply 9 times the macro

Thanks to Sean for saving two keystrokes, suggesting to replace C-udigit with C-digit.

Answer 8

Jelly, 7 bytes

”*x⁵Ṅ9¡

What's going on?

”*x⁵Ṅ9¡  - No arguments
”*       - character literal, *
  x      - multiply (dyadic operation)
   ⁵     - integer literal, 10 (we have now constructed the string '**********')
    Ṅ    - Print & linefeed (monadic operation)
     9   - integer literal, 9
      ¡  - Repeat n times (n is 9 as the first Ṅ is not a repeat)

Test it on tryitonline

Answer 9

PowerShell, 14 12 bytes

,('*'*10)*10

Constructs a string of asterisks of length 10 using string multiplication. Encapsulates that in parens and feeds that into the comma-operator to construct an array. We use array multiplication to construct a 10-element array consisting of that element (i.e., a 10-element array of asterisk strings). That's left on the pipeline, and output is implicit (since the default Write-Output for an array is newline-separated, we get that for free -- thanks to @Joey for the clarification).

Older, 14 bytes

0..9|%{'*'*10}

Full program. Loops from 0 to 9 through a ForEach-Object loop |%{...}. Each iteration, we use string multiplication to create a length-10 string of *. Those resulting strings are left on the pipeline, and output at the end is implicit (since the default Write-Output for an array is newline-separated, we get that for free -- thanks to @Joey for the clarification).

Answer 10

V, 7 bytes

10é*10Ä

Try it online!

About as straightforward as an answer can be.

Explanation:

10      "10 times:
  é*    "insert an asterisk
    10Ä "make 10 copies of the current line

Non-competing version (5 bytes):

10O±*

Explanation:

10O     " Insert the following on the next ten lines:
   ±    "   10 copies of
    *   "   an asterisk

This didn't work when the challenge was posted because of a bug.

Answer 11

Jellyfish, 12 10 bytes

Thanks to Zgarb for saving 2 bytes.

P$'*
 &;10

Try it online!

Explanation

Using more conventional notation, this program represents the following expression:

P( $( &;(10), '* ) )

&; takes a single value and creates a pair with two times that value, so &;(10) gives us [10 10]. Then $ is reshape which forms a 10x10 grid of asterisks. Finally, P prints the array in "matrix format" which prints each string on its own line.

Answer 12

HTML & CSS, 104 60 bytes

p::after{content:"**********"

<p><p><p><p><p><p><p><p><p><p>

^{I'm unsure if the byte count is correct (as I'm not counting the <style> tags for CSS. The HTML could also be shortened if I used a HTML preprocessor, but I'm unsure if that's breaking rules}

Thanks to manatwork and Business Cat.

^{See my Jade entry of 36 bytes}

Answer 13

Python 2, 22 21 bytes

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

Answer 14

APL, 9 bytes

Works on all APLs ever made.

10 10⍴'*'

10 10 ten rows and ten column

⍴ cyclically repeating

'*' a star

TryAPL online!

Answer 15

MATLAB, 14 bytes

repmat('*',10)

Answer 16

Java 7, 63 bytes

void f(){for(int i=0;i++<10;)System.out.println("**********");}

Just for kicks. I can't seem to find any tricks to make this shorter. Trying to add logic for a 100-loop or returning a String instead of printing just ends up worse.

Answer 17

Ruby, 15 characters

puts [?**10]*10

Sample run:

bash-4.3$ ruby -e 'puts [?**10]*10'
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Answer 18

Notepad, 34 31 keystrokes

**********
^A^C↓^V^A^C↓^V^V^V^V

^ denotes Ctrl-<following character> keypress, ↑↓ are up and down keys, respectively.

Props to Crypto for 3 saved keystrokes.

Answer 19

Emojicode, 54 bytes

i⏩0 10**********

Explanation:

                         The beginning of program.
     i ⏩ 0 10            This is called a "range".
                          It basically starts with i=0 and increments until i=10, then exits. 
         **********      is printing class.
                          The s make the characters they surround string literals. 
                          End of range
                          End of program

Answer 20

R, 27 29 bytes

cat(rep('\r**********\n',10))

An alternate answer (34 bytes) is: cat(rep('**********',10),sep='\n')

Answer 21

05AB1E, 7 bytes

TF'*T×,

Explanation

TF      # 10 times do:
  '*T×  # repeat asterisk 10 times
      , # print with newline

Try it online

Answer 22

PHP, 32 bytes

for(;$i++<10;)echo"**********
";

(variant 32 bytes - was written with echo)

<?=str_repeat("**********
",10);

(variant 33 bytes)

<?=str_pad("",110,"**********
");

(variant 33 bytes)

for(;$i++<110;)echo$i%11?"*":"
";

(variant 35 bytes)

for(;$i++<10;)printf("%'*10s
",'');

(variant 38 bytes)

<?=($a=str_repeat)($a("*",10)."
",10);

Answer 23

MATL, 8 bytes

'*'10tX"

Try it online!

'*'   % Push '*' (string containing an asterisk)
10t   % Push 10 twice
X"    % Repeat the string 10×10 times. Implicitly display

Answer 24

Brainfuck, 46 43 bytes

+[[---<]+[-->]<]<<[--<<++..........-->>>.<]

Try it online! Requires an interpreter with a tape that is open on the left and has 8-bit cells.

The first part of this program +[[---<]+[-->]<] sets up the tape like so:

[255, 250, 245, ... 15, 10, 5, 0, 250, 240, 230, ..., 40, 30, 20, 10, 0]
                                                                      ^

This gives a 40 for outputting asterisks (*, ASCII 42), a 20 to use as a loop counter, and a 10 to use for outputting newlines.

Answer 25

JavaScript (ES6), 37 bytes

console.log(`**********
`.repeat(10))

A straightforward answer.

Answer 26

R, 35 33 32 bytes

Ô R, you're so verbose sometimes.

for(i in 1:10)cat(rep("*",10),"\n")

Interestingly, the cat function has no value (it provides NULL to STDOUT), so you can't do somethig like rep(cat(rep))), which would have been funnier !

EDIT :
New solution proposed by @LeakyNun, -2 bytes.

for(i in 1:10)cat("**********\n")

EDIT : Shortening it just by -1 byte, by @user5957401

for(i in 0:9)cat("**********\n")

Answer 27

Cheddar, 21 20 bytes

print('*'*10+'
')*10

Yet another straightforward answer.

Answer 28

Haskell, 29 bytes

putStr$[0..9]>>"**********\n"

<list1> >> <list2> makes (length <list1>) copies of <list2>.

Answer 29

Common Lisp, SBCL, 39 38 35 32 31 29 28 bytes

(format t"~10{~10@{*~}
~}"1)

Ideas for improvement are welcomed.

~10{...~} ;loops 10 times, doing inside loop and printing newline
~10@{*~}  ;loops 10 times, displaying ten "*"

Answer 30

TSQL, 24bytes

PRINT'**********'
GO 10

My first submission, please be kind with any help :)

Answer 31

Retina, 12 bytes

Byte count assumes ISO 8859-1 encoding. The leading linefeed is significant.

10$**
.
$_¶

The first stage writes a string of ten asterisks, the second stage replaces each asterisk with the entire string and a linefeed. This prints two trailing linefeeds.

Answer 32

J, 10 9 bytes

1 byte thanks to @Adám.

10 10$'*'

Online interpreter.

Explanation

10 10 specifies the dimension to the operator $ which builds an array with the specified dimensions.

Answer 33

Mathematica, 24 bytes

Print@"**********"~Do~10

It's kinda unfortunate that StringRepeat alone is 12 characters long...

Answer 34

Brainfuck, 74 bytes

first brainfuck submission ever, first reasonable length program, too

+++>>+++>>+++++++[<+<+<<+>>>>-]<[>++++++<-]<<<[->++++++++++[>>>.<<<-]>.<<]

+++>>+++>>+++++++[<+<+<<+>>>>-]<[>++++++<-] < sets tape to 10 0 10 0 42

                                           <<< moves to the first 10
            [->++++++++++[>>>.<<<-]>.<<] <
loops while the first cell of the tape is not zero:
    subtracts 1 from first cell
    sets the second cell to 10,
    loops while second cell is not zero: prints 42 cell, subtracts from second cell
    moves to third cell, prints it

Answer 35

Perl 6,  19 17  16 bytes

say '*'x 10 for ^10
put '*'x 10 for ^10
put('*'x 10)xx 10
put(\*x 10)xx 10

Try it

Explanation:

put(       # print with trailing newline
  '*' x 10 # ｢*｣ string repeated 10 times
) xx 10    # list repeat the above 10 times

Apparently \* or \(*) which is short for Whatever.new.list.Capture when coerced to a Str turns into just *.

Answer 36

Julia, 23 22 bytes

print(("*"^10*"
")^10)

See here to test on an online interpreter. Thanks @Dennis for the tip!

Answer 37

DOG, 22 bytes

10 bark "**********\n"

Prints out ********** and a newline 10 times.

Try it online! (you'll have to manually copy the code since I don't have permalink functionality yet ;_;)

Answer 38

T-SQL, 35 bytes

I used a hard carriage return in the string, which is why it wraps to the next line.

select replicate('**********
',10)

Answer 39

Sesos, 11 bytes

With many thanks to Leaky Nun for his help, and credit to his Brainf*ck answer, which inspired this one. Golfing suggestions welcome. Try It Online!

0000000: A8 24 BE EC CB 82 06 BD A7 EC 0E    .$.........

How it works

The binary file above has been generated by assembling the following SASM code.

add 42,fwd 1,add 10,fwd 1,add 10  # puts 42, 10, 10 in the register
jmp,sub 1,rwd 1                   # starts the first loop
jmp,sub 1,rwd 1,put,fwd 1,jnz     # second loop prints 42 or "*"
add 10,put,fwd 1                  # resets first loop, prints 10 or "\n"
                                  # first loop ends implicitly

Answer 40

Unary, 3584048336806633376708256331142263836115215 bytes

Can't post it here for obvious reasons.

But it's literally just 3584048336806633376708256331142263836115215 zeroes.

Answer 41

Lost, 152 116 114 105 95 91 60 57 54 bytes

66 bytes saved thanks to Jo King

v%<@(<<<<<<<<<<<<<<
\?\<>"**********h^"
/<>9v+^?:)-1+-

Try it online!

This program is unbelievably convoluted. I might explain it when I finished golfing it. For now here is a rough overview.

Explanations

To the left we have

v%
\?\<

which catches and cleans the ip. It exits when ? fails to jump over \ pushing the ip down to

  (
  >
>9v

which puts a counter set at 9 into the scope.

Then we push the string "**********h^". The ip wraps around to the other side and back down onto the next line moving backwards. The +- combines the last two characters to turn the h^ to a newline.

From here +^?:)-1 subtracts one from the counter or deflects the counter up to the top row if it is already zero. On its way to the top row * combines the two junk values we have lying around once on the top row we get rid of the last value with ( and exit with @.

Answer 42

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 43

Python 2, 21 Bytes

exec"print'**'*5;"*10

Works in a similar way to Destructible Watermelon's Python 3 solution.

Answer 44

CJam, 9 8 bytes

Thanks to Lynn for saving 1 byte.

'*A*N]A*

Try it online!

Explanation

'*A*    e# Create a string of 10 asterisks.
N       e# Push a linefeed.
]       e# Wrap both in a list.
A*      e# Repeat 10 times.

Answer 45

///, 25 bytes

/a/**********
/aaaaaaaaaa

Try it online!

A simple replace command.

Answer 46

><>, 28 bytes

av
->:?!;av>~1ao
:-1o*76<^!?

Try it online!

Answer 47

Jelly, 8 bytes

”*x³s⁵j⁷

Try it online!

How it works

”*x³s⁵j⁷  Main link. No arguments.

”*        Yield '*'.
  x³      Repeat the character 100 times.
    s⁵    Split into chunks of length 10.
      j⁷  Join, separating by linefeeds.

Answer 48

Befunge, 39 bytes

52*>52* v
,1-:!#v_>67*
#@_v  >$52*,1-:!

Try it here!

Answer 49

Actually, 7 bytes

9u;'**n

Try it online!

Explanation:

9u;'**n
9u;      push two copies of 10
   '*    push "*"
     *   multiply by one of the copies, yielding "**********"
      n  push 10 total copies of the string

Answer 50

Lua 36 bytes

print((("*"):rep(10).."\n"):rep(10))

There is already a Lua answer, but his was however not a full program that would print output and this one is shorter.

I wanted to post it as a comment to that one, but I don't have the reputation yet.

Answer 51

PowerShell, 14 bytes

0..9|%{'*'*10}

Items exiting the pipeline are automatically printed on individual lines by the default PowerShell host.

Hooray for * doing string repetition.

Answer 52

Fuzzy Octo Guacamole, 15 bytes

'*'25**25*!_[X]

Explanation:

'*'              # Push '*'
   25*           # Push 10
      *          # Multiply, leaves '**********' ('*'*10)
       25*!_     # Sets the for-loop counter to 10 (2*5)
            [X]  # Iterates 10 times and prints '********' each time

Answer 53

Charcoal, 4 bytes (non-competing)

The language is newer than the question.

Ｇ+α*

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 54

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 55

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 56

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

Answer 57

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

Answer 58

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 59

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 60

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 61

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 62

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 63

><>, 35 bytes

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

Try it online!

Answer 64

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)

Answer 65

Racket, 43 36 bytes

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

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

Answer 66

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 67

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 68

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 69

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

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 71

Cubix, 26 bytes (non-competing)

Not a competing entry as the stack commands used post-date the question.

'*u.NNw\./>rroq(?;(?@....N

Try it here

This maps onto a side length 3 cube. Now to try and get rid of some of the no-ops and try and fit it on a side length 2 cube.

      ' * u
      . N N
      w \ .
/ > r r o q ( ? ; ( ? @
. . . . N . . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

• / Redirect the flow to the top face
• '*u Add an * to the stack and u-turn
• NN Add a couple of 10's to the stack as counters
• >rroq Rotate the stack to bring the * to the top, output and push it to the bottom
• (? Decrement the top counter (character) and test.
  • If zero ;( pop from stack, decrement next counter (line), otherwise go around to previous command set.
  • ?@ Test the counter (line) and exit if zero
• No\w Add a 10 to the stack as a linefeed and a new character counter, output it and redirect back to the > to start the sequence again.

Answer 72

Lua, 34 bytes

for i=1,10 do print"**********"end

Answer 73

Google Sheets, 31 23 bytes

Code:

In cell A1 (12 bytes):

=REPT(B1,10)

In cell B1 (11 bytes):

**********        # Contains New Line
                  # <--

Result:

Previous Attempt #1 (31 bytes):

=REPT(REPT("*",10)&CHAR(10),10)

Previous Attempt #2 (also 31 bytes):

=REPT("**********"&CHAR(10),10)

Answer 74

Braingolf, 18 bytes [non-competing]

8V9R#*[.]#
[R&!@v]

Try it online!

Explanation:

8V9R#*[.]#\n[R&!@v]
8                    Push 8
 V                   Create stack2 and switch to it
  9                  Push 9
   R                 Return to stack1
    #*               Push codepoint of *
      [.]            Do-while loop, will run 9 times due to the 8 pushed at the start
       .             Duplicate last item on stack
         #\n         Push codepoint of newline
            [R...v]  Do-while loop, uses stack2 for loop counting
                     Will run 10 times due to the 9 pushed at the start
              &!@    Print entire stack1 without popping

Answer 75

Javascript (REPL), 27 bytes, Old is 32 bytes. Thanks to @Peter

('**********\n').repeat(10)

Answer 76

Befunge-93 (PyFunge), 28 bytes

#<90v0-1_@#:,
#^_ >1+"*",:9`

Try it online!

Answer 77

Kotlin (script), 32 bytes

print("**********\n".repeat(10))

Try it online!

Run this locally as a standalone program by

• installing Kotlin
• saving the source to a .kts file
• run with kotlinc -script myfile.kts

This does not seem to work on TIO, for whatever reason, which is why I had to include the header/footer.

Answer 78

Kotlin, 62 bytes

fun main(a:Array<String>){for(i in 0..9)println("**********")}

Try it online!

Answer 79

Java (OpenJDK 8), 61 bytes

static{for(int i=0;i++<10;)System.out.println("**********");}

Try it online!

Answer 80

05AB1E, 9, 8 bytes

Tƒ,TF'*+

my first golfing answer so any tips are welcome

Try it online!

Answer 81

MathGolf, 6 bytes

⌂♀*♂/n

Try it online!

Explanation

⌂       Push "*"
 ♀*     Multiply by 100
   ♂/   Divide into chunks of 10
     n  Join with newline

With an output control flag this could be 5 bytes, but I don't have that yet.

Answer 82

Keg, 10 bytes

(
|(
|\*)
)

Explanation

(\n|           Start for loop iterating 10 times
    (\n|       Start for loop iterating 10 times
        \*     Push an asterisk
          )    End loop
           \n  Push a newline

Try it online!

Answer 83

Rust, 49 bytes

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

My first code golf answer!

Answer 84

Python 3, 29 23 bytes

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

Thanks to orlp for shaving off 6 bytes.

Answer 85

Golisp, 34 bytes

for[range@10{(_)writeln@*["**"5]}]

Due to a "bug", I can't concatenate strings...

Answer 86

SpecBAS - 18 bytes

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

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

Answer 87

C#, 79 bytes

class P{void Main(){for(int i=0;i++<10;)System.Console.Write("**********\n");}}

Answer 88

golflua, 22 characters

~@i=0,9 w"**********"$

Sample run:

bash-4.3$ golflua -e '~@i=0,9 w"**********"$'
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Answer 89

S.I.L.O.S 45 bytes

All whitespace necessary due to my poor interpreter design.

a = 10
lbla
printLine **********
a - 1
if a a

Try it Online!

Answer 90

Notepad++, ??? keystrokes

I have no idea how to score this, but I decided to give it a shot since there's an answer on Notepad.

Here's the sequence:

* * * * * CTRL (hold) A D → D D D D D D D D D

Answer 91

Bash (pure), 30 bytes

printf '%.s**********
' {0..9}

Test it on Ideone.

How it works

Before calling the shell built-in printf, Bash expands the glob {0..9} to 0 1 2 3 4 5 6 7 8 9.

The format string

%.s**********
 

specifies a string whose first 0 characters are included in the output (%.s), followed by ten asterisks and a linefeed. printf repeats the format string as many times as needed to consume all arguments. Since .%s is an empty string, this results in the desired output.

Answer 92

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 93

Clojure, 38 bytes

(apply print(repeat 10"**********\n"))

Simple enough

Answer 94

Ruby, 26 20 bytes

10.times{puts'*'*10}

Try it online!

Explanation

Runs 10 times; each time, it prints * (10 times), with an automatic line break at the end.

Kudos to OrangeFlash81 for saving me 6 bytes.

Answer 95

Scheme, 51 Bytes

(map (lambda (n)(display "**********\n"))(iota 10))

Answer 96

PyMin, 14 bytes / 10 characters (non-competing)

»("*"Ҁ+ѿ)Ҁ

Non-competing because I added a few things.

Shorter version with v0.5:

13 bytes / 9 characters:

»("*"ҀƜ)Ҁ

Answer 97

Xtend, 33 bytes

[for(_:0..9)print('**********
')]

... a Java dialect; [] is a lambda definition

Answer 98

Deadfish ~, 24 bytes

{{iiii}ii{c}{ddd}ddc{d}}

how it works:

{foo} does foo exactly ten times. first, it starts a ten loop, in this loop, it sets the counter to 42, prints it ten times (as char (asterisk)), decrements it to 10, prints it (newline), subtracts 10, then loops again, doing this 10 times.

Answer 99

SmileBASIC, 19 bytes

?("*"*10+" "*40)*10

SB has a 50 character wide console, so printing 40 spaces after the 10 asterisks will bring the cursor to the beginning of the next line

Answer 100

Tcl, 25 bytes

time {puts **********} 10

Try it online!

Answer 101

Carrot, 10 9 bytes, non-competing

*^*9^
^*9

Try it online! (copy & paste only)

*^                //pushes "*" to the stack
*9                //add 9 more copies of itself
                  //stack = "**********"
^\n^              //append a newline to it
*9                //add 9 more copies of the resulting string
                  //implicit output

Answer 102

Japt, 9 bytes

Ao ç*pA)·

Test it online! This is, in fact, competing.

How it works

Ao ç*pA)·  // Implicit: A = 10
Ao         // Create the range [0..10).
   ç*pA)   // Fill with "*".repeat(A).
        ·  // Join with newlines. Implicitly print.

Answer 103

tinylisp, 62 bytes

(d A(q((n *)(i n(i(disp *)0(A(s n 1)*))*))))
(A 9(q **********

Try it online!

We define a function A with two parameters: n is the number of iterations, and * is a row of asterisks (it will always be ten of them, but it saves bytes to pass that as an argument). If n is truthy (nonzero), we display the asterisk row (with trailing newline) and recurse with n minus 1. If n is falsey (zero), we simply return the asterisk row.

Calling the function with n = 9 results in 9 disp calls; the return value of the function is then displayed, giving us our 10th row.

Answer 104

Syms 1.3, 17 bytes (noncompeting)

{*}10;*{
}~+10;*>

Explanation:

{*}10;*{\n}~+10;*>
{*}                 Pushes "*"
   10;*             Repeats it 10 times.
       {\n}         Pushes \n.
           ~+       Adds it to the end of "*"*10.
             10;*   Repeats it 10 times.
                 >  Outputs.

Answer 105

R 34 bytes

While not being elegant at all, it makes what expected in not that many bytes...

cat(rep("**********",10),sep="\n")

Answer 106

LibreLogo, 21 bytes

Code:

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

Result:

Answer 107

MATLAB / Octave, 23 bytes

Code:

m=[eye(10) ''];m(:)='*'

Try It Online!

Result:

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

Answer 108

Triangular (non-competing) , 28 bytes

A\(A@1].p-p..pA@...](/*76-1<

Try it online!

Expanded version:

       A 
      \ ( 
     A @ 1 
    ] . p - 
   p . . p A 
  @ . . . ] ( 
 / * 7 6 - 1 < 

Commands executed, excluding directional commands:

A(1-A(1-67*@p]A@pp]

Answer 109

Kotlin, 41 bytes

Submission

fun f()=(0..9).map{println("**********")}

Test

fun f()=(0..9).map{println("**********")}

fun main(args: Array<String>) {
  f()
}

TryItOnline

Link

Answer 110

Java 8, 73 62 bytes

o is a String passed to a Consumer

o->System.out.print("**********".replace("*", "**********\n"))

Answer 111

R: 33 bytes

write.matrix(matrix("*",10,10))

This does assume that you've loaded the MASS library.

Answer 112

Powershell, 78 bytes

$h=@();$v=@();1..10|% $_{$h+="*"};$i=0;Do{$v+=$h-join'';$i++}while($i-ne10);$v

Code explode:

$numbers = 1..10
$horArray = @()
$verArray = @()

Foreach ($number in $numbers){
    $horArray += "*"
}

$i = 0
Do {
    $verArray += $horArray -join ''
    $i++
}
while ($i -ne 10)
$verArray

Answer 113

Befunge, 33 bytes

55+:v
_v#:<,"*"-1
^_1-:!#@_55+:,1

Try It Online

How it works

55+:v
....<... Initialises the stack with two 10s as counters.
........ The first is for the outer loop, and the second is the inner

.....
_v#:<... Checks whether the inner counter is 0
._......

.....           If so, decrement the outer counter
_..........       If the outer counter is 0, exit the program
^_1-:!#@_55+:,1   Else print a newline and reset the outer loop counter

.....
.....,"*"-1 Else, decrement the inner counter and print an *
........... And run the inner loop again

Answer 114

Befunge-98, 19 15 bytes

a1_@#:-,ka:k8*'

Try It Online

First time using 98 instead of 93. Both the k and ' commands are immensely useful.

Answer 115

Forth (gforth), 36 34 bytes

: f 9 for ." **********" cr next ;

Try it online!

-2 bytes thanks to @bubbler

Explanation

 10 0            \ put 10 and 0 on the stack
 do              \ begin a loop from 0 to 10 (0 inclusive 10 exclusive)
 ." **********"  \ print the string literal ********** (the initial space is required because forth words are space separated, and ." is not an exception)
 cr              \ print out a new line character
 loop            \ end the loop

Answer 116

Io, 32 bytes

10repeat("*"repeated(10)println)

Try it online!

Answer 117

Canvas, 5 bytes

*Ａ×Ａ＊

Try it online!

With notes (not valid code, as Canvas does not support comments):

          Print the following (implicit)
*         The string "*"
 Ａ×      Duplicated 10 times horizontally
    Ａ＊  Duplicated 10 times vertically

Answer 118

Julia, 23 bytes

print(("*"^10*"\n")^10)

Explanation:

print(                ) # Print
      (           )     # A string consisting of 
       "*"^10           # "*" duplicated 10 times
             *"\n"      # then concatenated to a newline
                   ^10  # which is then duplicated 10 times

Answer 119

Japt -R, 5 bytes

AÆAî*

Test it

Answer 120

Japt -R, 5 bytes

AÆAç*

Try it online!

Unpacked & How it works

Ao@Aç*

Ao@    Map range(10) with a function that returns...
Aç*      "*" repeated 10 times.
       `-R` flag joins the result array with "\n"
       Implicit output

Answer 121

Q'Nial7, 15 bytes

10 10reshape'*'               #create atom '*', reshape to 10 by 10 matrix

Answer 122

Python 2, 20 bytes

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

I didn't know you could remove the space between print and the string.

Answer 123

Z80Golf, 14 bytes

00000000: 0a4f 3e2a 46ff 10fd 7eff 0d20 f576       .O>*F...~.. .v

Try it online!

Disassembly

start:
  ld a, (bc)  ; 0a
  ld c, a     ; 4f
loop1:
  ld a, '*'   ; 3e 2a
  ld b, (hl)  ; 46
loop2:
  rst $38     ; ff
  djnz loop2  ; 10 fd
  ld a, (hl)  ; 7e
  rst $38     ; ff
  dec c       ; 0d
  jr nz, loop1  ; 20 f5
  halt        ; 76

Golfing nested loops

Since a is the parameter to putchar, I used b and c for loop counters. The loop constructs are

  ld b, ... ; 1 or 2 bytes
loop:
  (loop content)
  djnz loop ; 2 bytes

and

  ld c, ... ; 1 or 2 bytes
loop:
  (loop content)
  dec c     ; 1 bytes
  jr nz, loop ; 2 bytes

This combination of 2-level nested loops is optimal in Z80Golf.

Reusing the first instruction as data

The first byte 0a is located at memory address $0000. Since hl is always zero in this program, we can use the one-byte instruction ld r, (hl) whenever we need the constant 0a, instead of the two-byte ld r, $0a.

In this particular challenge, the byte $0a has three uses: the outer loop, the inner loop, and the newline character. The byte as an instruction is not particularly useful, so we save two bytes here.

Answer 124

Matlab, 17 bytes

@()repmat('*',10)

Try it Online

Answer 125

MBASIC, 32 bytes

1 WIDTH 10:PRINT STRING$(100,42)

RUN
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

No loop. Just printing 100 asterisks into a 10 character wide terminal to force line wraps.

There's no MBASIC on TIO, so I've linked the reference manual.

Answer 126

Shakespeare Programming Language, 387 bytes

,.Ajax,.Ford,.Act I:.Scene I:.[Exeunt][Enter Ajax and Ford]Ford:You be twice the sum ofa cat twice twice the sum ofa cat a big big cat.Speak thy.Speak thy.Speak thy.Speak thy.Speak thy.Speak thy.Speak thy.Speak thy.Speak thy.Speak thy.You be twice the sum ofa cat a big big cat.Speak thy.Ajax:You be the sum ofyou a cat.Be you nicer the sum ofa cat a big big big cat?If notlet usScene I.

Try it online!

Answer 127

q, 12 bytes

10 10#get"*" / a 10x10 matrix

Answer 128

Gol><>, 9 bytes

aFa:R`*|H

There is a trailing newline, but the specs say it is okay. Below is a version that doesn't have a trailing new line, but adds on 2 extra bytes.

aFaR`*a|~rH

Try it online!

Answer 129

R 33 bytes

cat(rep('**********',10),sep='
')

Try it online

I believe this is shorter than the other R answers on this question.

Answer 130

C# (.NET Core), 53 bytes

Brand new to code golf, is this type of format allowed to be used (Usage of the header section / footer section)?

for(int i=0;i<10;i++){Console.Write("**********\n");}

Try it online!

Answer 131

CSS only, 157 109 bytes

Inspired by hd answer, probably 1:1 reproduced from OP question (except background color)

body:after,body:before{white-space:pre;content:'**********\A**********\A**********\A**********\A**********\A'

Answer 132

Perl 5, 18 Bytes

say'*'x10for 1..10

Requires the -E flags, as in:

perl -E "say'*'x10for 1..10"

Answer 133

PHP, 26 bytes

Just used a compressed string. Has raw output of gzdeflate and contains unprintable binary data, so the code itself and direct TIO link cannot be posted here, but here is a hex dump of it:

000000  3c 3f 3d 67 7a 69 6e 66 6c 61 74 65 28 22 d3 d2  <?=gzinflate("..
000010  82 01 2e 2d 9a 33 01 22 29 3b                    ...-.3.");

Save it as a binary file then execute it like this: php asterisks.php

TIO which uses bash to run this file: Try it online!

Answer 134

APL (Dyalog Classic), 11 bytes

⎕←10 10⍴'*'

Try it online!

Explanation

⎕←          ⍝ Output
   10 10⍴'*' ⍝ The asterisk reshaped into a 10 by 10 grid

Answer 135

JAPT, 12 bytes

'*
pA)+R
VpA

Japt sets vars automatically, so '* sets U to "*" pA)+R prints U out A(10) times. And adds a new line (+R). All this is set to V. VpA prints V out A times

In Regular JS is

U = "*";
V = (U.p(A)) + R;
V.p(A)

Answer 136

naz, 44 40 bytes

1x1f6a7m9o1o4d1o0m0x1f1f1f1f1f1f1f1f1f1f

This is another one of those cases where a truly recursive definition would actually use more bytes than just repeating the f instruction.

Edit: Saved 4 bytes by using division instead of subtraction.

Explanation (with 0x commands removed)

1x1f                   # Function 1
    6a7m9o1o           # Output 10 asterisks
            4d1o       # Output a newline
                0m     # Reset the register
1f1f1f1f1f1f1f1f1f1f   # Call function 1 ten times

Answer 137

W d, 7 4 bytes

°♣∩x

Uncompressed

T:s*E

Explanation

T     % Push a 10 onto the stack
 :    % Copy the top of stack
  s*  % Generate 10 asterisks
    E % Foreach in the range 1 .. 10,
      % Print 10 asterisks following a newline

Answer 138

Scratch 3.0, 4 blocks/65 bytes

SB Syntax:

when gf clicked
delete all of[o v
repeat(10
add[**********]to[o v

Picture:

Try it online Scratch!

I'm quite proud of the block count here, because it matches the byte counts of the winning answers. But SB Syntax ruined things for me. (´• ╭╮ •`)

Answer 139

Racket, 52 bytes

(display(string-join(make-list 10"**********")"\n"))

If you're fine with just returning the string and not printing it, you can forego the (display) for a score of 41 bytes.

An alternate answer (longer at 73 bytes, but I like it better personally):

(display(build-string 110(λ(n)(if(eq?(remainder n 10)0)#\newline #\*))))

Answer 140

Batch, 41 bytes

@for /l %%i in (0,1,9)do @echo **********

Answer 141

Pyke, 6 bytes

TVT\**

Try it here!

       - (T = 10)
TV     - repeat(10):
  T\** -  10*"*"

Answer 142

Frink, 40 39 Bytes

for r=0 to 9
  println[repeat["*",10]]

-1 Byte @LeakNun

Answer 143

BASH, 46 bytes

for((n=0;n<10;n++));do echo "**********"; done

Answer 144

C++, 75 bytes

#include<cstdio>
int main(){for(int i=0;i<10;++i)std::puts("**********");}

Answer 145

Maple 30 bytes

printf(cat("**********\n"$10))

Answer 146

C, 84 bytes

#include<stdio>
int main(){int i;for(i=0;i<10;i++){printf("**********\n");return 0;}

If anyone can improve the answer, I'd appreciate it. I'm not trying to compete, it's just been simply ages since I've coded C or C++ and this challenge looked fun.

Answer 147

Sprects, 22 bytes

#eeep#eppp#pqqq*
#q***

Note: The interpreter uses U+0020 instead of U+0010.

Answer 148

T-SQL, 50 bytes

print replicate(replicate('*',10)+char(10),10)

Answer 149

C, 47 bytes

main(i){while(i<111)putchar(10|!!(i++%11)<<5);}

Try it online.

Not as compact as the other C answer (putchar is such a long name!), but I don't use the asterisk character in my program. It treats the output as a 11 by 10 grid, where the 11th character is the newline. It then computes the ASCII for '*' (10 + 32 = 42) or '\n' (10) for each position.

I could save one byte with this approach if I were to change the character expression to: 42-!(i++%11)*32, but that would require an asterisk.

Answer 150

EXCEL, 26 bytes.

=REPT("**********[ae]",10)

Can go into any cell.

Answer 151

tinyAll, 17 bytes

The current version (untouched for a LONG time), is extremelly broken, but works enough for this challenge.

P'*Ra_P"
[:;]"R9_

Basically:

• Pass * to the R(repeat) function
• Repeat it a (10) times
• Output it (_)
• Pass the output (;), through string interpolation, prefixed by a newline
• To the R function
• And repeat 9 more times
• And display the result

---

A boring alternative, with the same byte count:

P"**********
"Ra_

Translating:

• Pass "********** (newline)
• To the R function, to repeat a (10) times
• And output the result (_)

---

Try it:

// Commit https://github.com/ismael-miguel/tinyall/commit/2589837678f4b6556d1bd22f163255e2e058808e#diff-65af36bb0dc600cbc7a54816dcda57fd
(function(window, undefined) {
 var funcs = {
  //echo
  '_':function(value, data){
   var tmp = data.out + (value === undefined ? data.last : value);
   data.vars[';'] = data.out = tmp;
   return tmp;
  },
  //array
  A:function(value, data){
   var split_value = (value || '').split(/(\-?\d+(?:\.\d*)?(?:[eE][\-+]?\d+)?|'(?:\\'|[^']*)*'),?/);
   var final_value = [];
   for(var i = 0, l = split_value.length; i<l; i++)
   {
    if(split_value[i][0] == '\'')
    {
     final_value[final_value.length] = split_value[i].replace(/^'(.*)'$/,'$1').replace(/\\'/g,'\'');
    }
    else if(split_value[i]/1 || split_value[i] == '0')
    {
     final_value[final_value.length] = +split_value[i];
    }
   }
   
   return final_value;
  },
  //comparison functions
  C:function(value, data){
   
  },
  D:function(value, data){
   
   var debug = {
    value: value,
    type: typeof value,
    memory: data
   }
   
   if(console && console.log)
   {
    console.log(debug);
   }
   
   return value;
  },
  //eval
  E:function(value, data){
   run_code(value, data);
  },
  //flip the value around
  F:function(value, data){
   if(('object' === typeof value) && value.reverse)
   {
    return value.reverse();
   }
   else
   {
    return value.toString().split('').reverse().join('');
   }
  },
  //hello worlds
  H:function(value) {
   return 'hH'[value&1]
    +'ello'
    +(value&2?',':'')
    +' '
    +('wW'[+!!(value&4)])
    +'orld'
    +(value&8?'!':'')
    +(value&16?'\n':'');
  },
  //math functions
  M:function(value, data){
   
  },
  //not (inverts values/casing)
  N:function(value) {
   switch(typeof value)
   {
    case 'boolean':
     return !value;
    case 'number':
     return -value;
    case 'string':
     var tmp = '';
     for(var i = 0, l = value.length; i < l; i++)
     {
      if(value[i] >= 'a' && value[i] <= 'z')
      {
       tmp += String.fromCharCode(value.charCodeAt(i) - 32);
      }
      else if(value[i] >= 'A' && value[i] <= 'Z')
      {
       tmp += String.fromCharCode(value.charCodeAt(i) + 32);
      }
      else
      {
       tmp += value[i];
      }
     }
     return tmp;
    default:
     return 0;
   }
  },
  //passthrough
  P:function(value) {
   return value;
  },
  //repeat
  R:function(value, data){
   var tmp = '';
   
   if(value > 0)
   {
    while(value--)
    {
     tmp += data.last;
    }
   }
   
   return tmp;
  },
  //string functions
  S:function(value, data){
   var methods = {
    t:function(value){
     return value.replace(/^\s+/,'').replace(/\s+$/,'');
    },
    u:function(value){
     return value.toUpperCase();
    },
    T:function(value ){
     
    },
    R:function(value){
     
    }
   };
   
   var tmp = data.last.toString();
   for(var i = 0, l = value.length; i < l; i++)
   {
    tmp = value[i] in methods ? methods[value[i]](tmp, value, i) : '';
   }
  
   return tmp;
  },
  //clears output
  Z:function(value, data) {
   return data.vars[';'] = data.out = 0;
  }
 };
 
 var expand_string = function(value, data){
  
  return value.replace(
   /\[:(?:([A-Z_])(.)?|([^A-Z_'"]))\]/g,
   function(_, func, arg, value){
    if(func)
    {
     return funcs[func](get_value(arg, data, true), data);
    }
    else
    {
     return get_value(value, data, true);
    }
   }
  );
  
 };
 
 var get_value = function(value, data, recursion) {
  
  if(value === null || value === undefined || value === ' ')
  {
   return undefined;
  }
  
  var x = (value || '').toString();
  
  if(/^\-?\d+(?:\.\d*)?(?:[eE][\-+]?\d+)?$/.test(x))
  {
   //returns a number
   return +x;
  }
  else if(/^[a-z]$/.test(x))
  {
   //returns a number between 10-43
   return (x in data.vars) ? data.vars[x] : x.charCodeAt(0) - 87;
  }
  else if(x[0] == '\'')
  {
   return x[1];
  }
  else if(x[0] == '"' && x.length >= 2)
  {
   var sub = x.substr(1, x.length - 2);
   
   return recursion ? sub : expand_string(sub, data);
  }
  else
  {
   return data.vars[x];
  }
 };
 
 var run_code = function(code, memory){
  
  if(!code || /^[a-z\d]$/.test(code))
  {
   memory.out = funcs.H(get_value(code, memory));
  }
  else
  {
   code.toString().replace(
    // /(?:([^A-Z_:'"])=)?([A-Z_])(?::('.|"[^"]*"|-?\d+|.))?/g,
    /(?:([^A-Z_'"])=)?([A-Z_])(?:('.|"[^"]*"|-?\d+|[^A-Z_'"]))?/g,
    function(_, name, func, value){
     
     memory.vars[name || ':'] = memory.last = (funcs[func] || noop)( value ? get_value(value, memory) : memory.last, memory);
     
     return '';
    }
   );
  }
 }
 
 var noop = function(){};
 
 window.tinyAll=function(code, input) {
  var data = {
   out: '',
   last: 0,
   input: input || 0,
   vars: {
    //version
    '|':'0.3',
    //input
    ':':input || 0,
    //output
    ';':0,
    //code
    '.':(code || '').toString()
   }
  };
  
  run_code(data.vars['.'], data);
  
  return data.out || 0;
 };
})(Function('return this')());



//RUN THE CODE!!!
//\n instead of a real newline, but works the same
console.log(tinyAll('P\'*Ra_P"\n[:;]"R9_'));
console.log(tinyAll('P"**********\n"Ra_'));

Answer 152

PostgreSQL, 39 bytes

select repeat('**********'||chr(13),10)

Answer 153

99, 137 bytes

99999 9 9
9999 99999 9
999 99 9
999999 99 9




99 99 9 99 9 99 9 99 9999
99
99
99
99
99
99
99
99
99
99
999999
999 999 9
 99 999
 9 99999

Try it online!

Answer 154

jq, 24 18 characters

(16 characters code + 2 characters command line option.)

range(10)|"*"*10

Thanks to:

• Leaky Nun for suggesting to use string multiplication (-6 characters)

Sample run:

bash-4.3$ jq -nr 'range(10)|"*"*10'
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

On-line test (Passing -r through URL is not supported – check Raw Output yourself.)

Answer 155

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 156

C#, 52 50 49 bytes

49 bytes : 'for(int i=0;i++<10;)Console.Write("**********\n")' (Thanks to Csharpie)

50 bytes : for(int i=0;i<10;i++)Console.Write("**********\n")

52 bytes : for(int i=0;i<10;i++)Console.WriteLine("**********")

Close with 70 bytes : Console.WriteLine(String.Concat(Enumerable.Repeat("**********\n",10)))

edit : Test here : Online C# Interactive compiler.

P.S : C# Interactive is there in Visual Studio/Roslyn for a long time, no one said the answer needs to compile into an executable, or that C# is limited to .NET's verbose BCL functions or that C# is limited to Windows. csi.exe would just be same in functionality as other (interpreted) languages' interpreters do (like PowerShell), which is the beauty of C#.

Answer 157

Go, 84 characters

package main;import"fmt";func main(){for j:=0;j<10;j++{fmt.Println("**********");}}

Sample run:

bash$ go build && ./golf
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Answer 158

Underload, 22 bytes

(*****):*(
)*:*::*:**S

Answer 159

MarioLANG, 101 99 95 bytes

Saved 2 bytes thanks to Martin Ender.

Try it Online!

+
++++)+<......(<
++====".======"
+>)+(()>...(.
+====(-=====) -
+++++[!))++ )[!
======#=======#

The left half sets the tape to 10 40 10

The second half increases the 40 to 42, then prints the 42 (*) 10 times, and a newline, and repeats that 10 times.

Answer 160

Gibberish, 29 bytes

56ea1[[**********]eo1su1fu]gw

Explanation:

56ea1[[**********]eo1su1fu]gw |
56                            | push 5 and 6
  e                           | switch to first instruction set
   a                          | add a, b
    1                         | push 1
     [[**********]eo1su1fu]   | push string
                           g  | switch to set 3
                            w | while a is 1 execute string as code
      [**********]            | push ten asterisks
                  e           | switch to set 1
                   o          | print a
                    1s        | subtract one
                      u       | duplicate a
                       1      | push 1
                        f     | switch to set 2
                         u    | pop a, b push 1 if a > b else push 0

Answer 161

Neoscript, 39 bytes

each _=0:[]:9console:log("**********");

Answer 162

VBA, 31 bytes

for i=0to 9:?"**********":next

in the VBA Immediate window. I couldn't find any byte-saving tricks beyond this. My best non-loop version was 45 bytes:

?replace("..........",".","**********"&vblf)

Answer 163

Vitsy, 13 bytes

I'm late to the party. :c

a\[aa\['*']Z]

Try it online!

Answer 164

PHP 46 bytes

<?php
for($i=-2;++$i<9;)echo "**********\n";?>

I think this don't needs explanation.

Answer 165

Swift, 35 Bytes

for _ in 0...9{print("**********")}

Answer 166

Brachylog, 15 bytes

9ye,"*":9jw@Nw\

Try it online!

Explanation

This exploits backtracking to loop; we create ten useless choice points at the beginning so that it writes ten times the string "**********\n".

9ye,         Pick a number between 0 and 9 (there are thus 10 choice points here)
"*":9j       Concatenate "*" 9 times to itself
w@Nw         Write that string and write a line break
\            False (trigger backtracking: pich another one of the ten numbers)

Answer 167

Convex, 10 bytes

A'**{A*N}%

Try it online!

Answer 168

Fortran, 68 51 49 bytes

Skimmed off 17 bytes, because who needs indents and spaces?

-2 bytes thanks to @Joffan

As a tribute to senior and the fact there was no Fortran answer yet. Well, now I know why: this is a pretty hard language to golf! Just one or two indents already take up more bytes than the shortest answer here :)).

program T
do i=0,9
print*,('*',j=0,9)
end do
end

Try it! (ideone)

I tried golfing it down by introducing a nested 'implied' do loop, but the newline character wasn't available until Fortran 2003. Also, it's insanely verbose...

Answer 169

Grocery List, 72 bytes

G

number ten
v
z
v
P
s
u
c
l
number ten
l
b
c
p
u
n
s
e
x
u
c
p
b
n
s
e

Try it online

Answer 170

LaTeX, 122 110 105 bytes

-12 bytes thanks to @Leaky Nun
-5 bytes by changing package & document type

Or, if I'm allowed to skip the document class definition & setup, and just count the package import and for-loop code: 55 bytes.

I still need to check if there's another package that has a shorter loop syntax, but for now, this simply uses pgffor (from tikz) and a foreach:

\documentclass{book}\usepackage{tikz}\begin{document}\foreach\n in{0,...,9}{**********\par}\end{document}

Ungolfed:

\documentclass{book}
\usepackage{tikz}
\begin{document}
\foreach\n in{0,...,9}{**********\par}
\end{document}

Output (w/ free page number :) ):

Answer 171

TI-Basic, 21 bytes

For(I,0,9
Disp "**********
End

Answer 172

GolfScript, 27 bytes

0{"**********\n"\1+.10<}do;

Try it online!

Explanation

0              # Push 0 onto the stack: counter
{
"**********\n" # Push 10 '*' and a newline character
\              # Moves the counter onto the stack
1+             # Increments the counter
.10<           # Check if it's smaller than 10
}do;           # Repeat until counter equals 10

Answer 173

GNU sed, 27 bytes

s/^/**********/;h;H;G;H;g;G

To add to the diversity of languages used, I present a sed solution. The code works as follows, indicating the number of sets of 10 asterisks in pattern space and then in hold space:

s/^/**********/        # 10 asterisks are added to pattern space      (1 0)
h                      # overwrites hold space with pattern space     (1 1)
H                      # appends pattern space to hold space          (1 2)
G                      # appends hold space to pattern space          (3 2)
H                      #                                              (3 5)
g                      # overwrites pattern space with hold space     (5 5)
G                      # after G, pattern space is printed on exit   (10 5)

Answer 174

Thue, 30 bytes

%::=~**********
::=
%%%%%%%%%%

Try it online!

---

Thue, 53 bytes

%::=,*,*
>*::=>[
>,::=>]]
[::=~
]::=~*****
::=
>%%%%%

Uses the convention that "when a string is sent to the output stream, no newline is printed at the end, except if the string is empty, in which case a newline is all that is printed." This is not followed by the TIO interpreter.

Answer 175

S.I.L.O.S, 41 bytes

Never used S.I.L.O.S before, can probably be golfed more.

EDIT: Looks like there was already a S.I.L.O.S answer, but it didn't show up on the leaderboard. But I'll keep this answer because it's shorter.

a=10
lblb
printLine **********
a-1
if a b

Try it online!

Answer 176

BrainFuck, 68 Bytes

++[>+++++<-]++[>>>+++++<<<-]++++++[>>+++++++<<-]>[>..........>.<<-]

BrainFuck is fun, this is me practicing my skills.

Answer 177

memes, 17 bytes

d5+5’{p

Needs ********** as input, therefore +10.

d      Don't print result
5+5    10 times
’      loop
{p     Print input

Answer 178

C++ 83 bytes 82 Thanks to matthew roh!

#include <iostream>
int main(){for(int i;i++<10;){std::cout<<"**********"<<"\n";}}

Try Me Online!

Answer 179

8th, 28 bytes

( "*" 10 s:* . cr ) 10 times

Answer 180

Scala, 23 bytes

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

Almost the same as python solution.

Answer 181

Perl, 22 bytes

print"**********\n"x10

Answer 182

QC 41 bytes

&FF002A2A2A2A2A2A2A2A2A2A0D0AFF##########

&FF00 Write hex to memory at address 00 until FF is reached
2A2A2A2A2A2A2A2A2A2A0D0AFF 10 asterisks with a new line and the terminator at the end
########## Print contents of memory 10 times until first 00 is reached

Could be made shorter if loops were used.

Answer 183

Z80 TI-83+, 53 bytes

.nolist
#include "ti83plus.inc"
#define    ProgStart    $9D95

.list
.org    ProgStart - 2
    .db    t2ByteTok, tAsmCmp
    bcall(_homeup)
    ld A, 0
    ld (PenCol), A
Do:
    inc A
    ld hl, msg
    bcall(_PutS)
    bcall(_NewLine)
    cp 10
    jr NZ, Do
    ret
msg:
    .db "**********", 0
.end
.end

Compiled with SPASM.

Answer 184

Sinclair ZX81/Timex TS1000/1500

Simple enough I think

Method 1, 55 bytes (listing):

 1 LET A=0
 2 PRINT "**********"
 3 LET A=A+1
 4 GOTO 2+((A=9)*3)

Method 2, 30 bytes (listing)

 1 FOR I=0 TO 9
 2 PRINT "**********"
 3 NEXT I

Answer 185

Japt, 9 bytes

Ao@'*pA÷

Try it online!

Non-competitive solutions using the new flag features in Japt:

-R flag.

-x flag.

-Sx flags.

-P flag.

Answer 186

Syms, 24 bytes

{*}10;*[[[[[[[[[{~>[)}[)

The interpreter as provided errors immediately, but changing line 2 to if True: fixes it. (Is this allowed? Seems like it.)

Explanation:

{*}10;*[[[[[[[[[{~>[)}[)
{*}                       Add '*' to the stack.
   10;*                   Repeat it 10 times.
       [[[[[[[[[          Duplicate 9 times (there are now 10 copies on the stack)
                {~>[)}    Swap, output, duplicate, run (prints element below tos (top of stack) and then executes tos, stack is now (copies, this))
                      [)  Duplicate and run (causes infinite loop, exits when '*'*10 copies run out)

Answer 187

Cardinal, 41 bytes

%++=tt*=>"*******" v
        ^~?-~,"***"<

Try it online!

Answer 188

Python 3 (35 bytes)

for x in range(1,11):print("*"*10)

Answer 189

OIL, 55 44 41 bytes, noncompeting

Annotated here for better understanding; remove everything after each ‌# in each line to make it work.

**********# asterisk storage
10#if what's in
14#line 14 (marked with $)
1#is identical to 10 (line 1)
13#jump to line 13 (marked with &)
6#else to line 6; the next line
4#print what's in line 0; 10 asterisks

11#print a newline
8#increment line 14 (marked with $)
14
6#jump to the beginning (line '' == line 0)

3#exit &
0#counter $

Answer 190

RProgN 2, 8 bytes, Noncompeting

Noncompeting because Language Postdates challenge

°{°`**}*

I decided to take another stab at this, with a much better version of RProgN.

Explained

°{°`**}*
°      *    # Run the contained function Ten (Which ° is a constant for) times.
 {°  *}     # Repeat the referenced string 10 times.
   `*       # Asterisk Literal.
            # This results in 10 strings of 10 `*`s on the stack, which prints as expected.

Try it online!

Answer 191

OCTAVE, 36 bytes

strrep(num2str(ones(10,10)),"1","*")

Makes a 10 by 10 matrix of ones, converts these to strings and then changes the ones to *'s.

Answer 192

05AB1E, 7 bytes

'*т×Tô»

Try it online!

An alternate solution to the 05AB1E one already provided.

Explanation:

'*т×Tô» 
'*      Push an asterisk
  т×    Repeat the asterisk 100 times: "***********..."
    Tô  Split it into pieces of 10.
      » Join with newlines.
        Implicit print.

Answer 193

q/kdb+, 19 13 bytes

Solution:

-1(2#10)#"*";

Example:

q)-1(2#10)#"*";
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Explanation:

-1(2#10)#"*"; / solution
         "*"  / the asterisk
        #     / take or reshape
  (2#10)      / list (10;10), 10 rows, 10 columns
-1           ; / print to stdout

Answer 194

Syms 1.4, 12 bytes (noncompeting)

$
$*10*+10*>

Try it online!

Answer 195

C#, 96 bytes

static class P{static void Main(){for(int i=1;i<11;i++)System.Console.WriteLine("**********");}}

Try it online

Answer 196

Micro, 15 bytes

"*"10*10c+10*:/

Answer 197

Check, 15 bytes

^{Non-competing as language postdates the challenge}

"*">10:r*R]+R*o

Pushes the string * and repeats it ten times, while also storing 10 in the register. Then adds 10 to the end of the string (a newline), then repeats the whole thing 10 times.

Answer 198

k, 12 bytes

`0:10 10#"*"

Try it online.

Explanation:

   10 10#"*" /make 10 by 10 matrix of asterisk characters
`0:          /output each row as a line

Answer 199

Perl 5, 66 bytes

$x = 1x10;$x =~ s/\d/*/g;for($i = 1; $i <=10; $i++){print "$x\n";}

Try it online!

Answer 200

Excel VBA, 11 Bytes

Anonymous VBE immediate window function that outputs a 10x10 grid of * to the ActiveSheet object

[A1:J10]="*

Answer 201

Pyth, 6 bytes

Bet there's going to be a shorter Charcoal answer

VT*T"*

Explanation:

VT     Ten times
 *T"*  Output ten asterisks followed by a newline

Try it online!

Answer 202

4, 56 bytes

4, 5, 6!

3.600426011060310604018016021080250010202049503101010494

Try it online!

For explanation see verbose mode in the tio link - quite straightforward initialization of cells and nested 10x10 loop.

Answer 203

SOGL V0.12, 6 bytes

LL **∙

Try it Here!

Answer 204

Google Sheets, 22 Bytes

Anonymous worksheet function that takes no input and outputs a 10 x 10 grid of *s to the calling worksheet cell.

=REPT("**********
",10

Answer 205

Symbolic Python, 41 bytes

_=-~(_==_)
_=_**-~_+_
_=("*"*_+"""
""")*_

Try it online!

Explanation

• _=-~(_==_) sets the value of _ to True, which is interchangeable with 1
• _=_**-~_+_ performs 2**3+2, resulting in 10, and stores this in _
• "*"*_ constructs a row, and +"""\n""" appends a newline.
• This is multiplied by _, 10, to create the square.
• At the end of execution, the value left in _ is printed.

Answer 206

SNOBOL4 (CSNOBOL4), 56 50 bytes

O	OUTPUT =DUPL('*',10)
	X =LT(X,9) X + 1 :S(O)
END

Try it online!

Answer 207

ABCR, 36 bytes

)))))))BAAAAA4*xAb)))B(7OOOOOOOOOOP(x

Pushes 42 (the character code for *) to queue A, 10 (\n) to B, and then for each value from 9 to 0 print out ten copies of A as a character and one copy of B.

Answer 208

Acc!!, 68 bytes

Count i while i-10 {
	Count v while v-10 {
		Write 42
	}
	Write 10
}

Try it online!

Answer 209

dc, 41 bytes

[1-d0!>C]sR[42Pd10%0=NlRx]sC[10P]sN100lRx

Try it online!

I know there's dc answer, just wanna do it without dumping stack)

Answer 210

Python 3, 43 34 31 28 bytes

for i in[1]*10:print(10*'*')

Saved 9 bytes thanks to Simon

Saved 3 bytes thanks to Wheat Wizard

Just sprints ten asterisks and in a loop.

Answer 211

FALSE, 34 33 26 23 bytes

11[1-$]["**********
"]#

Answer 212

Momema, 44 bytes

a000b0-9 42 0+1*0b=+-10*0-9 10 1+1*1a=+-10*1

Try it online!

Explanation

                                                                     #  b = 0
a   0        #  label a0: jump past label a0 (no-op)                 #  do {
0   0        #            [0] = 0                                    #    a = 0
b   0        #  label b0: jump past label b0 (no-op)                 #    do {
-9  42       #            output chr 42                              #      print '*'
0   +1*0     #            [0] = 1 + [0]                              #      a += 1
b   =+-10*0  #  label b1: jump past label b((1 + !!([0] - 10)) % 2)  #    } while (a - 10 != 0)
-9  10       #            output chr 10                              #    print '\n'
1   +1*1     #            [1] = 1 + [1]                              #    b += 1
a   =+-10*1  #  label a1: jump past label a((1 + !!([1] - 10)) % 2)  #  } while (b - 10 != 0)

Answer 213

Micrsocript II, 13 bytes

{"*"s10*P}s9*

Answer 214

Whitespace, 91 bytes

[S S S T    T   S S T   S S N
_Push_100][N
S S N
_Create_Label_LOOP][S S S T N
_Push_1][T  S S T   _Subtract][S N
S _Duplicate][N
T   T   S N
_If_negative_Jump_to_Label_EXIT][S S S T    S T S T S N
_Push_42_*][T   N
S S _Print_as_character][S N
S _Duplicate][S S S T   S T S N
_Push_10][T S T T   _Modulo][N
T   S T N
_If_0_Jump_to_Label_NEWLINE][N
S N
N
_Jump_to_Label_LOOP][N
S S T   N
_Create_Label_NEWLINE][S S S T  S T S N
_Push_10][T N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.

Try it online (with raw spaces, tabs and new-lines only).

Explanation in pseudo-code:

Integer i = 100
Start LOOP:
  i = i - 1
  If(i < 0)
    Exit program
  Print "*"
  If(i modulo-10 == 0)
    Print new-line
  Go to next iteration of LOOP

Answer 215

Charm, 50 bytes

f := 10 repeat i
[ [ " * " pstring ] f newline ] f

Try it online!

Funnily enough, this doesn't use loops at all, just repeated code.

Answer 216

C, gcc 36 bytes

recursive solution. One downside is you need to pass 2 when you call the function to get 10 rows. f(a){a<puts("**********")?f(a+1):0;}

This alternative addresses that issue and you don't have to call the function from main since main is now the recursive function:

main(a){a<puts("**********")-1?main(a+1):0;}

gcc also resolves #include "stdio.h" missing and variable a is implicitly set to an int and initialized to 0.

Answer 217

PHP, 60 45 Bytes

Try it online (original answer)

Try it online (saved 15 Bytes thanks to @Titus)

Code (Original)

<?=strtr(str_repeat(base_convert("1ku",36,2),10),["
","*"]);

Code (Titus suggestions)

<?=strtr(str_repeat(11111111110,10),10,"*\n");

About the edit

The change is, using str_repeat(base_convert("1ku",36,10),10) actually uses more bytes than str_repeat(11111111110,10) and the use of string for replacements on strtr instead of an array.

Explanation, Why "1ku"?`

The solution is repeat the string "**********", lets take the base 2 number 11111111110

base 10 = 2046
base  2 = 11111111110
base 36 = 1ku

Basically is repeat a compressed string, and with strtr replace each 1 with a "*" and 0 with a \n

Answer 218

Prolog (SWI), 62 59 55 54 bytes

t.
b:-between(0,9,_).
?-b,(b,write(*),1=0;t),nl,1=0;t.

Try it online!

Answer 219

Pari/GP, 31 bytes

for(i=1,10,print("**********"))

Try it online!

Answer 220

Python 3, 28 bytes

print(*['*'*10]*10,sep='\n')

Try it online!

Answer 221

Python 2, 21 bytes

exec'print"*"*10;'*10

Try it online!

Answer 222

Glee, 17 bytes

('*'%%10\)%%10,,\

Explanation:

('*'                          create '*'
    %%10                      reshape to length 10
        \)                    monadic segment with CRLF
          %%10                reshape to sequence length 10
              ,,\             expose with LF separators

Answer 223

Python 3, 22 bytes

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

Felt like entering a Python 3 program too.

Answer 224

Ahead, 21 18 bytes

~oK:k9*'N@k=11:+1~

Try it online!

Answer 225

Powershell, 12 bytes

@('*'*10)*10

Explanation

  '*'*10      create a string with 10 '*'
@('*'*10)     create an array with one element of string with 10 '*'
@('*'*10)*10  repeat elements of this array 10 times

Answer 226

ORK, 185 bytes

When this program starts:
I have a scribe called W
W is to write "**********\n**********\n**********\n**********\n**********\n**********\n**********\n**********\n**********\n**********"

Try it online!

ORK does everything (even I/O and basic math) with objects. As far as this question goes, looping does not have to be one of them.

Answer 227

ESOPUNK, 167 78 77 bytes

MARK L
@REP 10
COPY 42 #STDO
@END
COPY 10 #STDO
TEST X = 9
ADDI X 1 X
FJMP L

I haven't been bothered to implement the preprocessor, but this should work when I do.

Answer 228

Julia 1.0, 23 bytes

print(("*"^10*"\n")^10)

Try it online!

Answer 229

A0A0, 145 bytes

A0A0
A0C3G1G1G1G1G1G1G1G1G1G1G1A0
A0P42P42P42P42P42P42P42P42P42P42G3P10A0
A0A1G-3G-3G-3G-3G-3G-3G-3G-3G-3G-3G-3A0
G-3
G-2G-2G-2G-2G-2G-2G-2G-2G-2

The top five lines are for the loop construction. A0A0 deletes instructions whenever it runs them, so those lines ensure that the loop keeps running. On line 3 are ten P42 instructions which print * (42 is the ascii code for an asterisk). The P10 instruction prints a new line.

The bottom line acts as a counter. For every execution of the loop it jumps to there and then jumps back to the loop. This consumes an instruction on that line. There are exactly nine instructions, so when it tries to go there when it has already printed ten lines the program will halt execution (since an empty line swill stop execution in A0A0).

Answer 230

Pascal (FPC), 57 bytes

var i:word;begin for i:=0to 9do writeln('**********')end.

Try it online!

This is probably the best one as I don't see how this can be improved in 9 characters or less which could be gained by removing *s.

Answer 231

Premier, 8 bytes

'*U*N+U*

Try it online!

The boring way.

Explanation

'*U*N+U*     full program
'*           push "*"
  U          push 10
   *         repeat
    N+       append newline
      U      push 10
       *     repeat

Premier, 14 bytes

QnN
**********

Try it online! This second approach uses Premier's implicit data iteration. It iterates over each character in the data (the second line), and executes the program (the first line) for each character. The data QnN pushes the data (Q), outputs it (n), then pushes a newline (N), to be implicitly outputted. This iterates 10 times, printing a 10x10 grid of asterisks.

Answer 232

Stax, 4 bytes

╪n│╔

Run and debug it

Answer 233

MathGolf, 7 bytes

♂⌂*n+♂*

Explanation

♂⌂*     Push asterisk multiplied by 10("**********")
   n    Append a newline
    +   Concatenate the two strings
     ♂* Multiply the string by 10
implicit output

Try it online!

Answer 234

Python 3, 23 bytes

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

Try it online!

In this case, the obvious answer is best. I tried some other ways, but all were equal or longer in length.
Let me know if you have any answers to add.

23 bytes (alternative)

print(10*f"{10*'*'}\n")

24 bytes

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

25 bytes

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

29 bytes

print("\n".join(10*[10*"*"]))

32 bytes

for _ in range(10):print(10*"*")

43 bytes

print(*(10*"*"for _ in range(10)),sep="\n")

Answer 235

Ruby, 15 bytes

puts [?**10]*10

Try it online!

Prints a trailing newline.

?* is the single character *

Explanation

puts [?**10]*10

      ?*        : literal '*' string
        *10     : repeated 10 times ('**********')
     [     ]    : as an element in an array
            *10 : which is also repeated 10 times
puts            : prints each element of the array appended with a newline.

Answer 236

Husk, 9 bytes

C10*100"*

Try it online!

Length 100 string chopped into 10 pieces.

Answer 237

C++, 76 bytes

I don't know if this could be golfed further, but just.

#include <iostream>
void a(){for(int i=0;i++<10;)std::cout<<"**********\n";}

Answer 238

Javascript (using external library - Enumerable) (41 bytes)

_.From("**********\n").Cycle(120).Write()

Link to lib: https://github.com/mvegh1/Enumerable/

Code explanation: This runs right in the console. Load the string into the library, which parses it to a char array enumerable. Create a new enumerable from that sequence, which is generated by cycling from start to finish 120 times (because the string length is 12, and we want 10 of them..12*10=120). I.e [1,2,3].Cycle(10) would be 1,2,3,1,2,3,1,2,3,1. Finally, join everything into a string with "" as delimiter

Answer 239

C# - 88 bytes

class P{static void Main(){int i=0;while(i++<10)System.Console.Write("**********\n");}}

Answer 240

Ruby, 18 bytes

puts (?**10+$/)*10

Alternative version (+3 bytes)

10.times {puts ?**10}

Ungolfed (first version)

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

Answer 241

Perl, 24 bytes

print((("*"x10).$/)x10);

Answer 242

Swift 2, 45 Bytes

func a(){for _ in 0...9{print("**********")}}

Answer 243

Wolfram, 22 bytes

Grid[Table["*",10,10]]

Answer 244

R

matrix(rep("*",100), nrow = 10)

Probably faster way in R, but fun utilization of matrix

Explanation

rep: repeats first argument as many times as second argument.

matrix: creates matrix from vector (first argument), and nrow is the number rows desired in matrix.

Answer 245

JAISBaL 3.0.1, 9 bytes (non-competing)

h**A10«

Verbose:

# \# enable verbose parsing #\
ten            \# [0] push ten onto the stack #\
push1 *        \# [1] push * onto the stack #\
mul            \# [2] multiply the top two values of the stack #\
dupmany 10     \# [3] duplicate the top value of the stack 10 times #\
popoutallln    \# [4] pop off every value in the stack and print each one with a new line #\

Conventional 10 byte version (using actual for loops):

˖˖S*˄P

Verbose:

# \# enable verbose parsing #\
ten                 \# [0] push ten onto the stack #\
for                 \# [1] start for loop #\
    ten             \# [2] push ten onto the stack #\
    for             \# [3] start for loop #\
        print1 *    \# [4] print * #\
    end             \# [5] end current language construct #\
    ln              \# [6] print a new line #\

This is non-competing because JAISBaL has received a huge amount of updates yesterday and today, and I'm not sure whether or not these instructions were available or did the same thing, furthermore, all the instructions ids have changed...

---

intepreter

Answer 246

Javascript, 45 bytes

for(i=0;i<10;i++) {console.log('**********')}

even better, ES6 Javascript, 38 bytes

console.log('**********\n'.repeat(10))

open console and copy paste to test

Answer 247

Python 3 (22 bytes)

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

Answer 248

3var, 27 26 bytes

1 byte thanks to Business Cat

iisiia+<*>aaaF[PPPPPPPPPPO]
aaamaiis*>iiF[PPPPPPPPPPO]

I don't how do nested loops marked by F.

Try it online!

Answer 249

Japt, 10 bytes

'*pA +R pA

Prints * ten times, then \n, then repeat from the beginning ten times.

Demo.

Answer 250

Arcyóu, 21 bytes

(* "**********\n" 10)

Try it online!

Answer 251

Gema, 31 characters

\A=@repeat{10;**********\n}@end

Sample run:

bash-4.3$ gema '\A=@repeat{10;**********\n}@end'
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Answer 252

Groovy, 23 characters

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

Sample run:

bash-4.3$ groovy -e 'print(("*"*10+"\n")*10)'
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Answer 253

Lua, 30 bytes

Full program outputting via its return value.

return("**********\n"):rep(10)

Answer 254

Bc, 26 characters

for(;i++<10;)"**********
"

Sample run:

bash-4.3$ bc <<< 'for(;i++<10;)"**********
"'
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Answer 255

Haskell, 34 bytes

putStr$[0..9]>>([0..9]>>"*")++"\n"

---

λ> putStr$[0..9]>>([0..9]>>"*")++"\n"
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Answer 256

JavaScript (115 106 81 chars)

o='';
for(i=0;i<10;i++){l='';for(j=0;j<10;j++){l+='*';}o+=l+"\n";}
console.log(o);

Answer 257

ListSharp, 73 bytes

[FOREACH NUMB IN 1 TO 10 AS k]
{
STRG p=p+"**********"+<newline>
}
SHOW=p

Answer 258

Mumps, 26 Bytes.

F J=0:1:9 W "**********",!

As loops are fairly efficient (space-wise) in Mumps, I thought I'd see if the loop within a loop was shorter, but it was not; weighing in at 31 bytes:

F I=0:1:9{F J=0:1:9{W "*"} W !}

The braces are allowable loop delimiters in the InterSystems Cache version of Mumps that I use; at times they may save a byte or two golfing, but mostly they're just handy to have nested loops in a one-line routine.

Answer 259

Befunge '98, 31 bytes

a>:|>1++:9`#@_a,
v*'[^
>,v1
-v>

Answer 260

Factor, 30

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

So verbose...

Answer 261

Fourier, 22 bytes

10(10(~X42aX^~X)aN^~N)

Try it on FourIDE!

Answer 262

MSM, 19 bytes

.;;.;...;.;;.;..␍**

where ␍ is a newline.

. concatenates the two rightmost characters and ; appends a copy of the rightmost element to the end, so the first commands .;;.;... create one line **********␍ and the next commands ;.;;.;.. make 10 lines out of it.

Answer 263

Oracle SQL 11.2, 44 bytes

SELECT'**********'FROM v$bh WHERE rownum<11;

Answer 264

Pip, 7 bytes

LtP'*Xt

Straightforward: Loop 10 times. Print string of 10 asterisks each time. Kinda disappointed that the simple way was the shortest...

Answer 265

Jade & CSS, 41 36 bytes

- for (x=0;x++<10;)
  **********<br>

^{Jade is a HTML pre-processor. I'm unsure if using this is breaking any rule or if I have to include something else in the byte count. This also beats my previous entry of 60 bytes.}

See it on Codepen: http://codepen.io/409/pen/ZOPgdJ

Thanks to Business Cat for saving 5 bytes.

Answer 266

Lua, 29 Bytes. Non-competing

(("*"):rep(10).."\n"):rep(10)

Forgot to make this print, and with print, it's identical to another answer. So I'm not competing, instead of trying to think up an entirely new short approach.

Answer 267

Groovy, 23 characters

10.times{println'*'*10}

Answer 268

Bash + coreutils + X11 term - 7 keystrokes

Exact keys to hit:

• <Alt>+1
• 0
• 0
• * (<Shift>+8)
• <Return>

Requirements:

• Your terminal window must be exactly 10 characters wide.
• Your terminal prompt (PS1) should be empty.
• Your working dir must be empty.

Answer 269

Stata, 49 bytes

loc i=1
wh `i'<11 {
di "**********"
loc i=`i'+1
}

Output

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

Answer 270

ISOLADOS, 131 bytes

ISOLAADOOOOOOOOOOOS ISOLAAAAAAADOS ISOLAADOOOOOOOOOOS ISOLAAADOOOS ISOLAAAAAAAADOS ISOLAADOOOOOOOOOOS ISOLAAADOOOS ISOLAAAAAAAAADOS

---

ISOLAADOOOOOOOOOOOS    push 11
ISOLAAAAAAADOS         chr(a + 31)
ISOLAADOOOOOOOOOOS     push 10
ISOLAAADOOOS           push a * b
ISOLAAAAAAAADOS        push [a]
ISOLAADOOOOOOOOOOS     push 10
ISOLAAADOOOS           push a * b
ISOLAAAAAAAAADOS       join list by new lines

Answer 271

Racket 36 bytes

(for((j 10))(displayln"**********"))

Answer 272

Groovy 46 Bytes

(1..10).collect{''.center(10,'*')}.join('\n')

https://groovyconsole.appspot.com/script/5102912250314752

Answer 273

SX, 21 bytes

和(0,10):我('*'*10)

Actually: this compiles (technically, it just becomes Python) directly to Python. It is the same as:

for i in range(0,10):print('*'*10)

Answer 274

Prolog (SWIPl), 64 / 69 bytes (depending on how to count)

-1*_.
A*0:-writeln(*),C is A-1,C*9.
A*B:-write(*),C is B-1, A*C.

Query with

9*9.

Online Example

Try it online, but take note that since writeln/1 has a bug in Swish, causing it to print a new line before as well as after. I've replaced it with write/1,nl/0 which should be (according to documentation) its equivalent. This raised the byte count of the example.

On the Byte Count

I'm not sure how to count the query, but if it is to be counted towards the total byte count, it's 5 bytes (including an Enter).

Answer 275

D2, 11 bytes

!7;//.|a:|a

Explanation:

!7 is expanded to 7 +, so it set the current cell to 7.
; switch to the second shift state (7 is *) /code|digit repeat code digit times (digit is base 36).
. print the character in the current shift state (so here, * is printed).
: print a newline in shift mode 2.

Answer 276

Crystal, 21 bytes

puts ("*"*10+"\n")*10

How does it work?

"*" * 10            = "**********" 
"**********" + "\n" = "**********\n"
"**********\n" * 10 = "**********\n**********\n[...]"

Answer 277

Stuck, 10 Bytes

Very simple implementation here, no tricks ;)

'*10*N+10*

Explanation:

'*           # Enter char mode, puts '*' on the stack
  10*        # Multiply string by 10, puts '**********' on the stack
     N+      # Push a newline to the stack and append to the asterisks
       10*   # Multiply that string by 10 and implicitly print.

Answer 278

HTML, 136 bytes

**********<br>**********<br>**********<br>**********<br>**********<br>**********<br>**********<br>**********<br>**********<br>**********