123
\$\begingroup\$

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

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

419 Answers 419

1
6 7
8
9 10
14
1
\$\begingroup\$

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.

\$\endgroup\$
2
1
\$\begingroup\$

Sprects, 22 bytes

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

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

\$\endgroup\$
1
\$\begingroup\$

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_'));

\$\endgroup\$
1
\$\begingroup\$

PostgreSQL, 39 bytes

select repeat('**********'||chr(13),10)
\$\endgroup\$
1
\$\begingroup\$

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!

\$\endgroup\$
1
\$\begingroup\$

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

\$\endgroup\$
2
  • \$\begingroup\$ range(10)|"*"*10 \$\endgroup\$
    – Leaky Nun
    Commented Aug 5, 2016 at 10:58
  • \$\begingroup\$ Thank you, @LeakyNun. No idea why I left with the idea that string*number not works. (array*string is the one that not works.) \$\endgroup\$
    – manatwork
    Commented Aug 5, 2016 at 11:02
1
\$\begingroup\$

Lua, 30 bytes

Full program outputting via its return value.

return("**********\n"):rep(10)
\$\endgroup\$
8
  • \$\begingroup\$ I'm afraid this is not a full program, just a snippet. It produces no output by its own, relies on Lua REPL's functionality. \$\endgroup\$
    – manatwork
    Commented Aug 5, 2016 at 12:11
  • 1
    \$\begingroup\$ @manatwork it is a full program, and is also outputting by itself. All lua program are encapsulated in function inside the VM, thus they can all return a value and it is a legit way of outputing \$\endgroup\$
    – Katenkyo
    Commented Aug 6, 2016 at 0:35
  • \$\begingroup\$ @manatwork Oh also, you just have to read this to know it's legit. \$\endgroup\$
    – Katenkyo
    Commented Aug 6, 2016 at 8:11
  • \$\begingroup\$ Are you referring to the “... if and only if the challenge requires an integer as output, obviously.” part? \$\endgroup\$
    – manatwork
    Commented Aug 6, 2016 at 9:05
  • \$\begingroup\$ @manatwork this part only refer to the case you use an exit code, because an exit code is always an integer. I was refering to "If functions can output using their return values, it makes sense that programs should be able to do the same", which is what I've done: using the return value of my program \$\endgroup\$
    – Katenkyo
    Commented Aug 6, 2016 at 10:28
1
\$\begingroup\$

Pyke, 6 bytes

TVT\**

Try it here!

       - (T = 10)
TV     - repeat(10):
  T\** -  10*"*"
\$\endgroup\$
1
\$\begingroup\$

Go, 84 characters

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

Sample run:

bash$ go build && ./golf
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********
\$\endgroup\$
2
  • \$\begingroup\$ Print ten asterisks without using a loop \$\endgroup\$
    – Leaky Nun
    Commented Aug 5, 2016 at 15:26
  • \$\begingroup\$ removed inner loop per @LeakyNun \$\endgroup\$ Commented Aug 6, 2016 at 2:10
1
\$\begingroup\$

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
\$\endgroup\$
1
\$\begingroup\$

Neoscript, 39 bytes

each _=0:[]:9console:log("**********");
\$\endgroup\$
1
\$\begingroup\$

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)
\$\endgroup\$
1
\$\begingroup\$

Vitsy, 13 bytes

I'm late to the party. :c

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

Try it online!

\$\endgroup\$
1
\$\begingroup\$

PHP 46 bytes

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

I think this don't needs explanation.

\$\endgroup\$
1
\$\begingroup\$

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

\$\endgroup\$
3
  • \$\begingroup\$ You might want to include a link to an online interpretter/compiler so we can test your code. e.g. \$\endgroup\$
    – Wheat Wizard
    Commented Aug 5, 2016 at 13:10
  • \$\begingroup\$ This would work almost the same as csi.exe included in Roslyn, although the behavior might not be the same for all cases. \$\endgroup\$ Commented Aug 5, 2016 at 13:25
  • \$\begingroup\$ You can shorten it down a bit for(int i=0;i<10;i++) can be written as for(int i=0;i++<10;) \$\endgroup\$
    – CSharpie
    Commented Aug 8, 2016 at 19:38
1
\$\begingroup\$

Swift, 35 Bytes

for _ in 0...9{print("**********")}
\$\endgroup\$
1
\$\begingroup\$

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.

\$\endgroup\$
2
  • \$\begingroup\$ Link? – – – – – \$\endgroup\$
    – Leaky Nun
    Commented Aug 5, 2016 at 17:01
  • \$\begingroup\$ @LeakyNun Sorry I completely forgot. Edited it in. \$\endgroup\$ Commented Aug 5, 2016 at 17:06
1
\$\begingroup\$

Convex, 10 bytes

A'**{A*N}%

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Oracle SQL 11.2, 44 bytes

SELECT'**********'FROM v$bh WHERE rownum<11;
\$\endgroup\$
1
\$\begingroup\$

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

\$\endgroup\$
1
\$\begingroup\$

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 :) ): enter image description here

\$\endgroup\$
6
  • 1
    \$\begingroup\$ ********** is shorter than \foreach\n in{0,...,9}{*} \$\endgroup\$
    – Leaky Nun
    Commented Aug 14, 2016 at 13:54
  • \$\begingroup\$ Good point! Not sure how I missed that... Must've been too focused on getting the nested loop going :) Thanks! \$\endgroup\$
    – MH.
    Commented Aug 14, 2016 at 14:10
  • \$\begingroup\$ \\ is shorter than \par \$\endgroup\$
    – Leaky Nun
    Commented Aug 14, 2016 at 14:11
  • \$\begingroup\$ True, but then the result is no longer a proper grid as the first line will be indented. \$\endgroup\$
    – MH.
    Commented Aug 14, 2016 at 14:27
  • \$\begingroup\$ @MH. -- Here's a Link to the Plain TeX solution: overleaf.com/read/tpjsnrgsnnsb \$\endgroup\$
    – Joe85AC
    Commented Jun 5, 2020 at 15:43
1
\$\begingroup\$

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

\$\endgroup\$
3
  • \$\begingroup\$ Loops using 0,9 limits skim off another couple? And make the positive case for not using '**********' :-) \$\endgroup\$
    – Joffan
    Commented Aug 19, 2016 at 20:14
  • \$\begingroup\$ Thanks! Not sure how I didn't think of that. Must've had a temporary brain meltdown :/ \$\endgroup\$
    – MH.
    Commented Aug 19, 2016 at 21:00
  • \$\begingroup\$ @MH. I know I'm late, but program T print'(10(A))',('*',j=0,99) end is 41 bytes long and doesn't print a leading space :-) \$\endgroup\$ Commented Oct 15, 2019 at 2:58
1
\$\begingroup\$

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
\$\endgroup\$
7
  • 1
    \$\begingroup\$ You know, you can just do this \$\endgroup\$
    – Leaky Nun
    Commented Aug 28, 2016 at 19:26
  • \$\begingroup\$ I'm a newbie, I didn't know, thank you! \$\endgroup\$
    – FedeWar
    Commented Aug 28, 2016 at 19:27
  • \$\begingroup\$ Another byte saved \$\endgroup\$
    – Leaky Nun
    Commented Aug 28, 2016 at 19:28
  • \$\begingroup\$ 12 bytes now \$\endgroup\$
    – Leaky Nun
    Commented Aug 28, 2016 at 19:29
  • \$\begingroup\$ Wow, I still have a lot to learn. \$\endgroup\$
    – FedeWar
    Commented Aug 28, 2016 at 19:30
1
\$\begingroup\$

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!

\$\endgroup\$
1
\$\begingroup\$

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.

\$\endgroup\$
1
\$\begingroup\$

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.
\$\endgroup\$
1
  • \$\begingroup\$ Can be 7 bytes these days! \$\endgroup\$
    – Shaggy
    Commented Feb 2, 2018 at 17:45
1
\$\begingroup\$

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
\$\endgroup\$
1
  • \$\begingroup\$ The ZX81 has a 1-byte ** (which is shift and H); this will save 5 bytes from each listing and might even be a bit quicker. ** is used for to the power of. \$\endgroup\$ Commented Feb 17, 2017 at 12:29
1
\$\begingroup\$

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.
\$\endgroup\$
1
  • \$\begingroup\$ 2 bytes can be saved with 1.4's single char string $. \$\endgroup\$ Commented Jun 22, 2017 at 15:32
1
\$\begingroup\$

LibreLogo, 21 bytes

Code:

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

Result:

enter image description here

\$\endgroup\$
1
\$\begingroup\$

MATLAB / Octave, 23 bytes

Code:

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

Try It Online!

Result:

**********
**********
**********
**********
**********
**********
**********
**********
**********
**********
\$\endgroup\$
1
  • \$\begingroup\$ You can replace '*' by 42 to save a byte. Or use [ones(10)+41 ''] \$\endgroup\$
    – Luis Mendo
    Commented Jan 8, 2018 at 16:26
1
6 7
8
9 10
14

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.