121
\$\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, 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
    Aug 4, 2016 at 12:58
  • 9
    \$\begingroup\$ @LeakyNun Leaderboard snippet please! \$\endgroup\$
    – anna328p
    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
    Aug 5, 2016 at 9:14
  • 3
    \$\begingroup\$ you say trailing new lines are acceptable. Are leading newlines acceptable too? \$\endgroup\$ Feb 10, 2017 at 2:34

406 Answers 406

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

CSS, 157 109 bytes

Inspired by hd answer, probably 1:1 reproduced from OP question (except background color) - pure CSS solution (no additional HTML)

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

\$\endgroup\$
1
  • 4
    \$\begingroup\$ 103 bytes: *,:after{margin:0;white-space:pre;content:'**********\A**********\A**********\A**********\A**********\A (FireFox only, save it inside <style>...</style> in a totally empty file), the :after matches every element's after (in this case html and body) and * is used to remove the body margin. \$\endgroup\$
    – Night2
    Oct 15, 2019 at 5:43
3
\$\begingroup\$

Mornington Crescent, 1940 bytes

Take Northern Line to Euston
Take Victoria Line to Seven Sisters
Take Victoria Line to Euston
Take Victoria Line to Euston
Take Northern Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington
Take District Line to Acton Town
Take Piccadilly Line to Heathrow Terminal 5
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Parsons Green
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Bakerloo Line to Paddington
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

Try it online!

// "*" = 42 = 6*7

// get 7
Take Northern Line to Euston
Take Victoria Line to Seven Sisters

// copy it
Take Victoria Line to Euston
Take Victoria Line to Euston
Take Northern Line to Bank

// add it until 42
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster

// get char "*"
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross

// concatenate it (shorter than with loop)
Take Northern Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington

// calculate a 10 for newline
// get 5 from Heathrow Terminal 5
Take District Line to Acton Town
Take Piccadilly Line to Heathrow Terminal 5
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Parsons Green

// add 5 + 5
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster

// get char "\n"
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross

// concatenate it with asterisks
Take Bakerloo Line to Paddington

// copy them
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington

// go home and print
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent
\$\endgroup\$
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(?;([email protected]

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\$

x86-16 machine code, IBM PC DOS, 17 bytes

00000000: b10a 8bd1 b82a 0acd 1088 c8cd 294a 75f4  .....*......)Ju.
00000010: c3                                       .

Listing:

B1 0A       MOV  CL, 10             ; repeat '*' 10 times per line 
8B D1       MOV  DX, CX             ; counter for 10 line loop 
        LINE_LOOP: 
B8 0A2A     MOV  AX, 0A2AH          ; AL = '*', AH = 0AH 
CD 10       INT  10H                ; print '*' 10 times 
88 C8       MOV  AL, CL             ; AL = LF char (0xA) 
CD 29       INT  29H                ; write to screen 
4A          DEC  DX                 ; dec counter 
75 F4       JNZ  LINE_LOOP          ; loop for 10 lines 
C3          RET                     ; return to DOS

Uses PC BIOS INT 10H function 0AH (write char at current position CX number of times) for each row. Since this function doesn't actually advance the cursor only a line feed/LF (0xA) char is needed to move to the next line.

enter image description here

\$\endgroup\$
0
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, 2021 at 1:03
  • 1
    \$\begingroup\$ @roblogic: Thanks for your hint. It was only a small change, of course. \$\endgroup\$
    – Donat
    Mar 15, 2021 at 9:04
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\$ Jun 25, 2021 at 8:19
  • \$\begingroup\$ @RedwolfPrograms yes! but i made it before i even joined stackexchange so i dont think it's cheating \$\endgroup\$ Jun 27, 2021 at 20:57
  • 1
    \$\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\$ Jun 27, 2021 at 20:59
3
\$\begingroup\$

GForth 36 Bytes

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

05AB1E, 6 bytes

'*T×v,

Try it online!

'* character literal: "*"
repeat ten times as a string: "**********"
v for each character y in this string:
, print the top of stack. As the stack is empty and there is no input, this uses the value that was previously on the stack, "**********".

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

51AC8, 10 bytes

10[10\*×t]

Try it Online!

Explanation

10[10\*×t]
10          # Push 10 (for each loop; looping var)
   [        # Begin foreach loop (for 10 times)
    10      # Push 10
      \*    # Push '*'
        ×   # Multiply
         t  # Pop and print
          ] # End foreach

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

K (ngn/k), 16 14 13 bytes

` 0:10 10#"*"

Try it online!

Thanks to @Bubbler in the k tree for helping me out with this.

¯2 bytes thanks to @Bubbler

¯1 byte thanks to @Bubbler

\$\endgroup\$
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.

Alternatively:

Vyxal, 5 bytes

₁×*²⁋

Try it Online!

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

Elixir, 35 bytes

for _<-0..9,do: IO.puts"**********"

Try it online!

Originally suggested to @Chester Lynn on their answer.

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

V (vim), -v 11 bytes

i*<esc>yl9pyy9p

Try it online!

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

Also I am a sock of someone :P

-4 as I am an idot.

\$\endgroup\$
4
  • 2
    \$\begingroup\$ Ooh nice, a fellow sockpuppet \$\endgroup\$ Oct 1, 2021 at 15:32
  • \$\begingroup\$ 9i*<esc>yy9p? \$\endgroup\$
    – pxeger
    Oct 15, 2021 at 11:50
  • 1
    \$\begingroup\$ Also, this is 11 bytes, not 15 bytes, because <esc> is one byte \$\endgroup\$
    – pxeger
    Oct 15, 2021 at 11:56
  • \$\begingroup\$ dom!!!e @pxeger \$\endgroup\$
    – user107261
    Oct 16, 2021 at 7:52
3
\$\begingroup\$

Python 3, 25 24 bytes

-1 byte thanks to @Jo King

*map(print,['*'*10]*10),

Try it online!

Unpacks the map object so it actually prints the output, instead of optimising it away.

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

Cascade, 32 27 bytes

"
*
*
*
*@
*}
*|
*/
*
*.
*/

Try it online!

Aha! It turns out just printing ten asterisks ten times does beat out my more complex answer. Unfortunately though, writing this program exposed not one, but two bugs in my interpreter. Below is my longer, but higher effort solution:

Cascade, 32 bytes

_9'2
 ^*|
\ !]
(.n
n?\
\%!|
n)+\

Try it online!

One of my more compact Cascade programs. I'm still not sure if it would be shorter to just print 10 asterisks 10 times instead of using a counter, but I'm satisfied with this, especially how the bottom intersects with the top.

Explanation

The easiest way to understand the code is know the basic structure. Each instruction can take up to three inputs, each one below it.

 +
lcr

These are the left, center and right arguments. In this case, the + instruction is dyadic, meaning it takes the left and right arguments. Most instructions are either dyadic or monadic (taking one argument, the center one). The /\| instructions take only the argument they are pointing to, and the ! instructions skips over the center and takes the argument two below it. Each of these arguments can themselves be code instructions, meaning they chain together in a prefix like notation. For example, this code could be represented by the recursive Lisp-like code:

code = (if (0==(n=dec n))
         doboth
           (print (
              if (% n (+9 2)) ('*')
              else (inc 9)
           ))
           (code)
       )

If that doesn't make sense, here's an expanded look at the code, which is still a little confusing, but it at least has an idea of which parts are connected to each other through the |/\Xs. Note that the top and bottom rows are the overlap between the two (and same with the left and right).

\  |/|\ \
 _ 9 ' 2
/ \  |  /
   ^ * |
  / \  | 
 \   ! ]
\ \  \/ \
 ( . n/
 | | |   
 n ? \
  /|\ \  
 \ % ! |
  X \\ | 
 n ) +/\
\  |/|\ \

Starting from the top left corner, we have the first check (_) which executes the right branch only if the left is successful. The left goes down to the ], which sets the n variable (initially 110) to the decrement (() of n, i.e. n=n-1. The check then takes the result of this (the new value of n) and continues if it is positive. This moves onto the branch instruction on the right (^), which executes both the left and right branches.

The left prints (.) the value given by the choice instruction (?). This branches depending on the center value, which is the modulo (%) of n and the addition (+) of 9 and 2. Note that this wraps around to the top again for those digits. If n%(9+2) is 0, then we branch left, which navigates around the % and returns the increment ()) of 9, printing a newline. If it is not divisible by 11, then we go right, skip over the + with a !, and return the character (') of * to print.

Now the right branch of the ^ skips over the n, then goes right, down, and right again, wrapping around both the right edge and the bottom edge to loop back to the _ in the top left. This now loops over the exact same code until n has reached 0, printing ten asterisks and then a newline.

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

Minim, 42 37 35 Bytes

New solution halts by checking if [0] > 99.

$<42._^++[0]%10.$<10._^[0]>99.C=-1.

With whitespace and comments:

$< 42.         ; Print 42 as unicode '*'
_^ ++[0] % 10. ; Increment index 0 and skip next stmt if index 0 mod 10 is nonzero
    $< 10.     ; Print 10 as unicode '\n'
_^ [0] > 99. ; Skip next stmt if index 0 is greater than 99
    C = -1.    ; Set program counter to -1 (advances to 0 afterwards)

Old solutions halted by checking [0] == 100...

$<42._^++[0]%10.$<10._^[0]==100.C=-1.

... or used labels and gotos.

_>1.$<42._^++[0]%10.$<10._<?([0]-100)._>0.

GitHub Repository

\$\endgroup\$
4
  • 1
    \$\begingroup\$ Nice answer! Did you make this language? (Also, welcome to Code Golf!) \$\endgroup\$ Aug 13, 2021 at 3:27
  • \$\begingroup\$ @RedwolfPrograms Thank ya kindly~ Yes indeed! This is an old esolang (2017) that I resurrected last month, and have been in the process of finishing. I didn't do too bad for my first entry, I suppose! And thank you~ \$\endgroup\$ Aug 13, 2021 at 3:37
  • \$\begingroup\$ Also just realized that my program's size is the ASCII value of the asterisk! How serendipitous~ \$\endgroup\$ Aug 13, 2021 at 4:11
  • 1
    \$\begingroup\$ When I went to the esolangs article, I instantly recognised this as being from Truttle server. Welcome to the wonderful world of Code Golf! \$\endgroup\$
    – lyxal
    Aug 13, 2021 at 11:17
3
\$\begingroup\$

Flobnar, 27 bytes

6v|<
+|_,
4|<v|@
7, |
*< |<

Try it online!

Same but abusing vertical if |.


Flobnar, 32 bytes

7  009
*,!__<
6 0^|<
>___,+
^!|@

Try it online!

The ultimate abuse of the behavior of _:

'Horizontal if', denoted _, checks what the cell on the other side of it evaluates to. If that value is nonzero, it evaluates to what the cell west of it evaluates to; otherwise, it evaluates to what the cell east of it evaluates to. In either case, at most two evaluations are made.

If _ is entered horizontally, it can be used to evaluate the other side twice, or various numbers of times if chained with other _s and/or horizontal arrows.

The first half (printing * 10 times) works like this:

7
*,!       Print an asterisk and return 1
6

7  00
*,!__<    Print asterisk 10 times (enter at the lower right corner):
6  ^|<

|  Check if the west returns nonzero value
^    evaluate north
_    evaluate other side, which is 0; evaluate east
_    evaluate other side:
<      evaluate west
_      evaluate other side:
_        evaluate other side:
..!        print * and return 1
         nonzero, so evaluate west
..!        print * and return 1
       nonzero, so evaluate west
_        evaluate other side: (repeat; * is printed 4 times so far)
     nonzero, so evaluate west
_      evaluate other side: (repeat; * is printed 6 times so far)
   nonzero, so evaluate north of |
_  the other side is 0, so go right to < (repeat; * is printed 10 times in total)

The other half (going through the large loop 10 times) is more straightforward, so figuring out that part is left for the exercise to the reader.


Flobnar, 40 bytes

d1_ +
@+|\<\
::
g- < >
:1 6
%9>*>
>+,7_,

Try it online!

More explicitly controlled loop. gets 100 (d) from the position (0, 0) of the grid, and repeats that many times, printing * at every iteration and a newline every 10 loops.

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

Knight, 14 bytes

O*+*"*"10"
"10

Try it online!

Ungolfed:

OUTPUT                    Print the string:
      * "*" 10            10 copies of "*"
    +          "\n"       newline appended
  *                 10    10 times concatenated
\$\endgroup\$
3
\$\begingroup\$

Java, 103 Bytes   92 Bytes

class Main{public static void main(String[]a){System.out.print("**********\n".repeat(10));}}

Try it online!

\$\endgroup\$
1
  • 4
    \$\begingroup\$ Welcome to code golf, and nice first answer! You can remove the space between String[] and args, and it’s shorter to in-line the "**********\n" string, so you can reduce this code to 95 bytes: Try it online! \$\endgroup\$
    – noodle man
    Sep 28, 2023 at 16:39
3
\$\begingroup\$

Nibbles, 13 12 nibbles (6.0 bytes)

^10: ^10"*" "\n"

Attempt This Online!

Explanation

^10: ^10"*" "\n"    #
----------------------------------------
     ^10"*"         # replicate 10 times
   :        "\n"    # append
^10                 # replicate 10 times

-1 Nibble thanks to xigoi

\$\endgroup\$
3
  • \$\begingroup\$ Nibbles is getting pretty competitive these days... \$\endgroup\$ Mar 21, 2023 at 11:09
  • \$\begingroup\$ true... I just found an answer where someone linked ATO for Nibbles, so I just added that to my existing answers :D \$\endgroup\$
    – sfieger
    Mar 21, 2023 at 12:24
  • \$\begingroup\$ You can use "\n" instead of '\n' for -1 nibble (string literals are cheaper than character literals). \$\endgroup\$
    – xigoi
    Sep 23, 2023 at 21:14
3
\$\begingroup\$

///, 24 bytes

Leaky Nun's answer finally needed to be proven not golfed far enough!

/5/*****//-/55
55
/-----

Try it online!

\$\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, 2016 at 9:35
  • \$\begingroup\$ Yes, I'm referring to your second paragraph. \$\endgroup\$
    – orlp
    Aug 4, 2016 at 9:36
  • 1
    \$\begingroup\$ print((10*"*"+"\n")*10) is shorter. \$\endgroup\$
    – orlp
    Aug 4, 2016 at 9:37
  • \$\begingroup\$ darnit we had the same answer :( \$\endgroup\$ Aug 4, 2016 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\$ Aug 4, 2016 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, 2016 at 10:29
  • \$\begingroup\$ @LeakyNun For what? \$\endgroup\$ Aug 4, 2016 at 10:30
  • \$\begingroup\$ For developing a language. \$\endgroup\$
    – Leaky Nun
    Aug 4, 2016 at 10:30
  • \$\begingroup\$ @LeakyNun Just look at my GitHub repos... \$\endgroup\$ Aug 4, 2016 at 10:35
  • 7
    \$\begingroup\$ I didn't say "for developing your first language" \$\endgroup\$
    – Leaky Nun
    Aug 4, 2016 at 10:35
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, 2016 at 15:49
  • \$\begingroup\$ @pay has void already not sure if it needs static will check later when I have chance \$\endgroup\$ Aug 4, 2016 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, 2016 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\$ Aug 4, 2016 at 13:03
  • 2
    \$\begingroup\$ That's actually not true. I don't think it's fair to assume. \$\endgroup\$
    – arnsong
    Aug 4, 2016 at 13:55
  • 1
    \$\begingroup\$ You can save 1 byte by changing the for-loop to: for(int i=0;++i<11;) \$\endgroup\$ Aug 4, 2016 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\$ Aug 4, 2016 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, 2016 at 8:25
2
\$\begingroup\$

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.

\$\endgroup\$
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
1 2 3
4
5
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.