109
\$\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 Aug 4 '16 at 12:56
  • 14
    \$\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 Aug 4 '16 at 12:58
  • 7
    \$\begingroup\$ @LeakyNun Leaderboard snippet please! \$\endgroup\$ – anna328p Aug 4 '16 at 22:08
  • 3
    \$\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 Aug 5 '16 at 9:14
  • 1
    \$\begingroup\$ you say trailing new lines are acceptable. Are leading newlines acceptable too? \$\endgroup\$ – Albert Renshaw Feb 10 '17 at 2:34

349 Answers 349

1 2
3
4 5
12
3
\$\begingroup\$

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.

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

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

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

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

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

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

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

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.

\$\endgroup\$
1
  • \$\begingroup\$ I think you're missing a HERE IS MY INVITATION i between lines 6 and 7. \$\endgroup\$ – ceilingcat Sep 4 '17 at 3:54
3
\$\begingroup\$

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

Racket, 43 36 bytes

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

(for([i 10])(displayln"**********"))
\$\endgroup\$
1
  • 1
    \$\begingroup\$ Can be shorter with just (i 10) rather than (i (range 10)). \$\endgroup\$ – rnso Sep 6 '16 at 23:11
3
\$\begingroup\$

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){} )
\$\endgroup\$
2
  • 1
    \$\begingroup\$ Maybe put a link to QBIC, for those who aren't familiar with a language? \$\endgroup\$ – user48538 Aug 4 '16 at 9:57
  • \$\begingroup\$ @zyabin101 I've added a link. \$\endgroup\$ – steenbergh Aug 4 '16 at 10:42
3
\$\begingroup\$

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.

\$\endgroup\$
3
\$\begingroup\$

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)

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

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)));
    }
}
\$\endgroup\$
3
\$\begingroup\$

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

Rust, 49 bytes

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

My first code golf answer!

\$\endgroup\$
1
  • 1
    \$\begingroup\$ Welcome to the site! You might want to add a link to Try It Online with your code, so other people can test your program. \$\endgroup\$ – mabel Jan 22 '20 at 14:06
3
\$\begingroup\$

Flurry, 76 bytes

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

Can be run with the interpreter as follows:

$ ./Flurry -bnn -c "$pgm"
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Explanation

A function that composes two functions (or multiplies two numbers):

comp = λf g x. f (g x)
     = λf g x. K f x (g x)
     = λf g x. S (K f) g x
     = λf. S (K f)
     = S ∘ K
    := <<>()>

A function that increments a number by one:

succ = λn f x. f (n f x)
     = λn f. comp f (n f)
     = λn f. S comp n f
     = S comp
    := <><<>()>

A function that computes n(n + 1):

oblong = λn. n * succ n
       = λn. comp n [succ n]
       = λn. S comp succ n
       = succ succ
      := <><<>()> [<><<>()]
      := (<><<>()>) {}

The number two:

2 = λf x. f (f x)
  = λf. <f f>
 := {<({}){}>}

The number six:

6 = 2 * 3
  = 2 * succ 2
  = oblong 2
 := oblong {<({}){}>}
 := (<><<>()>){} {<({}){}>}

The number 42 (ASCII value of *):

42 = 6 * 7
   = 6 * succ 6
   = oblong 6
   = oblong (oblong 2)
  := (oblong) [{} 2]
  := ((<><<>()>){}) [{} 2]
  := ((<><<>()>){}) [{} {<({}){}>}]

The number 10:

10 = λf x. f (f (f (f (f (f (f (f (f (f x)))))))))
   = λf. f ∘ f ∘ f ∘ f ∘ f ∘ f ∘ f ∘ f ∘ f ∘ f
   = λf. push (f ∘ f ∘ f ∘ f ∘ f) ∘ pop
   = λf. push (f ∘ push (f ∘ f) ∘ pop) ∘ pop
   = λf. push (push f ∘ push (push pop ∘ pop) ∘ pop) ∘ pop
  := {<  (    < ({})    (    <  ({})     {}>)   {}>)    {}>}
  := {<(<({})(<({}){}>){}>){}>}

A function that pushes 42 to the stack and returns its argument:

push_star = λx. (push 42; x)
          = λx. K x (push 42)
         := {() {} (42)}
         := {() {} (((<><<>()>){})[{}{<({}){}>}])}

A function that takes the number 10 and then pushes ten copies of 42, followed by 10, and returns 10:

push_row = λn. push (n push_star n)
        := { (({}) push_star {}) }
        := { (({}) {(){}(((<><<>()>){})[{}{<({}){}>}])} {}) }

Applying push_row 10 times to the number 10:

main () = 10 push_row 10
        = (push 10) push_row pop
       := (10) push_row {}
       := ({<(<({})(<({}){}>){}>){}>}){(({}){(){}(((<><<>()>){})[{}{<({}){}>}])}{})}{}
\$\endgroup\$
3
\$\begingroup\$

Cubix, 26 bytes

'*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.
\$\endgroup\$
3
\$\begingroup\$

Perl 5, 17 bytes

say'*'x10for 0..9

Try it online!

\$\endgroup\$
2
  • \$\begingroup\$ need to print * not x \$\endgroup\$ – roblogic Mar 15 at 1:03
  • 1
    \$\begingroup\$ @roblogic: Thanks for your hint. It was only a small change, of course. \$\endgroup\$ – Donat Mar 15 at 9:04
3
\$\begingroup\$

swift 5, 35 bytes

(0...9).map{$0;print("**********")}

The $0 is only needed to prevent a compiler error.

[Update]

Try it online:

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

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

Vyxal, jH, 6 5 4 3 bytes

×*²

Try it Online!

Explained

×*²
×*      # Push 100 asterisks onto the stack (as a single string) // the H flag initalises the stack with 100
  ²     # Split into pieces of 10 and use the j flag to join on newlines. 
\$\endgroup\$
3
\$\begingroup\$

RAMDISP, 31 bytes.

[P[5[*2]R[M[I[;**********
]]]]]
[P - pipe through the following array
  [
    5 - 5
    [*2] - times 2 [10]
    R - create a range of that size [1..10]
    [M - for each element in that range
      [I - ignore it
        [;**********\n] - print eight asterisks and a newline 
                          (real newline was replaced by \n)
      ]
    ]
  ]
]

basic, but works.

\$\endgroup\$
3
  • 1
    \$\begingroup\$ Out of interest, did you make this language? \$\endgroup\$ – Redwolf Programs Jun 25 at 8:19
  • \$\begingroup\$ @RedwolfPrograms yes! but i made it before i even joined stackexchange so i dont think it's cheating \$\endgroup\$ – Pro Odermonicon Jun 27 at 20:57
  • \$\begingroup\$ It wouldn't be cheating either way! In fact, I've got a bounty of +100 reputation for new(ish) languages, and this one looks really interesting. \$\endgroup\$ – Redwolf Programs Jun 27 at 20:59
3
\$\begingroup\$

GForth 36 Bytes

: A 10 0 do ." **********" CR loop ;
\$\endgroup\$
2
\$\begingroup\$

Python 3, 29 23 bytes

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

Thanks to orlp for shaving off 6 bytes.

\$\endgroup\$
8
  • 1
    \$\begingroup\$ We require either a full program or a function. An expression is not sufficient. \$\endgroup\$ – orlp Aug 4 '16 at 9:35
  • \$\begingroup\$ Yes, I'm referring to your second paragraph. \$\endgroup\$ – orlp Aug 4 '16 at 9:36
  • 1
    \$\begingroup\$ print((10*"*"+"\n")*10) is shorter. \$\endgroup\$ – orlp Aug 4 '16 at 9:37
  • \$\begingroup\$ darnit we had the same answer :( \$\endgroup\$ – Destructible Lemon Aug 4 '16 at 9:50
  • \$\begingroup\$ Changing print to exit will save 1 byte and still output the result, there wasn't specified if it should be printed on standard output. \$\endgroup\$ – Gábor Fekete Aug 4 '16 at 13:50
2
\$\begingroup\$

Golisp, 34 bytes

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

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

\$\endgroup\$
5
  • \$\begingroup\$ Congratulations! \$\endgroup\$ – Leaky Nun Aug 4 '16 at 10:29
  • \$\begingroup\$ @LeakyNun For what? \$\endgroup\$ – TuxCrafting Aug 4 '16 at 10:30
  • \$\begingroup\$ For developing a language. \$\endgroup\$ – Leaky Nun Aug 4 '16 at 10:30
  • \$\begingroup\$ @LeakyNun Just look at my GitHub repos... \$\endgroup\$ – TuxCrafting Aug 4 '16 at 10:35
  • 7
    \$\begingroup\$ I didn't say "for developing your first language" \$\endgroup\$ – Leaky Nun Aug 4 '16 at 10:35
2
\$\begingroup\$

SpecBAS - 18 bytes

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

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

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

C#, 79 bytes

class P{void Main(){for(int i=0;i++<10;)System.Console.Write("**********\n");}}
\$\endgroup\$
2
  • \$\begingroup\$ This won't run without static void right? \$\endgroup\$ – pay Aug 4 '16 at 15:49
  • \$\begingroup\$ @pay has void already not sure if it needs static will check later when I have chance \$\endgroup\$ – TheLethalCoder Aug 4 '16 at 15:59
2
\$\begingroup\$

golflua, 22 characters

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

Sample run:

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

C++, 75 bytes

#include<cstdio>
int main(){for(int i=0;i<10;++i)std::puts("**********");}
\$\endgroup\$
7
  • 2
    \$\begingroup\$ Why the downvote? \$\endgroup\$ – arnsong Aug 4 '16 at 13:00
  • \$\begingroup\$ I believe this was an automatic downvote from the community user. Your post was auto-flagged as low quality (since it only contained code) and Leaky Nun's edit caused an automatic unowned downvote. See meta.stackexchange.com/q/236883 \$\endgroup\$ – FryAmTheEggman Aug 4 '16 at 13:03
  • 2
    \$\begingroup\$ That's actually not true. I don't think it's fair to assume. \$\endgroup\$ – arnsong Aug 4 '16 at 13:55
  • 1
    \$\begingroup\$ You can save 1 byte by changing the for-loop to: for(int i=0;++i<11;) \$\endgroup\$ – Kevin Cruijssen Aug 4 '16 at 14:07
  • 2
    \$\begingroup\$ Use int main(i) and remove the int i=0. Then, replace i<10;++i with i++<10;. -7 \$\endgroup\$ – Erik the Outgolfer Aug 4 '16 at 14:58
2
\$\begingroup\$

T-SQL, 50 bytes

print replicate(replicate('*',10)+char(10),10)
\$\endgroup\$
1
  • 1
    \$\begingroup\$ not an T-SQL expert but wouldn't 'print replicate('**********'+char(10),10)' be shorter? \$\endgroup\$ – dwana Aug 5 '16 at 8:25
2
\$\begingroup\$

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

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

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.

\$\endgroup\$
1 2
3
4 5
12

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

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