Desenhe o logotipo dos Jogos Olímpicos [fechado]

107

Desafio

Desenhe o logotipo dos Jogos Olímpicos ...

Logotipo dos Jogos Olímpicos

... como personagem (por exemplo, ASCII) art!

Saída de amostra

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

Sua arte não precisa se parecer exatamente com a minha, mas precisa representar os anéis olímpicos o suficiente para ser reconhecível.

Regras

  • O programa deve gravar a arte no console.
  • O código mais curto (em bytes, qualquer idioma) vence.
  • Uma solução que imprima anéis em suas respectivas cores (ou uma representação aproximada) receberá um bônus de menos vinte pontos.

O vencedor será escolhido em 23 de fevereiro rd no final dos Jogos Olímpicos de Inverno de 2014.

Vencedores

code-golf  ascii-art 
— Adam Maras
fonte
7
20 pontos de bônus. Hum, por que eu iria querer +20 na minha pontuação?
— Justin
21
Hum, isso é uma marca registrada…
— moala
4
@moala Acho que isso se enquadra na política de uso justo.
— Nzall
11
Na cor, é evidente que eles são anéis entrelaçados , não apenas sobrepostos . Até agora, poucas das entradas foram responsáveis ​​por isso.
— Rob Kennedy
6
Totalmente IANAL: ok para escrever o software que desenha os O ****** ic R ** gs, não ok para executá-lo. :-)
— Carl Witthoft

Respostas:

23

APL (82) (-20 = 62)

Editar: para variar, este programa é simples o suficiente para que o TryAPL o toque, para que você possa executá-lo (basta colar a linha).

Não tenho certeza se posso reivindicar o bit 'cor', mas estou representando todos de forma diferente.

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]

O console do APL não suporta cores, então usei caracteres de bloco sombreado (atribuir qualquer tipo de outra arte ASCII seria tão simples quanto substituir os caracteres no início da string).

Eles devem parecer círculos ininterruptos (dependendo da fonte).

      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]
    ▓▓▓▓▓▓▓▓▓▓▓▓          ████████████          ▓▓▓▓▓▓▓▓▓▓▓▓    
  ▓▓            ▓▓      ██            ██      ▓▓            ▓▓  
▓▓                ▓▓  ██                ██  ▓▓                ▓▓
▓▓            ░░░░░░░░░░░░          ▒▒▒▒▒▒▒▒▒▒▒▒              ▓▓
▓▓          ░░    ▓▓  ██  ░░      ▒▒    ██  ▓▓  ▒▒            ▓▓
▓▓        ░░      ▓▓  ██    ░░  ▒▒      ██  ▓▓    ▒▒          ▓▓
▓▓        ░░      ▓▓  ██    ░░  ▒▒      ██  ▓▓    ▒▒          ▓▓
▓▓        ░░      ▓▓  ██    ░░  ▒▒      ██  ▓▓    ▒▒          ▓▓
  ▓▓      ░░    ▓▓      ██  ░░  ▒▒    ██      ▓▓  ▒▒        ▓▓  
    ▓▓▓▓▓▓░░▓▓▓▓          ██░░██▒▒████          ▓▓▒▒▓▓▓▓▓▓▓▓    
          ░░                ░░  ▒▒                ▒▒            
            ░░            ░░      ▒▒            ▒▒              
              ░░░░░░░░░░░░          ▒▒▒▒▒▒▒▒▒▒▒▒

Ou:

      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
— marinus
fonte
165

Commodore 64 BASIC

Escrevendo diretamente na tela e na memória colorida.

Programa

Resultado:

Resultado

Veja como você faz isso com sprites.

— Danko Durbić
fonte
1
Isso é fantástico. +1. Podemos obter uma contagem de bytes?
— Adam Maras 21/01
2
Lembre-se de que você também pode abreviar comandos e números de linha no C64 BASIC se quiser jogar golfe.
— Gabriele D'Antona
15
A única coisa que me incomoda nessa resposta é: como é essa arte ascii?
— Justin
10
esta é a arte PETSCII
— Gabriele D'Antona
7
@ Quincunx: Como o PETSCII também é conhecido como CBM ASCII, isso pode se qualificar. Se você deseja que um caractere diferente seja usado para desenhar (para parecer mais com a arte clássica ASCII), substituir 160 (espaço invertido) por 42 (asterisco) na linha 100 deve resolver o problema.
— Heinzi 22/01
86

HTML Fiddle - 48 , 35 , 33 caracteres (Obrigado @ Dom e @ cnst!)

OOO<p style="margin:-15px 6px">OO

Resultado:

insira a descrição da imagem aqui

— Briguy37
fonte
2
Você pode economizar mais caracteres usando: OOO<div style="margin:-10px 5px">OOem vez disso ... (eu acho que ele precisa ser um bloco, porém, daí a <div/>)
— Dom Hastings
Como este não é saída do console, você é melhor do no concurso Jogos Olímpicos de estilo livre: codegolf.stackexchange.com/q/19050/15168
— CousinCocaine
@DomHastings: Boa chamada! Resposta atualizada :)
— Briguy37
3
Então, por que se preocupar div, basta usar p!
— precisa saber é
2
@ PygameNerd: Depende da sua definição de "arte ASCII": Sim, se sua definição for "caracteres ASCII organizados para formar uma imagem"; não se sua definição for "caracteres ASCII em um editor de texto de largura fixa para formar uma imagem". Quanto à saída para o console, como disse CousinCocaine, se a definição for "A unidade de controle ou monitoramento de um computador, contendo o teclado ou as teclas, os interruptores etc." , a saída do navegador da Web faz parte do monitor e, portanto, do console (embora provavelmente não seja esse o objetivo do OP).
— usar o seguinte código
76

BASH em cores - 271 - 20 = 251 - Com anéis emaranhados; 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}"

Resultado:

insira a descrição da imagem aqui

E por diversão : 61 - 20 = 41.

x='_4mO_3m^_0m0_2m^_1mO\n_3m V _2mV\n';printf "${x//_/\\e[3}"

insira a descrição da imagem aqui

Versão LZ77:

echo H4sIALOY5VIAA12QwRXAIAhD767ghQV8CnYbXYENOnw1YqX1xk8wQGz1UiJKKRFebLX8ARsIs7g0g/djN7CdRAYC7Pf6h+5RVR3foMdTMcqHWlS3jKr5RKO/g25doJdXZ+ii75CseU2zNkGzH6HYCPKhPGmA2Wh3+7mEDHMgb/2cUPYJH2gPhtZxAQAA|base64 -d|zcat
— Runium
fonte
13
Até agora, poucas respostas acertam a sobreposição alternada dos anéis, portanto vale a pena ser votado mesmo que a pontuação seja um pouco maior.
— Peter Taylor
1
bash: !/\\e[3}": event not found:(
— Alter Lagos
Eu acho que sua versão do bash é válida - em nenhum lugar do OP ele especifica o tamanho do gráfico - mas você precisa corrigir os anéis em forma de "V". Talvez um til (~) para o fundo dos anéis?
— AmeliaBR
@AlterLagos: Você pode encontrar trabalhos de atualização?
— Runium
@AmeliaBR: Sim, esse foi mais por diversão, e não tão sério. Tentei com vários. Talvez isso seja mais do agrado? x='54mO53m_50m052m_51mO\n53m U 52mU\n';printf "${x//5/\\e[3}"- (Eu sou um pouco mal com o 5 aqui.) Ou até isso pode ser melhor, com sobreposição em mente: x='54mO53mA50m052mA51mO\n53m U 52mU\n';printf "${x//5/\\e[3}"- embora possa parecer mais confuso do que os outros.
— Runium 22/01
76

Sinclair BASIC no ZX Spectrum 48K (261 bytes)

Listagem BASIC:

Listagem BASIC

Resultado final:

Resultado

Execução do programa e medição de código:

Programa em execução

Listagem BASIC em formato de texto:

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

Arquivo TAP com o programa, adequado para emuladores ou máquinas reais usando DivIDE ou DivMMC: http://www.zxprojects.com/images/stories/draw_the_olympics_flag.tap

— mcleod_ideafix
fonte
17
Eu gosto da parte da asciificação :) #
— Thorbjørn Ravn Andersen
1
Isso é adorável!
— precisa saber é o seguinte
O uso do gráfico do sprite Z80 é simplesmente genial !! PS subtrai 20 pontos por cores.
— Tomas
Parece tão sujo gerar arte regular e depois criar arte ASCII. :)
— undergroundmonorail
Você poderia incluir o código-fonte em um formulário capaz de copiar?
— Pa Elo Ebermann 9/09/15
44

Então, eu realmente não li direito, é arte ASCII, então acho que isso é inválido. Opa!

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

No Chrome:

O que é isso! Uma bandeira olímpica para formigas?

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";
— Dom Hastings
fonte
2
Você pode obter cores mais próximas sem penalidade: azul #06f#fa0#193
— :,
2
Como este não é saída do console, você é melhor do no concurso Jogos Olímpicos de estilo livre: codegolf.stackexchange.com/q/19050/15168
— CousinCocaine
39

Ruby: 198 caracteres - 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*''}*$/

(Observe que ^[são caracteres únicos.)

Exemplo de execução:

logotipo dos jogos olímpicos

— homem a trabalhar
fonte
37

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}]

Aqui está a saída

insira a descrição da imagem aqui

Outra versão, baseada na rasterização de gráficos vetoriais

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}]

insira a descrição da imagem aqui

— swish
fonte
2
Você ganha pontos pela saída mais bonita.
— Michael Stern
Bom trabalho. Publiquei minha própria versão do seu código.
— precisa saber é o seguinte
34

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

Eu mantenho que isso conta como "arte ASCII", embora não grave no console. Resultado:

Anéis Olímpicos

Isso poderia ser jogado um pouco mais.

— Pseudônimo
fonte
19
Se isso é arte ASCII, certamente é o primeiro que eu vi usando asteriscos rotacionados.
— TheBlastOne 22/01
2
Tenho certeza que não será o último.
— Pseudônimo
25

Script de comando do Windows - 112 % de bytes

%1%0 @echo. set
%2.= oooo 
%2,=o    o
%1%.%%.%%.%&%1%,%%,%%,%&%1o  %.%%.%  o&%1%.%%.%%.%&%1   %,%%,%&%1   %.%%.%

100% anéis olímpicos

E, claro, a versão obrigatória da fraude - 4 bytes

%~n0

salvo como:

@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
— Robert Sørlie
fonte
10
precisamos de mais respostas na BAT e CMD :)
— Einacio
21

Outra tentativa em Perl, 130 120

Obrigado ao manatwork por ajudar com isso

for(qw(15005 40410 802a0 80a28 41414 15005 808 2a0)){$s=sprintf"%20b",hex;$s=~y/01/ #/;print$s.substr(reverse($s),1).$/}

Resultado:

   # # #         # # #         # # #   
 #       #     #       #     #       # 
#         # # #         # # #         #
#       # #   # #     # #   # #       #
 #     # #     # #   # #     # #     # 
   # # #         # # #         # # #   
        #       #     #       #        
          # # #         # # #
— ossifrage melindroso
fonte
3
Você pode poupar: 4 caracteres usando em forvez de foreach; 2 caracteres removendo os argumentos de (… )round sprintf(); 2 caracteres removendo hexo parâmetro; 1 caractere usando em y///vez de tr///; 1 caractere removendo o final ;.
— precisa saber é
@manatwork Thanks! Eu nunca ouvi falar y///antes. Irá procurar agora.
— Ossifrage squeamish
20

Python: 157 140 138 133 122 122 107 caracteres

107

(graças a manatwork )

for o in"jzd360 1zlpwci 3ydgr29 20pzv5u jzd360 149ytc b8n40".split():print bin(int(o,36))[2:].rjust(34,'0')

saída de amostra:

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

(apenas comecei este, vou tentar melhorá-lo)

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:]

com melhor saída: 120 caracteres

for o in"jzd360 1zlpwci 3ydgr29 20pzv5u jzd360 149ytc b8n40".split():print bin(int(o,36))[2:].replace('0',' ').rjust(34)

saída de amostra:

   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
— evuez
fonte
1
E a base 36? Este tem 140 caracteres: print'\n'.join(['{0:b}'.format(int(o,36)).rjust(39,'0')for o in"kpvbkq0 1re099tu 3ifszg1t 3iwiuayp 1re099tu kpvbkq0 httbls 5trxmo".split()]). Em relação à versão “melhor saída”, você pode poupar rjust()o segundo parâmetro. (E inserir um “t” no título deste post.)
— manatwork
Eu estava procurando uma solução melhor, a sua está ótima!
— evuez
1
Melhoria agradável com bin(). Mas por que você está usando str()isso? bin()O valor de retorno já é str.
— precisa saber é
3
A 5ª linha não deveria ser 010000010100000101000101000001010000010? Os dois anéis inferiores parecem um pouco quebrados para mim.
— ossifrage escrúpulos
@ manatwork, de fato, não pensei nisso!
— evuez
17

Perl, 177 163

Uma versão aprimorada graças a 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;

Resultado:

  .-~-.   .-~-.   .-~-. 
 /     \ /     \ /     \
|       |       |       |       
 \    ./~\.   ./~\.    /
  '-./'   '\-/'   '\.-'
    |       |       |   
     \     / \     /
      '-.-'   '-.-'
— ossifrage melindroso
fonte
2
Viva o Perl! Algumas economias extras: em vez de usar "\n"como $r, você pode usar $/quais padrões "\n", novas linhas literais podem até economizar mais em alguns lugares. Você também pode salvar mais 1 char usando em $s=$"x3vez de $s=" ". Espero que ajude!
— Dom Hastings
15

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);}

Isso poderia ter sido um pouco mais jogado.

Isso deve ser executado no Tektronix 4010 (ou emulador como o xterm -t). Resultado:

Saída

Esta é realmente a arte ASCII, já que essas são todas '.' personagens. E produz para o console, conforme solicitado. Alguns emuladores Tektronix suportam cores. O meu não, então eu não poderia fazer isso.

— Pseudônimo
fonte
12

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);}}

(Não será compilado no jdk 1.7, requer 1.6 ou menos)

A saída:

11100011111110001111111000111
10111110111011111011101111101
01111111000111111100011111110
10111100111001110011100111101
11100011111110001111111000111
11111101111101110111110111111
11111111000111111100011111111

Definitivamente não é um vencedor, mas vamos lá, é java .

— Yurii Shylov
fonte
2
Poupar 2 caracteres por não captura em replaceAll()'s expressão regular e colocar de volta toda a parte correspondida: replaceAll(".{29}","$0\n"). (Pode haver uma quebra de linha extra no final do seu arquivo, como eu contar apenas 181 caracteres no código postado.)
— manatwork
1
Mais uma coisa: remova o importe coloque o nome do pacote diretamente na chamada do construtor. Isso reduz o tamanho para 161 caracteres.
— manatwork
Poupou mais 5 bytes mudando class M{static{...para enum M{M;{.... O próximo grande passo é se livrar do BigInteger, isso é possível? Estou tentando fazer alguma mágica com String.format, mas ainda não tenho resultados.
— Yurii Shylov 23/01
12

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]

Resultado:

            #################                       #################                       #################            
         ########### ###########                 ########### ###########                 ########### ###########         
      #######               #######           #######               #######           #######               #######      
     #####                     #####         #####                     #####         #####                     #####     
   #####                         #####     #####                         #####     #####                         #####   
  #####                           #####   #####                           #####   #####                           #####  
 #####                             ##### #####                             ##### #####                             ##### 
 ####                               #### ####                               #### ####                               #### 
 ####                               #### ####                               #### ####                               #### 
 ###                                 ### ###                                 ### ###                                 ### 
 ####                           #################                       #################                           #### 
 ####                        ########### ###########                 ########### ###########                        #### 
 #####                    #######  ##### #####  #######           #######  ##### #####  #######                    ##### 
  #####                  #####    #####   #####    #####         #####    #####   #####    #####                  #####  
   #####               #####     #####     #####     #####     #####     #####     #####     #####               #####   
     #####            #####    #####         #####    #####   #####    #####         #####    #####            #####     
      #######        #####  #######           #######  ##### #####  #######           #######  #####        #######      
         ########### ###########                 ########### ###########                 ########### ###########         
            #################                       #################                       #################            
                     ###                                 ### ###                                 ###                     
                     ####                               #### ####                               ####                     
                     ####                               #### ####                               ####                     
                     #####                             ##### #####                             #####                     
                      #####                           #####   #####                           #####                      
                       #####                         #####     #####                         #####                       
                         #####                     #####         #####                     #####                         
                          #######               #######           #######               #######                          
                             ########### ###########                 ########### ###########                             
                                #################                       #################

jogado fora de: 

{-# 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 = ' '
— Vektorweg
fonte
2
Eu ainda ri do map.mapporque soa engraçado. : D
— Vektorweg 22/01
Parece meio inchado ...
— Samb
os anéis ou o código?
— Vektorweg 27/01
Eu quero dizer os anéis :-)
— SamB 27/01
11

Ruby, 9

p"\044"*5

#sátira

As regras permitem arte que não se parece exatamente com o exemplo, mas deve "representar os anéis olímpicos o suficiente para ser reconhecível" .

Você pode reconhecer esta representação do logotipo dos Jogos Olímpicos.

— Darren Stone
fonte
Engraçado :) Como um cidadão de Chicago, posso dizer que é exatamente o que o prefeito viu quando estava cortejando os jogos!
— Dean Radcliffe
Como Vancouverita (Jogos de 2010), também posso me relacionar. :-)
— Darren Stone
8
Sinto que estou perdendo uma piada interna aqui :-P
— Maçaneta da porta
2
@DoorknobofSnow Desculpe, mas você estava confuso sobre os códigos de caracteres. Se você não conseguir a conexão entre as Olimpíadas e os cifrões, não posso ajudá-lo lá.
— AmeliaBR
8
saída é:
$
— Roger
11

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,' '))})

Resultado:

   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

Segundo Javascript - 25 caracteres

console.log('O O O\n O O')

Resultado:

O O O 
 O O

O segundo é preguiçoso

— Eduard Florinescu
fonte
1
Você pode poupar; 2 caracteres usando "4" como separador em vez de "." E usando o dígito 4 (sem aspas) como split()parâmetro; 2 caracteres removendo os últimos 2 ;s.
— manatwork
A (atualmente) Firefox versão somente os itens acima pode ser reduzido ainda mais, para 172 caracteres: 'kpvbkq041re099tu43ifszg1t43iwiuayp41sdk52824kpvbkq04httbls45trxmo'.split(4).map(x=>{a=parseInt(x,36).toString(2);console.log(' '.repeat(39-a.length)+a.replace(/0/g,' '))}).
— manatwork
Obrigado, acrescentou sua sugestão, deixarei o navegador independente por enquanto.
— Eduard Florinescu
◯ não é ASCII ...
— njzk2
@ njzk2 Yup, resolveu סּ_סּ
— Eduard Florinescu
11

Binário! (265 CHARS) 

0001111100000000111110000000011111000
0100000001000010000000100001000000010
1000000001111100000000011111000000001
0100000011000011000001100001100000010
0001111100000000111110000000011111000
0000000010000001000001000000100000000
0000000001111100000000011111000000000

É muito grande para ganhar, mas pelo menos parece legal!

— Dozer789
fonte
Logotipo olímpico na matriz.
— precisa saber é o seguinte
@ user13107 O que?
— precisa saber é o seguinte
10

PHP - 99 (-20?)

 bbbb  ####  rrrr
b    b#    #r    r
b   ybyy  g#gg   r
 bbyb  ##g#  rrrr
   y    yg    g
    yyyy  gggg

Isso é definitivamente reconhecível. Eu digo que minhas "cores" contam; é uma representação próxima.

Se você não gosta disso, então aqui está

GolfScript - 101 (-20?)

' bbbb  ####  rrrr
b    b#    #r    r
b   ybyy  g#gg   r
 bbyb  ##g#  rrrr
   y    yg    g
    yyyy  gggg'
— Justin
fonte
16
Cadê o código?
— Desfazer
14
@Undo Esse é o código ;-)
— Maçaneta da
Na verdade, eu não sei PHP. Esse é o único programa / estilo PHP que sei escrever. (Claro que passei por um tutorial, mas esqueci).
— Justin
2
O PHP não apareceria como bbbb #### rrrr bb # #rrb aaaaaaaaaaaaa?
— Lister
4
Você precisa adicionar header("Content-Type: text/plain"), o padrão para servidores web é text / html
— Kroltan
10

Bash + ImageMagick: 163 caracteres

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 ' .
'

Saída de amostra:

.

     ...........             ...........             ...........
   ....       ....         ....       ....         ....       ....
 ...             ...     ...             ...     ...             ...
..                 ..   ..                 ..   ..                 ..
..                 ..   ..                 ..   ..                 ..
.                ...........             ...........                .
..             ......   ......         ......   ......             ..
..           ...   ..   ..   ...     ...   ..   ..   ...           ..
 ...        ..   ...     ...   ..   ..   ...     ...   ..        ...
   ....     ......         ......   ......         ......     ....
     ...........             ...........             ...........
            ..                 ..   ..                 ..
            ..                 ..   ..                 ..
             ...             ...     ...             ...
               ....       ....         ....       ....
                 ...........             ...........
— homem a trabalhar
fonte
10

Perl 6: 112 77 56 caracteres, 75 bytes

say flip .ord.base(2).trans("01"=>" @")for"𜜜𢢢񃣡𦶲𜜜䔐㣠".comb
  • Unicde strings! (a sequência acima é "\ x1C71C \ x228A2 \ x438E1 \ x26DB2 \ x1C71C \ x4510 \ x38E0")
  • .comb fornece uma lista dos caracteres separados em uma string (sem argumento de qualquer maneira)
  • .ord fornece o número do código do caractere
  • .base(2) retorna uma string com codificação base-2 desse Int
  • .trans substitui os dígitos por espaço e @ para melhor visibilidade
  • flip inverte os caracteres de uma string para que os 0s em falta não atrapalhem o desenho.
  @@@ @@@ @@@
 @ @ @ @ @ @
@ @@@ @@@ @
 @ @@ @@ @@ @@ @
  @@@ @@@ @@@
    @ @ @ @
     @@@ @@@

edit2: solução mais recente usando palavras qwote e codificado na base 36

say flip :36($_).base(2).trans("01"=>" @")for<2HWC 315U 5XI9 3ESY 2HWC DN4 B8G>
  • <ABC DEF GHI> é uma sintaxe de aspas no perl6, para que você obtenha uma lista de Strings
  • :36($_)cria um Int a partir de uma string codificada na base 36 em $_( forvariável padrão do loop)

edit: a solução antiga possui um desenho melhor (copiado), mas é mais longa:

  say flip :36($_).base(2).trans("01"=>" o")for<KPVBKQ0 1RE099TU 3IFSZG1T 3IWIUAYP 1SDK5282 KPVBKQ0 HTTBLS 5TRXMO>

   ooooooooo
 oooooo
oooooooo
oooooooooo
 oooooooooo
   ooooooooo
        oooo
          oooooo
— Ayiko
fonte
10

Mathematica 185 175

10 bytes salvos pelo mathe.

Os anéis abaixo são ASCII 'O's.

A letra "O", levemente translúcida, no século gótico, impressa 5 vezes no tamanho da fonte = 145 pontos da impressora.

Isso não é arte terminal. No entanto, satisfaz plenamente a definição de arte Ascii da Wikipedia: http://en.wikipedia.org/wiki/ASCII_art .

Graphics[{Opacity@.8,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"}]

anéis olímpicos

— DavidC
fonte
2
Como este não é saída do console, você é melhor do no concurso Jogos Olímpicos de estilo livre: codegolf.stackexchange.com/q/19050/15168
— CousinCocaine
FontSize -> pode ser removido.
— Mathe
@mathe, True. Eu usei o tamanho da fonte apenas para tornar a saída um tamanho razoável.
— DavidC
@DavidC Quero dizer que você poderia substituir FontSize -> 145por 145.
— Mathe
@mathe. Sim! Obrigado.
— DavidC
8

JavaScript: 153 caracteres

Eu queria ver se conseguia fazer isso mais rápido usando álgebra para representar graficamente os círculos:

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é uma matriz de cinco (x, y) pares, os centros dos círculos, achatados para salvar dez caracteres.)

resultado:

1110000000111111111000000011111111100000001111
1000111110001111100011111000111110001111100011
0011111111100111001111111110011100111111111001
0011111111100000001111111110000000111111111001
0011111110000111000011111000011100001111111001
1000111100001111100001110000111110000111100011
1110000000111111111000000011111111100000001111
1111111100111111111001110011111111100111111111
1111111110001111100011111000111110001111111111
1111111111100000001111111110000000111111111111

159 caracteres é um pouco mais legível:

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}}

resultado:

   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

Em 167 caracteres , temos "cores":

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}}

resultado:

   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

E com 189 caracteres , também posso ajustar o raio r:

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/

— Blazemonger
fonte
7

APL, 8 caracteres / bytes *

Aqui está uma resposta que pressiona pela menor contagem de caracteres (afinal, isso é código de golfe)

2 5⍴'○ '

Resultado:

○ ○ ○
 ○ ○

O símbolo é ○, operador de círculo APL. Você pode colocar um 'O', caso deseje uma saída estritamente ASCII. Eu apenas pensei em usar um símbolo APL.

Apenas para brincadeiras, aqui está uma versão colorida (37 caracteres - 20 = 17 pontos)

2 20⍴'m',⍨¯2↓3↓∈(⊂'m○ ^[[3'),⍪'40132 '
                      ‾‾ ← single Esc character, type Ctrl+V Esc on the terminal

Saída: saída terminal de anéis coloridos ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
*: O APL pode ser gravado em seu próprio conjunto de caracteres de byte (legado) que mapeia os símbolos do APL para os valores superiores de 128 bytes. Portanto, para fins de pontuação, um programa de N caracteres que usa apenas caracteres ASCII e símbolos APL pode ser considerado como N bytes.

— Tobia
fonte
7

CSS, 1176 922 855 771 bytes, bônus de -20 cores = 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}

Somente CSS, sem necessidade de marcação. Veja violino sem marcação aqui: http://jsfiddle.net/XcBMV/12/

argolas

Em cores e com a sobreposição correta.

— Mr Lister
fonte
6

Perl - 12 caracteres

say"OOO\nOO"

OK, então não é uma renderização especialmente artística. ;-)

Ligeiramente mais bonito:

perl -MTerm::ANSIColor=:constants -E'say ON_BRIGHT_WHITE,BLUE,O,BLACK,O,RED,O,$/,YELLOW,O,GREEN,O,RESET'
— tobyink
fonte
6

Carregador OL de BIOS de 16 bits do conjunto GAS - 617 - 20 = 597

Enlouquecendo de comprimento aqui, tão mero para se divertir.

Não carrega muito, mas carrega o logotipo dos Jogos Olímpicos como ASCII com cores;)

Código:

.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) Construa e extraia imagem MBR

as -o olymp.o olymp.S
objcopy -O binary olymp.o olymp.img

Executando no emulador

(Ainda não o testei no meu computador doméstico ...)

qemu-system-i386 olymp.img

Resultado

insira a descrição da imagem aqui

— Runium
fonte
4
Você com certeza leva a idéia de não usar recursos externos ao extremo, não é? +1
— Adam Maras 24/01
@ AdamMaras: Sim, e é isso;), tinha que tentar. O próximo passo é incorporar uma carga real do sistema operacional. O`Carregador II.
— Runium
Como ele pontua se você mede o binário, supondo que o disco já tenha um setor de inicialização, para que você possa pular as 55h AAh no final (junto com qualquer preenchimento associado)?
— SamB 27/01
@ SamB: Seriam 275 bytes, 255 pt, onde a parte do código é de cerca de 91 bytes e a variável + os dados da plotagem, 184 bytes.
— Runium 27/01
5

TI-Básico (16 bytes)

Nota: O TI-Basic é tokenizado. Se bem me lembro, ClrHomee Dispsão tokens de um byte.

ClrHome
Disp "O O O"," O O
— bb94
fonte
4 
#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();
}

Feito no compilador turbo c ++ 3.0. Tentei tornar o código o mais curto possível

— Arconte
fonte
7
1) Por favor, use Markdown para marcar o bloco de código e manter o código publicado legível. 2) Como se trata de um desafio de código-golfe , tente reduzir o tamanho do seu código ao estritamente necessário. 3) Adicione uma linha de título à sua resposta (enfatizada com algumas marcações até sua preferência (geralmente cabeçalho 1 ou negrito )), especificando o idioma usado, o comprimento do código e a pontuação obtida.
— precisa saber é
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.