Dibuja el logo de los Juegos Olímpicos [cerrado]

107

Desafío

Dibuja el logo de los Juegos Olímpicos ...

Logo de los Juegos Olímpicos

... como personaje (por ejemplo, ASCII) art!

Salida de muestra

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

Tu arte no tiene que parecerse exactamente al mío, pero tiene que representar los anillos olímpicos lo suficientemente bien como para que sea reconocible.

Reglas

  • El programa debe escribir el arte en la consola.
  • El código más corto (en bytes, cualquier idioma) gana.
  • Una solución que imprime anillos en sus respectivos colores (o una representación cercana) recibirá una bonificación de menos veinte puntos.

El ganador será elegido de febrero 23 de rd al final de los Juegos Olímpicos de Invierno 2014.

Ganadores

code-golf  ascii-art 
— Adam Maras
fuente
77
20 puntos extra. ¿Por qué querría +20 en mi puntaje?
— Justin
21
Hum, esta es una marca registrada ...
— moala
44
@moala Creo que esto cae bajo la política de uso justo.
— Nzall
11
En color, es evidente que son anillos entrelazados , no simplemente superpuestos . Pocas de las entradas hasta ahora han explicado eso.
— Rob Kennedy
66
Totalmente IANAL: está bien para escribir el software que dibuja los O ****** ic R ** gs, no está bien para ejecutarlo. :-)
— Carl Witthoft

Respuestas:

23

APL (82) (-20 = 62)

Editar: para variar, este programa es lo suficientemente simple como para que TryAPL lo toque, por lo que puede ejecutarlo allí (solo pegue la línea).

No estoy seguro si puedo reclamar el bit 'color', aunque los estoy representando a todos de manera 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]

La consola APL no admite el color, por lo que utilicé caracteres de bloque sombreados (asignar cualquier tipo de otro arte ASCII sería tan simple como reemplazar los caracteres al comienzo de la cadena).

Deben verse como círculos ininterrumpidos (dependiendo de su fuente).

      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:

      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
fuente
165

Commodore 64 BÁSICO

Escritura directa en la pantalla y memoria de color.

Program

Salida:

Output

Así es como haces esto con los sprites.

— Danko Durbić
fuente
1
Eso es fantástico. +1. ¿Podemos obtener un conteo de bytes?
— Adam Maras
2
Recuerde que también puede abreviar comandos y números de línea en C64 BASIC si desea jugar golf.
— Gabriele D'Antona
15
Lo único que me molesta de esta respuesta es: ¿Cómo es este arte ascii?
— Justin
10
esto es PETSCII-art
— Gabriele D'Antona
77
@Quincunx: Dado que PETSCII también se conoce como CBM ASCII, esto podría calificar. Si desea que se use un personaje diferente para dibujar (para que se parezca más al arte ASCII clásico), reemplazar 160 (espacio invertido) con 42 (asterisco) en la línea 100 debería ser el truco.
— Heinzi
86

HTML Fiddle - 48 , 35 , 33 caracteres (¡Gracias @Dom y @cnst!)

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

Salida:

enter image description here

— Briguy37
fuente
2
Puede guardar más caracteres utilizando: en su OOO<div style="margin:-10px 5px">OOlugar ... (creo que debe ser un bloque, de ahí el <div/>)
— Dom Hastings
Como esto no es salida de consola, eres mejor en el concurso olímpico de estilo libre: codegolf.stackexchange.com/q/19050/15168
— CousinCocaine
@DomHastings: ¡Buena llamada! Respuesta actualizada :)
— Briguy37
3
Entonces, ¿por qué molestarse con div, solo puede usar pen su lugar!
— Cnst
2
@PygameNerd: Depende de su definición de "arte ASCII": Sí, si su definición es "caracteres ASCII dispuestos para formar una imagen"; no si su definición es "caracteres ASCII en un editor de texto de ancho fijo para formar una imagen". En cuanto a si se emite a la consola como dijo CousinCocaine, si la definición es "La unidad de control o monitoreo de una computadora, que contiene el teclado o las teclas, interruptores, etc." , la salida del navegador web es parte del monitor y, por lo tanto, de la consola (aunque esto probablemente no sea lo que pretendía el OP).
— Briguy37
76

BASH en color - 271 - 20 = 251 - Con anillos enredados; 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:

enter image description here

Y por diversión : 61 - 20 = 41.

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

enter image description here

Versión LZ77:

echo H4sIALOY5VIAA12QwRXAIAhD767ghQV8CnYbXYENOnw1YqX1xk8wQGz1UiJKKRFebLX8ARsIs7g0g/djN7CdRAYC7Pf6h+5RVR3foMdTMcqHWlS3jKr5RKO/g25doJdXZ+ii75CseU2zNkGzH6HYCPKhPGmA2Wh3+7mEDHMgb/2cUPYJH2gPhtZxAQAA|base64 -d|zcat
— Runium
fuente
13
Hasta el momento, no hay muchas respuestas que obtengan la superposición alterna de los anillos, por lo que vale la pena un voto positivo incluso si la puntuación es un poco más alta.
— Peter Taylor
1
bash: !/\\e[3}": event not found:(
— Alter Lagos
Creo que su versión bash es válida, en ninguna parte del OP especifica el tamaño del gráfico, pero debe arreglar los anillos en forma de "V". Tal vez una tilde (~) para la parte inferior de los anillos?
— AmeliaBR
@AlterLagos: ¿Puede encontrar trabajos de actualización?
— Runium
@AmeliaBR: Sí, ese fue más por diversión, y no en serio. Probado con varios. Quizás esto es más del agrado? x='54mO53m_50m052m_51mO\n53m U 52mU\n';printf "${x//5/\\e[3}"- (Soy un poco malvado con los 5 aquí.) O incluso esto podría ser mejor, con una superposición en mente: x='54mO53mA50m052mA51mO\n53m U 52mU\n';printf "${x//5/\\e[3}"- aunque podría parecer más desordenado que los otros.
— Runium
76

Sinclair BASIC en el ZX Spectrum 48K (261 bytes)

Listado BÁSICO:

BASIC listing

Resultado final:

Result

Programa en ejecución y medición de código:

Program running

Listado BÁSICO en 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

Archivo TAP con el programa, adecuado para emuladores o máquinas reales que usan DivIDE o DivMMC: http://www.zxprojects.com/images/stories/draw_the_olympics_flag.tap

— mcleod_ideafix
fuente
17
Me gusta la parte de asciificación :)
— Thorbjørn Ravn Andersen
1
¡Esto es adorable!
— pcnThird
¡El uso del gráfico de sprites Z80 es simplemente genial! PS resta 20 puntos para los colores.
— Tomás
Se siente tan sucio generar arte regular y luego hacer arte ASCII a partir de él. :)
— undergroundmonorail
¿Podría incluir el código fuente en un formulario que se pueda copiar?
— Paŭlo Ebermann
44

Así que en realidad no leí correctamente, es arte ASCII, así que supongo que esto no es válido. ¡Uy!

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

En cromo:

What is this! An Olympic flag for ants?

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
fuente
2
Usted puede obtener los colores un poco más estrechas con ninguna pena: azul: #06f, amarillo: #fa0verde:#193
— quebrantahuesos aprensivos
2
Como esto no es salida de consola, eres mejor en el concurso olímpico de estilo libre: codegolf.stackexchange.com/q/19050/15168
— CousinCocaine
39

Rubí: 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*''}*$/

(Tenga en cuenta que ^[son caracteres individuales).

Ejecución de muestra:

olympic games logo

— hombre trabajando
fuente
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}]

Aquí está la salida

ingrese la descripción de la imagen aquí

Otra versión, basada en rasterización de gráficos vectoriales

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

ingrese la descripción de la imagen aquí

— silbido
fuente
2
Obtienes puntos por la salida más bonita.
— Michael Stern
Buen trabajo. Publiqué mi propia versión de tu código.
— Mr.Wizard
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

Mantengo que esto cuenta como "arte ASCII", aunque no escribe en la consola. Salida:

Aros olímpicos

Esto podría jugarse un poco más.

— Seudónimo
fuente
19
Si esto es arte ASCII, seguramente es el primero que he visto usando asteriscos rotados.
— TheBlastOne
2
Estoy seguro de que no será el último.
— Seudónimo el
25

Script de comandos de Windows: 112 por ciento de bytes

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

100% anillos olímpicos

Y, por supuesto, la versión obligatoria de trucos - 4 bytes

%~n0

guardado 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
fuente
10
necesitamos más respuestas en BAT y CMD :)
— Einacio
21

Otro intento en Perl, 130 120

Gracias a manatwork por ayudar con esto

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

Salida:

   # # #         # # #         # # #   
 #       #     #       #     #       # 
#         # # #         # # #         #
#       # #   # #     # #   # #       #
 #     # #     # #   # #     # #     # 
   # # #         # # #         # # #   
        #       #     #       #        
          # # #         # # #
— ossifrage aprensivo
fuente
3
Puede ahorrar: 4 caracteres usando en forlugar de foreach; 2 caracteres eliminando (... argumentos de )round sprintf(); 2 caracteres eliminando hexel parámetro de; 1 personaje usando en y///lugar de tr///; 1 personaje eliminando la final ;.
— manatwork
@manatwork Gracias! Nunca he oído hablar de y///antes. Iré a buscarlo ahora.
— aprensivo ossifrage
20

Python: 157 140 138 133 122 107 caracteres

107

(gracias a manatwork )

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

salida de muestra:

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

(Acabo de comenzar este, intentaré mejorarlo)

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

con mejor salida: 120 caracteres

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

salida de muestra:

   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
fuente
1
¿Qué hay de la base 36? Esto tiene 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()]). Con respecto a la versión de "mejor salida", allí puede ahorrar rjust()el segundo parámetro. (E insertar una “t” en el encabezamiento de este post.)
— manatwork
Estaba buscando una solución mejor, ¡la tuya se ve genial!
— evuez
1
Buena mejora con bin(). Pero, ¿por qué lo usas a tu str()alrededor? bin()El valor de retorno ya está str.
— manatwork
3
¿No debería ser la quinta línea 010000010100000101000101000001010000010? Los dos anillos inferiores me parecen un poco rotos.
— aprensivo ossifrage
@manatwork de hecho, ¡no pensé en eso!
— evuez
17

Perl, 177 163

Una versión mejorada gracias 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;

Salida:

  .-~-.   .-~-.   .-~-. 
 /     \ /     \ /     \
|       |       |       |       
 \    ./~\.   ./~\.    /
  '-./'   '\-/'   '\.-'
    |       |       |   
     \     / \     /
      '-.-'   '-.-'
— ossifrage aprensivo
fuente
2
¡Hurra por Perl! Un par de ahorros adicionales: en lugar de usar "\n"como $r, puede usar los $/valores predeterminados "\n", las nuevas líneas literales incluso podrían ahorrarle más en un par de lugares. También puede guardar 1 char más usando en $s=$"x3lugar de $s=" ". ¡Espero que ayude!
— 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);}

Esto podría haberse jugado un poco más.

Esto debe ejecutarse en un Tektronix 4010 (o un emulador como xterm -t). Salida:

Salida

Este es de hecho un arte ASCII, ya que todos son '.' caracteres. Y hace salir a la consola, según lo solicitado. Algunos emuladores de Tektronix admiten color. El mío no, así que no pude hacer eso.

— Seudónimo
fuente
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);}}

(No se compilará en jdk 1.7, requiere 1.6 o inferior)

La salida:

11100011111110001111111000111
10111110111011111011101111101
01111111000111111100011111110
10111100111001110011100111101
11100011111110001111111000111
11111101111101110111110111111
11111111000111111100011111111

Definitivamente no es un ganador, pero vamos, es Java .

— Yurii Shylov
fuente
2
Reserva 2 caracteres al no capturar en replaceAll()'s expresión regular y poner de nuevo toda la parte coincidente: replaceAll(".{29}","$0\n"). (Puede haber un salto de línea extra al final de su archivo, mientras cuento sólo 181 caracteres en el código publicado.)
— manatwork
1
Una cosa más: elimine importy coloque el nombre del paquete directamente en la llamada del constructor. Eso reduce el tamaño a 161 caracteres.
— manatwork
Ahorró otros 5 bytes cambiando class M{static{...a enum M{M;{.... El siguiente gran paso es deshacerse de BigInteger, ¿es eso posible? Estoy tratando de hacer algo de magia con String.format pero todavía no tengo resultados.
— Yurii Shylov
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]

Salida:

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

golf fuera 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
fuente
2
Todavía me río map.mapporque suena gracioso. : D
— Vektorweg
Parece un poco hinchado ...
— SamB
los anillos o el código?
— Vektorweg
Me refiero a los anillos :-)
— Samb
11

Rubí, 9

p"\044"*5

#sátira

Las reglas permiten el arte que no se ve exactamente como el ejemplo, pero debe "representar los anillos olímpicos lo suficientemente bien como para que sea reconocible" .

Puede reconocer esta representación del logotipo de los Juegos Olímpicos.

— Piedra de Darren
fuente
Divertido :) Como Chicago, puedo decirte que eso es exactamente lo que el alcalde vio cuando estaba cortejando los juegos.
— Dean Radcliffe
Como Vancouverite (Juegos de 2010), también puedo relacionarme. :-)
— Darren Stone
8
Siento que me estoy perdiendo una broma interna aquí :-P
— Pomo de la puerta
2
@DoorknobofSnow Lo siento, pensé que te confundías con los códigos de personajes. Si no obtienes la conexión entre los Juegos Olímpicos y los signos de dólar, no puedo ayudarte allí.
— AmeliaBR
8
la salida es:
$
— Roger
11

Javascript - 170 185 189 Caracteres

'jzd36071zlpwci73ydgr29720pzv5u7jzd3607149ytc7b8n40'.split(7).map(function(x){a=parseInt(x,36).toString(2);console.log((Array(35-a.length).join(0)+a).replace(/0/g,' '))})

Salida:

   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

2do Javascript - 25 caracteres

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

Salida:

O O O 
 O O

El segundo es vago

— Eduard Florinescu
fuente
1
Puede sobra; 2 caracteres usando "4" como separador en lugar de "." Y usando el dígito 4 (sin comillas) como split()parámetro; 2 caracteres eliminando los últimos 2 ;s.
— manatwork
A (actualmente) Firefox versión sólo de lo anterior puede reducirse aún más, hasta 172 caracteres: 'kpvbkq041re099tu43ifszg1t43iwiuayp41sdk52824kpvbkq04httbls45trxmo'.split(4).map(x=>{a=parseInt(x,36).toString(2);console.log(' '.repeat(39-a.length)+a.replace(/0/g,' '))}).
— manatwork
Gracias, agregué su sugerencia, lo dejaré independiente del navegador por ahora.
— Eduard Florinescu
◯ no es ascii ...
— njzk2
@ njzk2 Sí, lo resolvió סּ_סּ
— Eduard Florinescu
11

¡Binario! (265 CHARS) 

0001111100000000111110000000011111000
0100000001000010000000100001000000010
1000000001111100000000011111000000001
0100000011000011000001100001100000010
0001111100000000111110000000011111000
0000000010000001000001000000100000000
0000000001111100000000011111000000000

Es demasiado grande para ganar, ¡pero al menos se ve genial!

— Dozer789
fuente
Logotipo olímpico en la matriz.
— user13107
@ user13107 ¿Qué?
— Dozer789
10

PHP - 99 (-20?)

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

Eso es definitivamente reconocible. Yo digo que mis "colores" cuentan; Es una representación cercana.

Si no te gusta, entonces aquí está

GolfScript - 101 (-20?)

' bbbb  ####  rrrr
b    b#    #r    r
b   ybyy  g#gg   r
 bbyb  ##g#  rrrr
   y    yg    g
    yyyy  gggg'
— Justin
fuente
16
¿Dónde está el código?
— Deshacer el
14
@Undo Ese es el código ;-)
— Pomo
En verdad, no sé PHP. Ese es el único programa / estilo PHP que sé escribir. (Claro que he seguido un tutorial, pero lo olvidé).
— Justin
2
¿No saldría el PHP como bbbb #### rrrr bb # #rrb ybyy g # gg r bbyb ## g # rrrr y yg g aaaa gggg en la pantalla?
— Sr. Lister el
44
Debe agregar header("Content-Type: text/plain"), el valor predeterminado para los servidores web es text / html
— Debe
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 ' .
'

Salida de muestra:

.

     ...........             ...........             ...........
   ....       ....         ....       ....         ....       ....
 ...             ...     ...             ...     ...             ...
..                 ..   ..                 ..   ..                 ..
..                 ..   ..                 ..   ..                 ..
.                ...........             ...........                .
..             ......   ......         ......   ......             ..
..           ...   ..   ..   ...     ...   ..   ..   ...           ..
 ...        ..   ...     ...   ..   ..   ...     ...   ..        ...
   ....     ......         ......   ......         ......     ....
     ...........             ...........             ...........
            ..                 ..   ..                 ..
            ..                 ..   ..                 ..
             ...             ...     ...             ...
               ....       ....         ....       ....
                 ...........             ...........
— hombre trabajando
fuente
10

Perl 6: 112 77 56 caracteres, 75 bytes

say flip .ord.base(2).trans("01"=>" @")for"𜜜𢢢񃣡𦶲𜜜䔐㣠".comb
  • Cuerdas Unicde! (la cadena de arriba es "\ x1C71C \ x228A2 \ x438E1 \ x26DB2 \ x1C71C \ x4510 \ x38E0")
  • .comb da una lista de los caracteres separados en una cadena (sin argumento de todos modos)
  • .ord da el número de código del personaje del personaje
  • .base(2) devuelve una cadena con codificación de base 2 de ese Int
  • .trans reemplaza los dígitos con espacio y @ para una mejor visibilidad
  • flip invierte los caracteres de una cadena para que los 0 iniciales que faltan no estropeen el dibujo.
  @@@ @@@ @@@
 @ @ @ @ @ @
@ @@@ @@@ @
 @ @@ @@ @@ @@ @
  @@@ @@@ @@@
    @ @ @ @
     @@@ @@@

edit2: solución más nueva que usa palabras qwote y codificación base 36

say flip :36($_).base(2).trans("01"=>" @")for<2HWC 315U 5XI9 3ESY 2HWC DN4 B8G>
  • <ABC DEF GHI> es una sintaxis de comillas en perl6, por lo que obtienes una lista de cadenas
  • :36($_)crea un Int a partir de una cadena codificada en base 36 $_( forvariable predeterminada del bucle)

editar: la solución anterior tiene un dibujo más bonito (copiado) pero es más largo:

  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
fuente
10

Mathematica 185 175

10 bytes guardados por mathe.

Los anillos a continuación son ASCII 'O's.

La letra "O", ligeramente translúcida, en Century Gothic, impresa 5 veces en tamaño de letra = 145 puntos de impresora.

Esto no es arte terminal. Sin embargo, satisface completamente la definición de Wikipedia del arte Ascii: 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"}]

aros olímpicos

— DavidC
fuente
2
Como esto no es salida de consola, eres mejor en el concurso olímpico de estilo libre: codegolf.stackexchange.com/q/19050/15168
— CousinCocaine
FontSize -> se puede quitar.
— Mathe
@mathe, cierto. Utilicé el tamaño de fuente simplemente para hacer que la salida tuviera un tamaño razonable.
— DavidC
@DavidC Quiero decir que podría reemplazar FontSize -> 145por 145.
— mathe
@mathe. ¡Si! Gracias.
— DavidC
8

JavaScript: 153 caracteres

Quería ver si podía hacerlo más rápido usando álgebra para representar gráficamente los 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}}

( ces una matriz de cinco (x, y) pares, los centros de los círculos, aplanados para guardar diez caracteres).

salida:

1110000000111111111000000011111111100000001111
1000111110001111100011111000111110001111100011
0011111111100111001111111110011100111111111001
0011111111100000001111111110000000111111111001
0011111110000111000011111000011100001111111001
1000111100001111100001110000111110000111100011
1110000000111111111000000011111111100000001111
1111111100111111111001110011111111100111111111
1111111110001111100011111000111110001111111111
1111111111100000001111111110000000111111111111

159 caracteres es un poco más legible:

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

salida:

   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

En 167 caracteres tenemos "colores":

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

salida:

   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

Y con 189 caracteres , también puedo hacer que el radio sea rajustable:

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

APL, 8 caracteres / bytes *

Aquí hay una respuesta que impulsa el recuento de char más bajo (después de todo, esto es código golf)

2 5⍴'○ '

Salida:

○ ○ ○
 ○ ○

El símbolo es ○, operador de círculo APL. Puede poner una 'O' en su lugar, en caso de que desee una salida estrictamente ASCII. Simplemente pensé que era apropiado usar un símbolo APL.

Solo por diversión, aquí hay una versión en color (37 caracteres - 20 = 17 puntos)

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

Salida: salida de terminal de anillos de color ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ *: APL se puede escribir en su propio juego de
caracteres de un solo byte (heredado) que asigna símbolos APL a los valores superiores de 128 bytes. Por lo tanto, para fines de puntuación, un programa de N caracteres que solo usa caracteres ASCII y símbolos APL puede considerarse que tiene una longitud de N bytes.

— Tobia
fuente
7

CSS, 1176 922 855 771 bytes, -20 bonificación de color = 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}

Solo CSS, no se necesita marcado. Ver violín sin marcas aquí: http://jsfiddle.net/XcBMV/12/

Anillos

En color, y con la superposición correcta.

— Señor lister
fuente
6

Perl - 12 caracteres

say"OOO\nOO"

OK, entonces no es una representación especialmente artística. ;-)

Un poco más lindo:

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

Ensamblador GAS Cargador OL de BIOS de 16 bits - 617 - 20 = 597

Me estoy volviendo loco aquí, tan solo por el gusto de hacerlo.

No carga mucho, pero carga el logotipo de los Juegos Olímpicos como ASCII con colores;)

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) Construir y extraer imagen MBR

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

Corriendo en emulador

(Todavía no lo he probado en la computadora de mi casa ...)

qemu-system-i386 olymp.img

Resultado

ingrese la descripción de la imagen aquí

— Runium
fuente
44
Seguro que llevas la idea de no utilizar recursos externos al extremo, ¿no? +1
— Adam Maras
@AdamMaras: Sí, y está eso;), tuve que intentarlo. Lo siguiente es incorporar una carga real de SO. O`Loader II.
— Runium
¿Cómo se califica si mide el binario, suponiendo que el disco ya tenía un sector de arranque para que pueda omitir el 55h AAh al final (junto con cualquier relleno asociado)?
— SamB
@SamB: Eso sería 275 bytes, 255 pt donde la parte del código es de aproximadamente 91 bytes y la variable + datos de trazado 184 bytes.
— Runium
5

TI-Basic (16 bytes)

Nota: TI-Basic está tokenizado. Si no recuerdo mal, ClrHomey Dispson tokens de un byte.

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

Hecho en el compilador turbo c ++ 3.0. Intenté hacer el código lo más corto posible

— Arconte
fuente
77
1) Utilice Markdown para marcar el bloque de código y mantener legible el código publicado. 2) Como se trata de un desafío de código de golf , intente reducir el tamaño de su código a lo estrictamente necesario. 3) Agregue una línea de encabezado a su respuesta (enfatizada con algunas marcas según su preferencia (generalmente encabezado 1 o negrita )), especificando el idioma utilizado, la longitud del código y la puntuación obtenida.
— manatwork
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.