[Question]
  [
**Closed**. This question needs to be more [focused](/help/closed-questions). It is not currently accepting answers.
 
 
Closed 7 years ago.
**Locked**. This question and its answers are [locked](/help/locked-posts) because the question is off-topic but has historical significance. It is not currently accepting new answers or interactions.
 
 
# Challenge
Draw the Olympic Games logo...
![Olympic Games logo](https://i.stack.imgur.com/FroIE.png)
...as character (e.g. ASCII) art!
# Sample Output
```
      * * *               * * *               * * *
  *           *       *           *       *           *
*               *   *               *   *               *
*               * * *               * * *               *
*           *   *   *   *       *   *   *   *           *
  *       *   *       *   *   *   *       *   *       *
      * * *               * * *               * * *
          *               *   *               *
            *           *       *           *
                * * *               * * *
```
Your art doesn't have to look exactly like mine, but it has to represent the Olympic rings well enough that it's recognizable.
# Rules
* The program must write the art to the console.
* Shortest code (in bytes, any language) wins.
* **A solution that prints rings in their respective colors (or a close representation) will be awarded a minus-twenty-point bonus.**
The winner will be chosen on February 23rd at the end of the 2014 Winter Olympics.
---
# Winners
* **Gold**: marinus - [APL, 62 points](https://codegolf.stackexchange.com/a/19053/1654)
* **Silver**: Ayiko - [Perl 6, 75 points](https://codegolf.stackexchange.com/a/19005/1654)
* **Bronze**: evuez - [Python, 107 points](https://codegolf.stackexchange.com/a/19003/1654)
* **Popular choice**: Danko Durbiƒá - [Commodore 64 BASIC](https://codegolf.stackexchange.com/a/19009/1654)
  
[Answer]
## Commodore 64 BASIC
Writing directly in the screen and color memory.
![Program](https://i.stack.imgur.com/PbKOc.png)
**Output:**
![Output](https://i.stack.imgur.com/gmn8m.gif)
---
[Here's how you do this with sprites.](https://codegolf.stackexchange.com/questions/19050/olympic-games-logo-free-style-edition/19159#19159)
[Answer]
## [HTML Fiddle](http://jsfiddle.net/briguy37/hT9vP/) - 48, 35, 33 characters (Thanks @Dom and @cnst!)
```
OOO<p style="margin:-15px 6px">OO
```
Output:
![enter image description here](https://i.stack.imgur.com/wvzNG.png)
[Answer]
## BASH in color - 271 - 20 = 251 ‚Äì With entangled rings ;P
```
o='_4mGA  _0mGA  _1mG\n _4m/A \A _0m/A \\_1mA /A \\\n_4mD_3m---_0mD_2m---_1mD\n _4m\A_3m/_4m/A_0m\\_3m\\A_2m/_0m/A_1m\\_2m\A _1m/\n_4mG_3mD_0m---_2mD_1m---\n_3m   A\A /A _2m\A /_1m\n _3mA G  A_2mG\n';o=${o//D/|A   |};o=${o//A/    };o=${o//G/   ---};printf "${o//_/\\e[3}"
```
Result:
![enter image description here](https://i.stack.imgur.com/9pt9n.png)
---
### And the *for fun* of it one: 61 - 20 = 41.
```
x='_4mO_3m^_0m0_2m^_1mO\n_3m V _2mV\n';printf "${x//_/\\e[3}"
```
![enter image description here](https://i.stack.imgur.com/d8ZlH.png)
---
[Answer]
# Sinclair BASIC on the ZX Spectrum 48K (261 bytes)
BASIC listing:
![BASIC listing](https://i.stack.imgur.com/qFs8J.png)
Final result:
![Result](https://i.stack.imgur.com/rHop7.png)
Program running and code measuring:
![Program running](https://i.stack.imgur.com/eW96H.gif)
BASIC listing in text format:
```
5 INK VAL "7": CLS 
10 LET a=VAL "42": LET b=VAL "131": LET c=VAL "40": CIRCLE INK SGN PI;a,b,c: CIRCLE INK PI-PI;a+a+a,b,c: CIRCLE INK VAL "2";VAL "210",b,c
20 LET a=VAL "84": LET b=VAL "87": CIRCLE INK VAL "6";a,b,c: CIRCLE INK VAL "4";a+a,b,c
30 FOR l=PI-PI TO VAL "21": FOR c=PI-PI TO VAL "31": IF ATTR (l,c)<>VAL "63" THEN PRINT INK VAL "8";AT l,c;"*"
40 NEXT c: NEXT l
```
TAP file with the program, suitable for emulators or real machine using DivIDE or DivMMC:
<http://www.zxprojects.com/images/stories/draw_the_olympics_flag.tap>
[Answer]
So I didn't actually read properly, it's ASCII-art, so I guess this is invalid. Oops!
---
## HTML 121 (141 - 20)
```
<pre style=line-height:3px;letter-spacing:-3px><font color=#06f>O <font color=#000>O <font color=red>O
 <font color=#fa0>O <font color=#193>O
```
In Chrome:
![What is this! An Olympic flag for ants?](https://i.stack.imgur.com/tdbOh.png)
## PHP 103 (123 - 20)
```
<pre style=line-height:3px;letter-spacing:-3px><?=($f='<font color=')."#06f>O ${f}#000>O ${f}red>O
 ${f}#fa0>O ${f}#193>O";
```
[Answer]
# Ruby: 198 characters - 20 = 178
```
a=[*0..9].map{[' ']*35}
d=->c,x,y=0{11.times{|i|7.times{|j|a[y+j][x+i]="^[[3#{c}m#^[[0m"if[248,774,1025,1025,1025,774,248][j]&1<<i!=0}}}
d[4,0]
d[0,12]
d[1,24]
d[3,6,3]
d[2,18,3]
$><<a.map{|r|r*''}*$/
```
(Note that `^[` are single characters.)
Sample run:
![olympic games logo](https://i.stack.imgur.com/Muutr.png)
[Answer]
# Mathematica - 185
```
c[x_, y_] := 
 Table[Boole[Abs[(i - x)^2 + (j - y)^2 - 16] < 4], {i, 0, 15}, {j, 0, 
   30}]
MatrixForm@
 Replace[Blue c[5, 4] + Black c[5, 14] + Red c[5, 24] + 
   Yellow c[9, 9] + Green c[9, 19], {0 -> "", 
   c_ + _ | c_ :> Style["*", c]}, {2}]
```
Here is the ouput
![enter image description here](https://i.stack.imgur.com/CKXA6.png)
Another version, based on rasterization of vector graphics
```
MatrixForm@
 Replace[ImageData@
   Rasterize[
    Graphics[{Blue, Circle[{4, 9}, 4], Black, Circle[{14, 9}, 4], Red,
       Circle[{24, 9}, 4], Yellow, Circle[{9, 4}, 4], Green, 
      Circle[{19, 4}, 4]}], ImageSize -> {30, 15}], {c_ :> 
    Style["*", RGBColor@c]}, {2}]
```
![enter image description here](https://i.stack.imgur.com/DPrxq.png)
[Answer]
PostScript, 203 (-20 = 183)
```
%!
/Courier findfont 12 scalefont setfont
/l { setrgbcolor translate 20 { 0 30 moveto (*) show 18 rotate } repeat } def
140 200 0 0 1 l 45 -30 1 1 0 l 45 30 0 0 0 l 45 -30 0 1 0 l 45 30 1 0 0 l
showpage
```
I maintain that this counts as "ASCII art", though it doesn't write to the console. Output:
![Olympic Rings](https://i.stack.imgur.com/ViILg.png)
This could be golfed a little more.
[Answer]
## Windows Command Script - 112 percent bytes
```
%1%0 @echo. set
%2.= oooo 
%2,=o    o
%1%.%%.%%.%&%1%,%%,%%,%&%1o  %.%%.%  o&%1%.%%.%%.%&%1   %,%%,%&%1   %.%%.%
```
![100% Olympic rings](https://i.stack.imgur.com/KEthe.png)
**And of course, the obligatory cheat'ish version - 4 bytes**
```
%~n0
```
saved as:
```
@echo. oooo  oooo  oooo&echo.o    oo    oo    o&echo.o   oooo  oooo   o&echo. oooo  oooo  oooo&echo.   o    oo    o&echo.    oooo  oooo.cmd
```
[Answer]
## APL (82) (-20 = 62)
Edit: for a change, this program is simple enough that [TryAPL](http://tryapl.com) will touch it, so you can run it there (just paste the line in).
Not sure if I can claim the 'color' bit, I'm representing them all differently though.
```
2/' ‚ñì‚ñà‚ñë‚ñì‚ñí'[1+(13‚Üë‚çân)‚åà¬Ø13‚Üë‚çâ32‚Üë¬Ø26‚Üë‚åà1.1√ó11‚Üìn‚Üê‚çâc,0,2√óc,0,2√óc‚Üê(‚ç≥2/10)‚àä‚åà5+5√ó1 2‚àò‚óã¬®‚ç≥1e4]
```
The APL console doesn't support color, so I used shaded block characters (assigning any kind of other ASCII art would be as simple as replacing the characters at the beginning of the string.)
They should look like unbroken circles (depending on your font.)
```
      2/' ‚ñì‚ñà‚ñë‚ñì‚ñí'[1+(13‚Üë‚çân)‚åà¬Ø13‚Üë‚çâ32‚Üë¬Ø26‚Üë‚åà1.1√ó11‚Üìn‚Üê‚çâc,0,2√óc,0,2√óc‚Üê(‚ç≥2/10)‚àä‚åà5+5√ó1 2‚àò‚óã¬®‚ç≥1e4]
    ‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì          ‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà          ‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì    
  ‚ñì‚ñì            ‚ñì‚ñì      ‚ñà‚ñà            ‚ñà‚ñà      ‚ñì‚ñì            ‚ñì‚ñì  
‚ñì‚ñì                ‚ñì‚ñì  ‚ñà‚ñà                ‚ñà‚ñà  ‚ñì‚ñì                ‚ñì‚ñì
‚ñì‚ñì            ‚ñë‚ñë‚ñë‚ñë‚ñë‚ñë‚ñë‚ñë‚ñë‚ñë‚ñë‚ñë          ‚ñí‚ñí‚ñí‚ñí‚ñí‚ñí‚ñí‚ñí‚ñí‚ñí‚ñí‚ñí              ‚ñì‚ñì
‚ñì‚ñì          ‚ñë‚ñë    ‚ñì‚ñì  ‚ñà‚ñà  ‚ñë‚ñë      ‚ñí‚ñí    ‚ñà‚ñà  ‚ñì‚ñì  ‚ñí‚ñí            ‚ñì‚ñì
‚ñì‚ñì        ‚ñë‚ñë      ‚ñì‚ñì  ‚ñà‚ñà    ‚ñë‚ñë  ‚ñí‚ñí      ‚ñà‚ñà  ‚ñì‚ñì    ‚ñí‚ñí          ‚ñì‚ñì
‚ñì‚ñì        ‚ñë‚ñë      ‚ñì‚ñì  ‚ñà‚ñà    ‚ñë‚ñë  ‚ñí‚ñí      ‚ñà‚ñà  ‚ñì‚ñì    ‚ñí‚ñí          ‚ñì‚ñì
‚ñì‚ñì        ‚ñë‚ñë      ‚ñì‚ñì  ‚ñà‚ñà    ‚ñë‚ñë  ‚ñí‚ñí      ‚ñà‚ñà  ‚ñì‚ñì    ‚ñí‚ñí          ‚ñì‚ñì
  ‚ñì‚ñì      ‚ñë‚ñë    ‚ñì‚ñì      ‚ñà‚ñà  ‚ñë‚ñë  ‚ñí‚ñí    ‚ñà‚ñà      ‚ñì‚ñì  ‚ñí‚ñí        ‚ñì‚ñì  
    ‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì‚ñë‚ñë‚ñì‚ñì‚ñì‚ñì          ‚ñà‚ñà‚ñë‚ñë‚ñà‚ñà‚ñí‚ñí‚ñà‚ñà‚ñà‚ñà          ‚ñì‚ñì‚ñí‚ñí‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì‚ñì    
          ‚ñë‚ñë                ‚ñë‚ñë  ‚ñí‚ñí                ‚ñí‚ñí            
            ‚ñë‚ñë            ‚ñë‚ñë      ‚ñí‚ñí            ‚ñí‚ñí              
              ‚ñë‚ñë‚ñë‚ñë‚ñë‚ñë‚ñë‚ñë‚ñë‚ñë‚ñë‚ñë          ‚ñí‚ñí‚ñí‚ñí‚ñí‚ñí‚ñí‚ñí‚ñí‚ñí‚ñí‚ñí                
```
Or:
```
      2/' bByRg'[1+(13‚Üë‚çân)‚åà¬Ø13‚Üë‚çâ32‚Üë¬Ø26‚Üë‚åà1.1√ó11‚Üìn‚Üê‚çâc,0,2√óc,0,2√óc‚Üê(‚ç≥2/10)‚àä‚åà5+5√ó1 2‚àò‚óã¬®‚ç≥1e4]
    bbbbbbbbbbbb          BBBBBBBBBBBB          RRRRRRRRRRRR    
  bb            bb      BB            BB      RR            RR  
bb                bb  BB                BB  RR                RR
bb            yyyyyyyyyyyy          gggggggggggg              RR
bb          yy    bb  BB  yy      gg    BB  RR  gg            RR
bb        yy      bb  BB    yy  gg      BB  RR    gg          RR
bb        yy      bb  BB    yy  gg      BB  RR    gg          RR
bb        yy      bb  BB    yy  gg      BB  RR    gg          RR
  bb      yy    bb      BB  yy  gg    BB      RR  gg        RR  
    bbbbbbyybbbb          BByyBBggBBBB          RRggRRRRRRRR    
          yy                yy  gg                gg            
            yy            yy      gg            gg              
              yyyyyyyyyyyy          gggggggggggg                
```
[Answer]
# Another attempt in Perl, ~~130~~ 120
Thanks to manatwork for helping with this
```
for(qw(15005 40410 802a0 80a28 41414 15005 808 2a0)){$s=sprintf"%20b",hex;$s=~y/01/ #/;print$s.substr(reverse($s),1).$/}
```
Output:
```
   # # #         # # #         # # #   
 #       #     #       #     #       # 
#         # # #         # # #         #
#       # #   # #     # #   # #       #
 #     # #     # #   # #     # #     # 
   # # #         # # #         # # #   
        #       #     #       #        
          # # #         # # #          
```
[Answer]
# Python: ~~157~~ ~~140~~ ~~138~~ ~~133~~ ~~122~~ 107 characters
## 107
(thanks to [manatwork](https://codegolf.stackexchange.com/questions/18986/draw-the-olympic-games-logo#comment37393_19003))
```
for o in"jzd360 1zlpwci 3ydgr29 20pzv5u jzd360 149ytc b8n40".split():print bin(int(o,36))[2:].rjust(34,'0')
```
sample output:
```
0001001000000001001000000001001000
0100000010000100000010000100000010
1000000001001000000001001000000001
0100000110000110000110000110000010
0001001000000001001000000001001000
0000000100000010000100000010000000
0000000001001000000001001000000000
```
## 157
```
print'\n'.join(['{0:b}'.format(o).rjust(39,'0') for o in [45099909288,137984246274,275230249985,276241138945,137984246274,45099909288,1078001920,352343040]])
```
## 122
(just started this one, I will try to improve it)
```
h=lambda x:bin(int("15bb511iun9aqulod22j8d4 ho8skh  "[x::8],36))[2:].rjust(20)
for x in range(8):print h(x)+h(x)[::-1][1:]
```
---
### with better output: 120 characters
```
for o in"jzd360 1zlpwci 3ydgr29 20pzv5u jzd360 149ytc b8n40".split():print bin(int(o,36))[2:].replace('0',' ').rjust(34)
```
sample output:
```
   1  1        1  1        1  1   
 1      1    1      1    1      1 
1        1  1        1  1        1
 1     11    11    11    11     1 
   1  1        1  1        1  1   
       1      1    1      1       
         1  1        1  1         
```
[Answer]
# Perl, ~~177~~ 163
An improved version thanks to Dom Hastings:
```
$s=$"x3;print"  .-~-. "x3 .$/." /$s  \\"x3 .$/."|$s$s "x4 ."
 \\$s ./~\\.$s./~\\.$s /
  '-./'$s'\\-/'$s'\\.-'
"."$s |$s"x3 ."
$s "." \\$s  /"x2 ."
$s"."$s'-.-'"x2;
```
Output:
```
  .-~-.   .-~-.   .-~-. 
 /     \ /     \ /     \
|       |       |       |       
 \    ./~\.   ./~\.    /
  '-./'   '\-/'   '\.-'
    |       |       |   
     \     / \     /
      '-.-'   '-.-'
```
[Answer]
# C, 257 bytes
```
#include <stdio.h>
d(i,j){int r=35;float x=r,y=0;while(--r>0){char s[8]={29,(((int)y+j)/32)+32,(((int)y+j)%32)+96,(((int)x+i)/32)+32,(((int)x+i)%32)+64,31,'.',0};puts(s);x-=0.2*y;y+=0.2*x;}}main(){d(140,200);d(185,170);d(230,200);d(275,170);d(320,200);}
```
This could have been golfed a bit more.
This has to be run on a Tektronix 4010 (or an emulator such as xterm -t). Output:
![Ooutput](https://i.stack.imgur.com/tUidi.png)
This is indeed ASCII art, since those are all '.' characters. And it does output to the console, as requested. Some Tektronix emulators support colour. Mine didn't, so I couldn't do that.
[Answer]
# Java, ~~181~~ ~~179~~ ~~161~~ 156 bytes
```
enum M{M;{System.out.print(new java.math.BigInteger("2b13bp4vx9rreb1742o0tvtpxntx0mgsfw48c4cf",36).toString(2).replaceAll(".{29}","$0\n"));System.exit(1);}}
```
(Won't compile on jdk 1.7, requires 1.6 or lower)
The output:
```
11100011111110001111111000111
10111110111011111011101111101
01111111000111111100011111110
10111100111001110011100111101
11100011111110001111111000111
11111101111101110111110111111
11111111000111111100011111111
```
Definitely not a winner, but come on, it's *java*.
[Answer]
# Haskell, 200
```
main=mapM(putStrLn.map(\b->if b then '#' else ' '))$(map.map)(\(x,y)->or$map(\(n,m)->(<2).abs.(18-)$sqrt$(n-x)^2+(m-y*2)^2)$[(20,20),(60,20),(100,20),(40,40),(80,40)])$map(zip[0..120].repeat)[0..30]
```
Output:
```
            #################                       #################                       #################            
         ########### ###########                 ########### ###########                 ########### ###########         
      #######               #######           #######               #######           #######               #######      
     #####                     #####         #####                     #####         #####                     #####     
   #####                         #####     #####                         #####     #####                         #####   
  #####                           #####   #####                           #####   #####                           #####  
 #####                             ##### #####                             ##### #####                             ##### 
 ####                               #### ####                               #### ####                               #### 
 ####                               #### ####                               #### ####                               #### 
 ###                                 ### ###                                 ### ###                                 ### 
 ####                           #################                       #################                           #### 
 ####                        ########### ###########                 ########### ###########                        #### 
 #####                    #######  ##### #####  #######           #######  ##### #####  #######                    ##### 
  #####                  #####    #####   #####    #####         #####    #####   #####    #####                  #####  
   #####               #####     #####     #####     #####     #####     #####     #####     #####               #####   
     #####            #####    #####         #####    #####   #####    #####         #####    #####            #####     
      #######        #####  #######           #######  ##### #####  #######           #######  #####        #######      
         ########### ###########                 ########### ###########                 ########### ###########         
            #################                       #################                       #################            
                     ###                                 ### ###                                 ###                     
                     ####                               #### ####                               ####                     
                     ####                               #### ####                               ####                     
                     #####                             ##### #####                             #####                     
                      #####                           #####   #####                           #####                      
                       #####                         #####     #####                         #####                       
                         #####                     #####         #####                     #####                         
                          #######               #######           #######               #######                          
                             ########### ###########                 ########### ###########                             
                                #################                       #################                                
```
golfed out of: 
```
{-# LANGUAGE NoMonomorphismRestriction #-}
olympMids = [(1,1),(3,1),(5,1),(2,2),(4,2)]
circleRadius = 0.9
circleBorder = 0.1
scaleFactor = 20
verticalScale = 0.5
distance :: Floating a => (a,a) -> (a,a) -> a
distance (x,y) (x2,y2) = sqrt $ (x2-x)^2 + (y2-y)^2
match :: (Floating a, Ord a) => (a,a) -> (a,a) -> Bool
match v v2 = (<circleBorder) . abs . (circleRadius-) $ distance v v2
matchOlymp :: (Floating a, Ord a) => (a,a) -> Bool
matchOlymp v = or $ map (match $ scale v) $ olympMids
  where
    scale (x,y) = (x / scaleFactor, y / scaleFactor / verticalScale)
board :: (Enum a, Num a) => a -> a -> [[(a, a)]]
board lx ly = map (zip [0..lx] . repeat) [0..ly]
printOlymp = mapM (putStrLn . map to) $ (map.map) matchOlymp $ board 120 30
main = printOlymp
to :: Bool -> Char
to True = '#'
to False = ' '
```
[Answer]
## Ruby, 9
```
p"\044"*5
```
**#satire** 
The rules allow for art that does not look exactly like the example, but it must *"represent the Olympic rings well enough that it's recognizable"*. 
You may recognize this representation of the Olympic Games logo.
[Answer]
# Javascript - 170 ~~185~~ ~~189~~ Chars
```
'jzd36071zlpwci73ydgr29720pzv5u7jzd3607149ytc7b8n40'.split(7).map(function(x){a=parseInt(x,36).toString(2);console.log((Array(35-a.length).join(0)+a).replace(/0/g,' '))})
```
**Output:**
```
   1  1        1  1        1  1    
 1      1    1      1    1      1  
1        1  1        1  1        1 
 1     11    11    11    11     1  
   1  1        1  1        1  1    
       1      1    1      1        
         1  1        1  1         
```
# 2nd Javascript - 25 Chars
```
console.log('O O O\n O O')
```
**Output:**
```
O O O 
 O O 
```
The second is lazy
[Answer]
**Binary! (265 CHARS)** 
```
0001111100000000111110000000011111000
0100000001000010000000100001000000010
1000000001111100000000011111000000001
0100000011000011000001100001100000010
0001111100000000111110000000011111000
0000000010000001000001000000100000000
0000000001111100000000011111000000000
```
It is too large to win, but at least it looks cool!
[Answer]
# PHP - 99 (-20?)
```
 bbbb  ####  rrrr
b    b#    #r    r
b   ybyy  g#gg   r
 bbyb  ##g#  rrrr
   y    yg    g
    yyyy  gggg
```
That is definitely recognizable. I say that my "colors" count; it's a close representation.
If you don't like that, then here is
# GolfScript - 101 (-20?)
```
' bbbb  ####  rrrr
b    b#    #r    r
b   ybyy  g#gg   r
 bbyb  ##g#  rrrr
   y    yg    g
    yyyy  gggg'
```
[Answer]
# Bash + ImageMagick: 163 characters
```
e=ellipse
c=,10,5,0,360
convert -size 70x20 xc:black +antialias -stroke white -fill none -draw "$e 10,5$c$e 34,5$c$e 58,5$c$e 22,10$c$e 46,10$c" xpm:-|tr -dc ' .
'
```
Sample output:
```
.
     ...........             ...........             ...........
   ....       ....         ....       ....         ....       ....
 ...             ...     ...             ...     ...             ...
..                 ..   ..                 ..   ..                 ..
..                 ..   ..                 ..   ..                 ..
.                ...........             ...........                .
..             ......   ......         ......   ......             ..
..           ...   ..   ..   ...     ...   ..   ..   ...           ..
 ...        ..   ...     ...   ..   ..   ...     ...   ..        ...
   ....     ......         ......   ......         ......     ....
     ...........             ...........             ...........
            ..                 ..   ..                 ..
            ..                 ..   ..                 ..
             ...             ...     ...             ...
               ....       ....         ....       ....
                 ...........             ...........
```
[Answer]
## Perl 6: ~~112~~ ~~77~~ 56 characters, 75 bytes
```
say flip .ord.base(2).trans("01"=>" @")for"úúú¢¢¢ÒÉ£°¶∂≤úúú‰îê„£†".comb
```
* Unicde strings! (above string is "\x1C71C\x228A2\x438E1\x26DB2\x1C71C\x4510\x38E0")
* `.comb` gives a List of the separate characters in a String (without argument anyway)
* `.ord` gives character code number from character
* `.base(2)` returns a string with base-2 encoding of that Int
* `.trans` replaces the digits with space and @ for better visibility
* `flip` reverses the characters of a string so that missing leading 0's don't mess up the drawing.
```
  @@@   @@@   @@@
 @   @ @   @ @   @
@    @@@   @@@    @
 @  @@ @@ @@ @@  @
  @@@   @@@   @@@
    @   @ @   @
     @@@   @@@
```
---
edit2: newer solution using qwote words and base-36 encoded
```
say flip :36($_).base(2).trans("01"=>" @")for<2HWC 315U 5XI9 3ESY 2HWC DN4 B8G>
```
* `<ABC DEF GHI>` is a quote-words syntax in perl6, so you get a list of Strings
* `:36($_)` creates an Int from a base-36 encoded string in `$_` (`for` loop default variable)
---
edit: old solution has nicer (copied) drawing but is longer:
```
  say flip :36($_).base(2).trans("01"=>" o")for<KPVBKQ0 1RE099TU 3IFSZG1T 3IWIUAYP 1SDK5282 KPVBKQ0 HTTBLS 5TRXMO>
```
```
   o o o         o o o         o o o
 o       o     o       o     o       o
o         o o o         o o o         o
o       o o   o o     o o   o o       o
 o     o o     o o   o o     o o     o
   o o o         o o o         o o o
        o       o     o       o
          o o o         o o o
```
[Answer]
# Mathematica ~~185~~ 175
10 bytes saved by mathe.
The rings below are ASCII 'O's.
The letter "O", slightly translucent, in Century Gothic, printed 5 times at font size=145 printer points.
This is not terminal art. However it fully satisfies Wikipedia's definition of Ascii art: <http://en.wikipedia.org/wiki/ASCII_art>.
```
Graphics[{[[email protected]](/cdn-cgi/l/email-protection),Style["O",#]~Text~#2&@@@{{Blue,{-1.5,1}},{Black,{0,1}},{Red,{1.5,1}},{Orange,{-.8,.4}},{Darker@Green,{.8,.4}}}},BaseStyle->{145,FontFamily->"Century Gothic"}]
```
![olympic rings](https://i.stack.imgur.com/xoUuV.png)
[Answer]
**JavaScript: 153 chars**
I wanted to see if I could do it any faster using algebra to actually graph the circles:
```
s="";c=[3,7,11,7,19,7,7,4,15,4];for(y=10;y>0;y--){s+="\n";for(x=0;x<23;x+=.5){t=1;for(i=0;i<9;i+=2){a=x-c[i];b=y-c[i+1];d=a*a+b*b-9;t&=(d<0?-d:d)>3}s+=t}}
```
(`c` is an array of five (x,y) pairs, the centers of the circles, flattened to save ten characters.)
output:
```
1110000000111111111000000011111111100000001111
1000111110001111100011111000111110001111100011
0011111111100111001111111110011100111111111001
0011111111100000001111111110000000111111111001
0011111110000111000011111000011100001111111001
1000111100001111100001110000111110000111100011
1110000000111111111000000011111111100000001111
1111111100111111111001110011111111100111111111
1111111110001111100011111000111110001111111111
1111111111100000001111111110000000111111111111
```
**159 chars** is a little more readable:
```
s="";c=[3,7,11,7,19,7,7,4,15,4];for(y=10;y>0;y--){s+="\n";for(x=0;x<23;x+=.5){t=1;for(i=0;i<9;i+=2){a=x-c[i];b=y-c[i+1];d=a*a+b*b-9;t&=(d<0?-d:d)>3}s+=t?" ":t}}
```
output:
```
   0000000         0000000         0000000    
 000     000     000     000     000     000  
00         00   00         00   00         00 
00         0000000         0000000         00 
00       0000   0000     0000   0000       00 
 000    0000     0000   0000     0000    000  
   0000000         0000000         0000000    
        00         00   00         00         
         000     000     000     000          
           0000000         0000000            
```
In **167 chars** we have "colors":
```
s="";c=[3,7,11,7,19,7,7,4,15,4];for(y=10;y>0;y--){s+="\n";for(x=0;x<23;x+=.5){t=1;for(i=0;i<9;i+=2){a=x-c[i];b=y-c[i+1];d=a*a+b*b-9;t&=(d<0?-d:d)>3;h=t?i:h}s+=t?" ":h}}
```
output:
```
   8888888         0000000         2222222    
 888     888     000     000     222     222  
88         88   00         00   22         22 
88         8844400         0066622         22 
88       4444   0044     6600   2266       22 
 888    4444     0004   6000     2226    222  
   8888888         0000000         2222222    
        44         44   66         66         
         444     444     666     666          
           4444444         6666666            
```
And with **189 chars**, I can make the radius `r` adjustable as well:
```
r=5;s="";c=[r,0,2*r+1,r,3*r+2,0,4*r+3,r,5*r+4,0];for(y=-r;y<3*r;y++){s+="\n";for(x=0;x<9*r;x+=.5){t=1;for(i=0;i<9;i+=2){a=x-c[i];b=y-c[i+1];d=a*a+b*b-r*r;t&=(d<0?-d:d)>r;h=t?i:h}s+=t?" ":h}}
```
<http://jsfiddle.net/mblase75/5Q6BX/>
[Answer]
# APL, 8 chars/bytes\*
Here's an answer pushing for lowest char count (this is code golf after all)
```
2 5‚ç¥'‚óã '
```
Output:
```
‚óã ‚óã ‚óã
 ‚óã ‚óã 
```
The symbol is ‚óã, APL circle operator. You can put an 'O' instead, in case you want strictly ASCII output. I just thought it fit to use an APL symbol.
---
Just for kicks, here's a color version (37 chars - 20 = 17 score)
```
2 20‚ç¥'m',‚ç®¬Ø2‚Üì3‚Üì‚àà(‚äÇ'm‚óã ^[[3'),‚ç™'40132 '
                      ‚Äæ‚Äæ ‚Üê single Esc character, type Ctrl+V Esc on the terminal
```
Output:
![color rings terminal output](https://i.stack.imgur.com/odDwd.png)
‚éØ‚éØ‚éØ‚éØ‚éØ‚éØ‚éØ‚éØ‚éØ‚éØ‚éØ‚éØ‚éØ‚éØ  
\*: APL can be written in its own (legacy) single-byte charset that maps APL symbols to the upper 128 byte values. Therefore, for the purpose of scoring, a program of N chars *that only uses ASCII characters and APL symbols* can be considered to be N bytes long.
[Answer]
# CSS, ~~1176~~ ~~922~~ ~~855~~ 771 bytes, -20 colour bonus = 751
```
html,head,title,body{display:block; color:transparent; font:bold 1em/1 monospace; height:0}
link,meta,style{display:none}
:before,:after{float:left; color:#000; white-space:pre;
content:'   @@@@@@@\A  @@@     @@@\A@@         @@ \A            @@\A@@         @@\A@@         @@\A  @@@     @@@\A    @@@@  @'}
html:before{color:blue}
title:before,title:after{color:blue; position:absolute; left:0; top:3em; content:'@@'}
title:after{color:red; top:7em; content:'                                   @@'}
head:after{color:red}
body:before{clear:left; content:'     '}
body:after,html:after{position:relative; top:-5em; color:#EC0;
content:'    @  @@@@\A   @@@     @@@\A  @@         @@\A  @@         @@\A  @@\A  @@         @@\A   @@@     @@@\A     @@@@@@@'}
html:after{color:#090}
```
CSS only, no markup needed. See markupless fiddle here: <http://jsfiddle.net/XcBMV/12/>
![Rings](https://i.stack.imgur.com/MaFhG.png)
In colour, and with the correct overlap.
[Answer]
**Perl - 12 characters**
```
say"OOO\nOO"
```
OK, so it's not an especially artistic rendering. ;-)
Slightly cuter:
```
perl -MTerm::ANSIColor=:constants -E'say ON_BRIGHT_WHITE,BLUE,O,BLACK,O,RED,O,$/,YELLOW,O,GREEN,O,RESET'
```
[Answer]
# GAS Assembly 16-bit BIOS OL loader ‚Äì 617 - 20 = 597
Going crazy on length here, so mere for the fun of it.
---
It does not load much, but it loads The Olympic Games logo as ASCII with colors ;)
Code:
```
.code16;S:jmp o;nop;o:mov $1984,%ax;mov %ax,%ds;mov %ax,%es;movw $t,%si;r:lodsb;or %al,%al;jz q;cmp $33,%al;jg k;movb $0,c;call X;inc %dh;mov $0,%dl;call G;jmp r;k:sub $48,%al;mov %al,%cl;add %al,c;lodsb;cmp $32,%al;je v;mov %al,%bl;and $15,%bl;mov $35,%al;v:mov $9,%ah;mov $0,%bh;mov $0,%ch;int $16;call X;mov c,%dl;call G;jmp r;q:ret;G:mov $2,%ah;int $16;X:mov $3,%ah;mov $0,%bh;int $16;ret;c:.byte 0;t:.asciz "3 5A9 5H9 5D!1 1A7 1A5 1H7 1H5 1D7 1D!1A9 1A4N9 1H4B9 1D!1A7 1N1 1A3 1H1 1N5 1B1 1H3 1D1 1B7 1D!1 1A5 1N1 1A5 1H1 1N3 1B1 1H5 1D1 1B5 1D!3 4A1N9 4H1B9 5D!8 1N7 1N5 1B7 1B!9 1 5N9 5B!";.=S+510;.word 0xaa55
```
### (Linux) Build and extract MBR image
```
as -o olymp.o olymp.S
objcopy -O binary olymp.o olymp.img
```
### Running in emulator
*(Have not tested it on my home computer yet ...)*
```
qemu-system-i386 olymp.img
```
### Result
![enter image description here](https://i.stack.imgur.com/llY1L.png)
[Answer]
# TI-Basic (16 bytes)
Note: TI-Basic is tokenized. If I remember correctly, `ClrHome` and `Disp` are one-byte tokens.
```
ClrHome
Disp "O O O"," O O
```
[Answer]
```
#include<iostream.h>
#include<conio.h>
#define tc textcolor
void circle(int x,int y,int k)
{
  tc(k);
  int n;
  for(n=0;n<=6;n++)
  {
    if(n==0||n==6)
    {
      gotoxy(x+3,y+n);
      cprintf("* * *");
    }
    else if(n==1||n==5)
    {
      gotoxy(x+1,y+n);
      cprintf("*");
      gotoxy(x+9,y+n);
      cprintf("*");
    }
    else if(n>1&&n<5)
    {
      gotoxy(x,y+n);
      cprintf("*");
      gotoxy(x+10,y+n);
      cprintf("*");
    }
  }
}
void main()
{
  clrscr();
  circle(1,1,BLUE);
  circle(14,1,WHITE);
  circle(27,1,RED);
  circle(8,4,YELLOW);
  circle(21,4,GREEN);
  _setcursortype(0);
  getch();
}
```
![Made in turbo c++ 3.0 compiler. Tried t make the code as short as possible](https://i.stack.imgur.com/hJDA5.jpg)
]