Print an n-by-n Box

Question

Simple problem: print an n by n box from a function.

A couple caveats:
 -You may not use any loops
 -The function must have exactly one parameter of type int (or the equivalent in your chosen language)
 -You may not partition data into this parameter (including switching it between negative and positive)
 -No global variables
 -The program must exit without an error
 -You may only use the following:
      Print a string (a single asterisk or, if needed, multiple (but must be hard-typed: e.g. print("**"); may also print a newline)
      If-then-else/switch statements
      Recursive calls
      Returning values (if needed: function may or may not return a value)
      (Local) Variable declaration/assignment/usage

Keep the spirit of the challenge, good luck!

(Preference given to most elegant/clever solution: not shortest code -- make it readable!)

Answer 1

Logo

Definitely the right tool for the job.

TO BOX :n
  FD :n RT 90
  FD :n RT 90
  FD :n RT 90
  FD :n RT 90
END

Answer 2

Python

I'm pretty sure this follows all rules and completes all objectives.

def f(n):
    print "A %s by %s box"%(n,n)

Answer 3

Brainfuck

That whole "function" concept is a bit far-fetched to me, but if you happen to leave n under the cursor, this program will print a few asterisks in a box conformation:

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

Plus, the program kinda looks like a box itself.

Answer 4

SQL (Oracle syntax)

• no loops
• no functions (argument is to be replaced in first line)
• no variables
• recursive call with CONNECT BY

SQL is the language for the task.

WITH n AS (SELECT 10 FROM dual)
SELECT LPAD('*', (SELECT * FROM n), '*') FROM dual
CONNECT BY level <= (SELECT * FROM n);

Answer 5

Haskell

Haskell doesn't have loops. Only functions. Oh, and monads.

import Control.Monad
box n = replicateM_ n (putStrLn (replicate n '*'))
main = box 10

Answer 6

Unlambda

I wasn't quite sure what counted as iteration or whether defining named functions counted against the global variables, so I picked Unlambda. This way, we're sure there'll be:

• no if/then/else
• no recursive calls
• no variables at all
• no functions of more than one parameter

The function takes one parameter of type int (encoded as a Church numeral).

``s``si``s`kd``s`kr``s``si`k.*`ki`ki

Ironically, it seems like this brings me the shortest answer as well, despite this not being a code golf :D

Answer 7

sed

Parameter is given on standard input. The last two lines are only needed to make multiple boxes possible in a single run; they're not necessary in one-shot mode.

:d
x
s/\(.*\)/\1\1\1\1\1\1\1\1\1\1/
x
/^1/ { x ; s/$/*/         ; x }
/^2/ { x ; s/$/**/        ; x }
/^3/ { x ; s/$/***/       ; x }
/^4/ { x ; s/$/****/      ; x }
/^5/ { x ; s/$/*****/     ; x }
/^6/ { x ; s/$/******/    ; x }
/^7/ { x ; s/$/*******/   ; x }
/^8/ { x ; s/$/********/  ; x }
/^9/ { x ; s/$/*********/ ; x }
s/.//
/[0-9]/ b d
g
:p
/./ { x ; p ; x ; s/.// ; b p }
x
d

Adding it here because they could be misinterpreted at first glance: the nine digit-numbered lines are part of the bignum decoding process, not (well, not really) of the box-printing one. The script handles box sizes OVER NINE without breaking a sweat. I'll limit it to 13 for presentation purposes, but I've tested sizes up to 11111111. Larger might work, but then it's too slow for my impatient self.

$ sed -f box.sed <<<13
*************
*************
*************
*************
*************
*************
*************
*************
*************
*************
*************
*************
*************

Answer 8

Emacs-Lisp

It's no fun if it doesn't move. So let's animate that a bit!

(defun box (n)
  "Create a buffer containing a asterisk box of side n.  With animation."
  (interactive "NBox size? ")
  (animate-sequence (make-list n (make-string n (string-to-char "*"))) 0))

For Emacs newcomers, here's a quick quide of how to try it. C- is Control; M- is Meta (if you don't have it use Alt.)

• if you aren't already there (it's the default buffer in most releases of Emacs), go to the *scratch* buffer: C-x b *scratch* RET
• copy-paste the code above
• evaluate it using any one of C-j, C-M-x or C-x C-e
• run it with M-x box RET
• follow the interactive instructions from there on
• optionally, destroy the newly created buffer with C-x k RET

Answer 9

Ruby, 38 29 28 23 chars

->(_){$><<[?**_]*_*?\n}

Runs in Ruby 1.9

More readable version

def box(n)
  print (['*' * n] * n).join "\n"
end

Answer 10

Python 2.7

def box(n):
    print ('*'*n+'\n')*n

Answer 11

D

void main(string[] a){
    int n=to!int(a[1]);
    void f(int i=0){
        if(n==i)return;
        void lf(int i=0){
            if(i==n)return;
            write("*");
            lf(i+1);
        }
        lf();
        writeln;
        f(i+1);
    }    
    f();
}

getting around no globals with closures

Answer 12

ASM

Source = 237 characters

Executable = 60 bytes, as assembled by A86

Size of output is specified as the first (and only) parameter on the command line.

        mov si,82h
        xor ax,ax
        xor cx,cx
    l1: imul cx,10
        add cx,ax
        lodsb
        sub al,48
        jnc l1
        push cx
        mov di,0200
        call l2
        mov ax,0a0d
        stosw
        mov ax,49956
        stosb
        mov w[l3],21cdh
        pop cx
    l2: shr cx,1
        jnc l4
        mov ax,092a
        mov dx,0200
    l3: nop
        stosb
    l4: jcxz l2-9
        push cx
        call l2
        pop cx
        jmp l2

There is a loop, the code up to and including the jnc l1, but this bit just gets the value off the command line.

A couple of questions:

1. How does the code output anything?
2. How does the program exit?

Answer 13

Interactive J

One function, no loops and no variables.

box =: '*' $~ ,~

This code defines a verb (function) box that can be used both monadic (one argument) to produce boxes of size y by y and dyadic (two arguments) to produce boxes of size x by y. Use it like this:

   box 4
****
****
****
****
   5 box 3
*****
*****
*****

The verb box generates a list of the two arguments or duplicates the argument if only one is given (,~). This list is used to build a matrix of stars ('*') with the given dimensions ($~). =: defines the verb.

Answer 14

APL

 Box ← {⎕ ← ⍵ ⍵ ⍴ '*'}

This function uses the reshape function, ⍴, to form a ⍵ by ⍵ array of the character '*'. ⍵ gives the input to the right of our function (there's also ⍺ to grab the input to the left of it). It outputs the array (⎕ ←).

Example input:

Box 4

Corresponding output:

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

As usual, I used Dyalog APL. I found the restrictions somewhat vague, so I'm not sure if this entry is acceptable.

Answer 15

HTML + CSS + JS

I chose a different language, just for the sake of trying something uncommon.

This is HTML+CSS+JS, resizing a div for the correct size (in pixels). There is no current validation of the input.

<html>
    <head></head>
    <body>
        <input type="text" id="length" onkeyup="bs=document.getElementById('box').style;s=this.value+'px';bs.width=s;bs.height=s;" />
        <div id="box" style="border: 1px solid; width: 0px;" />
    </body>
</html>

The javascript is (to take a closer look):

bs = document.getElementById('box').style;
s = this.value+'px';
bs.width = bs.height = s;

Oh, and bs stands for "box style". Don't think weird.

You can see it in action here.

Answer 16

Scala

A rare occasion where Scala can do it in a quick one-liner:

def box(size:Int)=print(Array.fill(size)("*"*size).mkString("\n"))

You can test it at SimplyScala

or maybe a recursive solution?

def box(size:Int)
{
    def b1(s:Int):String=if(s<2) "*" else "*"+b1(s-1)
    def b2(s1:Int,s2:Int):String=b1(s1)+"\n"+(if(s2<2) "" else b2(s1,s2-1))

    print(b2(size,size))
}

or (ab)using foldLeft:

def box(size:Int)
{
    val a=List.fill(size)("")
    print(a.foldLeft("")(_+_+(a.foldLeft("")(_+_+"*"))+"\n"))
}

Usage in all cases: box(n)

Answer 17

C

I think this follows the rules...

void box(int x) {
   static int n=0;
   static char *d=0;
   if (!x) { n=0; if(d) free(d); return; }
   if (!n) { n=x; d=memset(calloc(n+1, sizeof(char)), '*', n); }
   puts(d);
   box(--x);
}

Python

This should do it, right?

def box(n): print '\n'.join(['*'*n]*n)

Answer 18

PHP

function box($i){echo str_repeat(str_repeat('*',$i)."\n",$i);}

http://codepad.org/ygnwmg3Z

Answer 19

Perl

I suppose this is something like what you were looking for?

sub rep {
    my ($n, $f) = @_;
    $f->();
    rep($n-1, $f)  if $n > 1;
}

sub box {
    my ($n) = @_;
    rep $n, sub {
        rep $n, sub {
            print "*";
        };
        print "\n";
    };
}

box(8);  # print an 8x8 box

Or, if only one (named) function is allowed:

sub box {
    my ($n, $f) = @_;
    if ($f) {
        $f->();
        box($n-1, $f)  if $n > 1;
    } else {
        box( $n, sub {
            box( $n, sub {
                print "*";
            } );
            print "\n";
        } );
    }
}

Alternatively, how about abusing the regexp engine to construct pseudo-loops?

sub box {
    my ($n) = @_;
    my $x = my $y = 1 x $n;
    $x =~ s(1){
         $y =~ s(1){
             print "*";
         }eg;
         print "\n";
    }eg;
}

Or doing the same with map:

sub box {
    my ($n) = @_;
    map {
         map {
             print "*";
         } 1 .. $n;
         print "\n";
    } 1 .. $n;
}

Ps. I assumed from the task description that we were only allowed to print constant strings. If I can build a string and print it, this problem becomes remarkably simple:

sub box {
    my ($n) = @_;
    print +("*" x $n . "\n") x $n;
}

Answer 20

C#

This contest was just screaming for C# lambdas :D

    static void box(int n)
    {
        Func<int, int> Rows = null;
        Rows = r =>
            {
                Func<int, int> Columns = null;
                Columns = c =>
                    {
                        Console.Write("*");
                        if (c > 1)
                            return Columns(c - 1);
                        else
                            return 0;
                    };

                Columns(n);
                Console.WriteLine();
                if (r > 1)
                    return Rows(r - 1);
                else
                    return 0;
            };

        Rows(n);
    }

Bonus question: why do I initialize the Func<>s to null?

Answer 21

PHP:182 chars

Create ASCII box with edge parameters. Does squares and rectangles.

The square example shows more rectangle on SE when in code tag.

Deforms if you make it too big, starts to become a rectangle after 64x64, not sure you would need it bigger than that though.

function ASCIIbox($w,$l)
{
echo str_repeat("―",$w+($l+2))."<br/>";
echo str_repeat("|".str_repeat(" ",$l+$w)."|<br/>",$l);
echo str_repeat("―",$w+($l+2))."<br/>";
}

ASCIIbox(16,16);

Example:

――――――――――――――――――――――――――――――――――
|                                |
|                                |
|                                |
|                                |
|                                |
|                                |
|                                |
|                                |
|                                |
|                                |
|                                |
|                                |
|                                |
|                                |
|                                |
|                                |
――――――――――――――――――――――――――――――――――

Answer 22

QBASIC - 39 Chars

SUB B(N)
LINE (0,0)-(N,N),7,B
END SUB

So nice to have drawing methods built into the lanugage. I think this even beats Logo for simplicity.

Answer 23

Python

I'm not sure did I get it right. Main function has one parameter, local function not.

def P(n):
 def A(n): return '*'+A(n-1) if n>0 else ''
 def R(n,m):
  if n>0: print A(n+m); R(n-1,m+1)
 R(n,0)

Answer 24

A little confused on the specification, maybe this perl code counts?

sub printbox
{
  print((('*' x $_[0]) . "\n") x $_[0]);
}

Answer 25

in REXX:

parse arg n                        
say do('say print_box('n')',n)     
exit                               

do: procedure                      
    parse arg cmd,n                
    if n < 1 then return ' '       
    interpret cmd                  
    return do(cmd,n-1)             

print_box: procedure               
    parse arg n                    
    if n <= 1 then return '*'      
    return '*'||print_box(n-1)     

Answer 26

Python

This is my answer (in Python), but I think I'm cheating (i.e data partitioning):

def box(n):
    if n <= 0:
        return
    elif n < 256:
        box(n*65536 + (n-1)*256 + n)
    elif n % 256 == 0:
        sys.stdout.write('\n')
        if n % 65536 != 0:
            box(n - 256 + n//65536)
    else:
        sys.stdout.write('*')
        box(n - 1)

There's an obvious limit for size (less than 256).

I find it hard to conceive a function without argument data partitioning and no other shared storage that can produce a square, although a triangle is relatively easy.

Answer 27

Python 3

P=lambda n:Q(n*n-1,n)
def Q(c,n):
 print('*',end='')
 if not c%n:print('')
 if c:Q(c-1,n)

Answer 28

Racket

Clearly not the shortest, but works good. My boxes are empty, because... I didn't think they were supposed to be full like most did. (Which complicates the code quite a bit.) I support all sizes of boxes (0+) and complain on negative sizes. Recursive calls, no loops.

(define box ; draws a square box
  (λ (side)
    (let ((char-line #\*) ; defining characters to be used below
          (char-void #\ )
          (char-rtrn #\u000A))
      (letrec ((print-multi ; prints a character many times
                (λ (n char)
                  (unless (zero? n)
                    (printf "~a" char)
                    (print-multi (- n 1) char))))
               (print-hline ; prints the horizontal lines
                (λ (n)
                  (print-multi n char-line)
                  (printf "~a" char-rtrn)))
               (print-vlines ; prints the vertical lines
                (λ (n)
                  (unless (zero? n)
                    (printf "~a" char-line)
                    (print-multi (- side 2) char-void)
                    (printf "~a~a" char-line char-rtrn)
                    (print-vlines (- n 1))))))
        (cond
          ((> side 2) ; normal case
           (print-hline side)
           (print-vlines (- side 2))
           (print-hline side))
          ((= side 2) ; 2
           (print-hline side)
           (print-hline side))
          ((>= side 0) ; 0 and 1
           (print-hline side))
          (else
           'negative-number))))))

Testing with

(box 5)
(box 4)
(box 3)
(box 2)
(box 1)
(box 0)
(box -1)

Results in the output

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

'negative-number

Answer 29

Python (136 119 chars)

def b(n,m):
if n==1 or n==m:
    print '*'*m
else:
    print'*'+' '*(m-2)+'*'
if n>1:
    b(n-1,m)
n=m=int(input())
b(n,m)

Answer 30

Ruby, 22

->(n){$><<(?**n+$/)*n}

Today I learned that using p instead of puts doesn't parse newlines.