# Calculate 6*9 in different bases

Output the following result (which is a result of calculating 6 * 9 in bases from 2 to 36). Make sure letters are uppercase, and the multiplication itself is outputed on every line.

``````6 * 9 = 110110
6 * 9 = 2000
6 * 9 = 312
6 * 9 = 204
6 * 9 = 130
6 * 9 = 105
6 * 9 = 66
6 * 9 = 60
6 * 9 = 54
6 * 9 = 4A
6 * 9 = 46
6 * 9 = 42
6 * 9 = 3C
6 * 9 = 39
6 * 9 = 36
6 * 9 = 33
6 * 9 = 30
6 * 9 = 2G
6 * 9 = 2E
6 * 9 = 2C
6 * 9 = 2A
6 * 9 = 28
6 * 9 = 26
6 * 9 = 24
6 * 9 = 22
6 * 9 = 20
6 * 9 = 1Q
6 * 9 = 1P
6 * 9 = 1O
6 * 9 = 1N
6 * 9 = 1M
6 * 9 = 1L
6 * 9 = 1K
6 * 9 = 1J
6 * 9 = 1I
``````

Shortest code wins.

-
It's the result from bases 2 to 36, not 10 to 36. – Howard Jan 5 '14 at 10:04
@Howard: Fixed. I was considering changing 2 to 10, but forgot about this edit while fixing something else in the result, so I accidentally left it the wrong way. – xfix Jan 5 '14 at 10:06
The challenge would be more interesting if you weren't allowed to use to use library functions for base conversion. – nitro2k01 Jan 5 '14 at 11:07
`Calculate 6*9 in different bases` I wonder why the statement is worded thus, why `6*9` and not simply `54`? Perhaps the originally intended meaning was that `6` and `9` should be interpreted not always as decimal but in different bases? That would make the statement more logical, and the problem more interesting (but then we should start from base 10 to 36) – leonbloy Jan 5 '14 at 16:16
@IlmariKaronen: Correct, but `6 * 9 = 110110` doesn't make a lot of sense... – Dennis Jan 5 '14 at 18:09

### GolfScript, 39 characters

``````35,{2+'6 * 9 = '54@base{.9>7*+48+}%n+}/
``````

Result can be seen here.

-

## Octave, 49

`for i=2:36printf("6 * 9 = %s\n",dec2base(54,i))end`

-

Javascript (57)

``````for(i=2;i<37;i++)console.log('6 * 9 = '+(54).toString(i))
``````

Could be shortened to 51 with `alert`, but I don't want to submit anyone to that...

-
Output should be uppercase, and `(54)` can be replaced with `54.` (to write `54..toString`). – xfix Jan 5 '14 at 11:03
`for(i=1;++i<37;)` also saves a character. – grc Jan 5 '14 at 11:42

# Ruby (47)

``````2.upto(36){|t|puts"9 * 6 = "+54.to_s(t).upcase}
``````

Well, I know that GolfScript solution is better, but hey, at least this is not esoteric...

-

## Python, 89

``````B=lambda x:x*'.'and B(x/b)+chr(x%b+7*(x%b>9)+48)
b=2
while b<37:print'6 * 9 =',B(54);b+=1
``````
-
Brilliant. Quite noticeable that I'm a total Python noob in comparison :) – Joachim Isaksson Jan 5 '14 at 21:02
@JoachimIsaksson Thanks... I've got loads more to learn. – boothby Jan 5 '14 at 21:58
You can shave off one character by using a while loop instead: `b=2` <linebreak> `while b<37:print'6 * 9 =',B(54);b+=1` (assuming single character for a *nix linebreak) – Bob Jan 5 '14 at 22:53
@Bob Whenever I try a while loop, it's too expensive. Then, I forget to try the next time. ;) Thanks! – boothby Jan 5 '14 at 23:00

Python 2.7 (124 114)

EDIT: Cut some fluff thanks to @boothby's comment below

I think Python is doing ok considering it has no built-in (that I know of) to do the base conversion so it has to be done in code;

``````for b in range(2,37):print'6 * 9 = '+''.join(chr((54/b**y%b>9)*7+48+54/b**y%b)for y in range(4,-1,-1)).lstrip('0')
``````
-
I have to remind myself of this continually: `print'\n'.join(...for x in y)` is rather longer than `for x in y:print...`. – boothby Jan 5 '14 at 15:54
@boothby Thanks, updated with your suggestion :) – Joachim Isaksson Jan 5 '14 at 20:32

# Mathematica 40

Not in contention (lower case letters used):

``````Print["6*9 = ",54~BaseForm~#]&/@2~Range~36
``````

-

Julia, 61

for b=2:36;@printf("6 * 9 = %s\n",uppercase(base(b,54)));end

Pretty painless, apart from remembering to use the macro @printf versus printf.

Import Base; not needed ...

-
`for b=2:36;println("6 * 9 = \$(uppercase(base(b,54)))");end` is also good... – cormullion Jan 26 '14 at 12:13

# J - 78 70

``````'6 * 9 = ',"1>;/(a.#~48 10 7 26 165#0 1 0 1 0){~<&.>(2+i.35)#.inv&.>54
``````

``````let s=['0'..'9']++['A'..'Z'];t _(0,r)=[s!!r];t b(q,r)=(t b\$b q)++[s!!r]in mapM_(putStrLn.("6 * 9 = "++).(\b->t b\$b 54).flip divMod)[2..36]
``````
-

CoffeeScript 71

``````alert ("6 * 9 = "+59.toString(x).toUpperCase()for x in[2..36]).join "\n"
``````

-

## C (166 151)

Got rid of some unnecessary characters and changed some declarations. Assumes that you are running the program with no arguments.

``````p[7],i,l,v,r;main(b){for(r=2;r<37;r++){b++;printf("6 * 9 = ");v=54;while(v>0)l=v%b,p[i++]=l>9?l+55:l+48,v/=b;while(i^0)printf("%c",p[--i]);puts("");}}
``````
-

## Clojure, 75

`(for[i(range 2 37)](println"6 * 9 ="(.toUpperCase(Integer/toString 54 i))))`

-

## Scala, 71

``````2 to 36 map(i=>println("6 * 9 = "+Integer.toString(54,i).toUpperCase))
``````
-

Common Lisp: 56 characters

``````(do((b 2(1+ b)))((> b 36))(format t"6 * 9 = ~vr~%"b 54))
``````
-

Perl

Had to use the Math::BaseCnv module

35 chars without the `use` statement:

``````map{say"6 * 9 = ",cnv(54,\$_)}2..36
``````

54 chars with the `use` statement:

``````use Math::BaseCnv;
map{say"6 * 9 = ",cnv(54,\$_)}2..36
``````

Not sure how you'd score this, so both are included.

The map BLOCK LIST structure was used. List is the range 2 to 36, that was requested. The meat is in the `cnv(\$NUMBER, \$BASE)` function, and the map is an implied loop.

-
Count the `use` statement. The first one doesn't work in my perl. – boothby Jan 5 '14 at 22:09

## Sage, 48:

Shame Sage prints in lowercase... I'd only be one over Howard. Or, I guess, wrong and tied with David Carraher.

``````for i in[2..36]:print'6 * 9 =',54.str(i).upper()
``````
-

## Forth, 54

``````: f 54 37 2 do ." 6 * 9 = " dup i base ! . cr loop ; f
``````
-