Dessinez le logo des Jeux Olympiques [fermé]

107

Défi

Dessinez le logo des Jeux Olympiques ...

Logo des Jeux Olympiques

... comme un personnage (par exemple, ASCII)!

Exemple de sortie

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

Votre art ne doit pas nécessairement ressembler au mien, mais il doit bien représenter les anneaux olympiques pour être reconnaissable.

Règles

  • Le programme doit écrire l’art sur la console.
  • Le code le plus court (en octets, toutes les langues) l'emporte.
  • Une solution qui imprime des anneaux dans leurs couleurs respectives (ou une représentation proche) se verra attribuer un bonus de moins vingt points.

Le gagnant sera choisi le 23 Février rd à la fin des Jeux olympiques d' hiver de 2014.

Gagnants

code-golf  ascii-art 
— Adam Maras
source
7
20 points bonus. Euh, pourquoi voudrais-je +20 à mon score?
— Justin
21
Hum, c'est une marque…
— Moala
4
@ Moala Je pense que cela relève de la politique d'utilisation équitable.
— Nzall
11
En couleur, il est évident que ce sont des anneaux qui s’emboîtent les uns dans les autres et non pas simplement se chevauchent . Jusqu'à présent, peu d'entrées l'ont expliqué.
— Rob Kennedy
6
Totalement IANAL: ok pour écrire le logiciel qui dessine le O ****** ic R ** gs, pas ok pour l’exécuter. :-)
— Carl Witthoft

Réponses:

23

APL (82) (-20 = 62)

Edit: pour faire changement, ce programme est assez simple pour que TryAPL le touche, vous pouvez donc l'exécuter ici (il suffit de coller la ligne).

Je ne suis pas sûr de pouvoir revendiquer le bit 'couleur', je les représente tous différemment.

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 console APL ne prend pas en charge les couleurs. J'ai donc utilisé des caractères ombrés (l'attribution de tout autre type d'art ASCII serait aussi simple que de remplacer les caractères au début de la chaîne.)

Ils doivent ressembler à des cercles ininterrompus (selon votre police de caractères).

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

Commodore 64 BASIC

Ecrire directement dans l'écran et dans la mémoire couleur.

Programme

Sortie:

Sortie

Voici comment vous faites cela avec les sprites.

— Danko Durbić
source
1
C'est fantastique. +1 Pouvons-nous obtenir un nombre d'octets?
— Adam Maras
2
N'oubliez pas que vous pouvez également abréger les commandes et les numéros de ligne sur C64 BASIC si vous souhaitez jouer au golf.
— Gabriele D'Antona
15
La seule chose qui me dérange dans cette réponse est: comment est cet art ascii?
— Justin
10
PETSCII-art
— Gabriele D'Antona
7
@Quincunx: PETSCII étant également appelé CBM ASCII, cela pourrait être admissible. Si vous souhaitez utiliser un caractère différent pour le dessin (afin que celui-ci ressemble davantage à de l'art ASCII classique), remplacer 160 (espace inversé) par 42 (astérisque) dans la ligne 100 devrait suffire.
— Heinzi
86

HTML Fiddle - 48 , 35 , 33 caractères (Merci @Dom et @cnst!)

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

Sortie:

entrez la description de l'image ici

— Briguy37
source
2
Vous pouvez enregistrer plus de caractères en utilisant: à la OOO<div style="margin:-10px 5px">OOplace ... (Je pense que cela doit être un bloc, d'où le <div/>)
— Dom Hastings
Comme il ne s'agit pas d'une sortie console, vous avez tout intérêt à participer au
— CousinCocaine le
@DomHastings: bon appel! Réponse mise à jour :)
— Briguy37
3
Alors pourquoi s'embêter avec div, peut simplement utiliser à la pplace!
— cnst le
2
@PygameNerd: Cela dépend de votre définition de "art ASCII": Oui si votre définition est "les caractères ASCII agencés pour former une image"; non si votre définition est "Caractères ASCII dans un éditeur de texte à largeur fixe pour former une image". Quant à savoir si elle est sortie vers la console comme CousinCocaine l’a dit, si la définition est "Unité de contrôle ou de surveillance d’un ordinateur, contenant le clavier ou les touches, commutateurs, etc." , la sortie du navigateur Web fait alors partie du moniteur et donc de la console (bien que ce ne soit probablement pas ce que l’OP voulait obtenir).
— Briguy37
76

BASH en couleur - 271 - 20 = 251 - avec anneaux enchevêtrés; 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}"

Résultat:

entrez la description de l'image ici

Et pour le plaisir : 61 - 20 = 41.

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

entrez la description de l'image ici

Version LZ77:

echo H4sIALOY5VIAA12QwRXAIAhD767ghQV8CnYbXYENOnw1YqX1xk8wQGz1UiJKKRFebLX8ARsIs7g0g/djN7CdRAYC7Pf6h+5RVR3foMdTMcqHWlS3jKr5RKO/g25doJdXZ+ii75CseU2zNkGzH6HYCPKhPGmA2Wh3+7mEDHMgb/2cUPYJH2gPhtZxAQAA|base64 -d|zcat
— Runium
source
13
Jusqu’à présent, peu de réponses ont permis d’obtenir le bon chevauchement alternatif des anneaux. C’est donc un vote positif même si le score est un peu plus élevé.
— Peter Taylor
1
bash: !/\\e[3}": event not found:(
— Alter Lagos le
Je pense que votre version bash est valide - nulle part dans l'OP ne spécifie la taille du graphique - mais vous devez corriger les anneaux en forme de "V". Peut-être un tilde (~) pour le bas des anneaux?
— AmeliaBR
@AlterLagos: Vous pourriez trouver des travaux de mise à jour?
— Runium
@AmeliaBR: Oui, celui-là était plus amusant, mais pas vraiment sérieux. Essayé avec divers. C'est peut-être plus au goût? x='54mO53m_50m052m_51mO\n53m U 52mU\n';printf "${x//5/\\e[3}"- (Je suis un peu mal avec le 5 ici.) Ou même cela pourrait être mieux, avec le chevauchement en tête: x='54mO53mA50m052mA51mO\n53m U 52mU\n';printf "${x//5/\\e[3}"- même si cela peut paraître plus compliqué que les autres.
— Runium
76

Sinclair BASIC sur le ZX Spectrum 48K (261 bytes)

Liste BASIC:

Liste de base

Résultat final:

Résultat

Programme en cours et mesure du code:

Programme en cours

Liste BASIC en format texte:

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

Fichier TAP avec le programme, adapté aux émulateurs ou aux machines réelles utilisant DivIDE ou DivMMC: http://www.zxprojects.com/images/stories/draw_the_olympics_flag.tap

— mcleod_ideafix
source
17
J'aime la partie asciification :)
— Thorbjørn Ravn Andersen
1
C'est adorable!
— pcnThird
L'utilisation du graphique de sprite Z80 est tout simplement géniale !! PS soustraire 20 points pour les couleurs.
— Tomas
C’est tellement sale de générer de l’art ordinaire puis d’en faire de l’art ASCII. :)
— undergroundmonorail
Pourriez-vous inclure le code source dans un formulaire pouvant être copié?
— Paŭlo Ebermann
44

Donc, je n'ai pas vraiment lu correctement, c'est de l'art ASCII, alors je suppose que c'est invalide. 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

En Chrome:

Qu'est-ce que c'est! Un drapeau olympique pour les fourmis?

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
source
2
Vous pouvez obtenir les couleurs un peu plus près sans pénalité: bleu #06f#fa0#193
— :,
2
Comme il ne s'agit pas d'une sortie console, vous avez tout intérêt à participer au
— CousinCocaine le
39

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

(Notez que ce ^[sont des caractères uniques.)

Échantillon échantillon:

logo des jeux olympiques

— homme au travail
source
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}]

Voici la sortie

entrez la description de l'image ici

Une autre version, basée sur la pixellisation de graphiques vectoriels

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

entrez la description de l'image ici

— bruissement
source
2
Vous obtenez des points pour la plus belle sortie.
— Michael Stern
Bon travail. J'ai posté ma propre version de votre code.
— 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

Je maintiens que cela compte comme "art ASCII", bien que cela n’écrive pas sur la console. Sortie:

Anneaux olympiques

Cela pourrait être joué un peu plus au golf.

— Pseudonyme
source
19
Si c’est de l’art ASCII, c’est sûrement le premier que j’ai vu utiliser des astérisques pivotés.
— TheBlastOne
2
Je suis sûr que ce ne sera pas la dernière.
— Pseudonyme le
25

Script de commande Windows - 112 % d' octets

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

100% des anneaux olympiques

Et bien sûr, la version cheat'ish obligatoire - 4 octets

%~n0

enregistré en tant que:

@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
source
10
nous avons besoin de plus de réponses dans BAT et CMD :)
— Einacio
21

Une autre tentative à Perl, 130 120

Merci à manatwork d’avoir aidé avec cela

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

Sortie:

   # # #         # # #         # # #   
 #       #     #       #     #       # 
#         # # #         # # #         #
#       # #   # #     # #   # #       #
 #     # #     # #   # #     # #     # 
   # # #         # # #         # # #   
        #       #     #       #        
          # # #         # # #
— ossifrage délirant
source
3
Vous pouvez épargner: 4 caractères en utilisant à la forplace de foreach; 2 caractères en supprimant les arguments de (… )round sprintf(); 2 caractères en supprimant hexle paramètre '; 1 caractère en utilisant y///au lieu de tr///; 1 personnage en supprimant la finale ;.
— Manatwork
@manatwork Merci! Je n'ai même jamais entendu parler de y///. Je vais aller le chercher maintenant.
— ossifrage délicat
20

Python: 157 140 138 133 122 107 caractères

107

(merci à manatwork )

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

exemple de sortie:

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

(Je viens de commencer celui-ci, je vais essayer de l'améliorer)

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

avec une meilleure sortie: 120 caractères

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

exemple de sortie:

   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
— évuez
source
1
Qu'en est-il de la base 36? Cela a 140 caractères: print'\n'.join(['{0:b}'.format(int(o,36)).rjust(39,'0')for o in"kpvbkq0 1re099tu 3ifszg1t 3iwiuayp 1re099tu kpvbkq0 httbls 5trxmo".split()]). En ce qui concerne la version «meilleure sortie», vous pouvez utiliser rjust()le second paramètre. (Et insérez un «t» dans l'en-tête de ce message.)
— manatwork
Je cherchais une meilleure solution, la tienne est superbe!
— evuez le
1
Belle amélioration avec bin(). Mais pourquoi utilisez-vous str()autour de cela? bin()La valeur de retour de est déjà str.
— Manatwork
3
La 5ème ligne ne devrait-elle pas l'être 010000010100000101000101000001010000010? Les deux anneaux inférieurs me semblent un peu cassés.
— ossifrage délirant
@manatwork, en effet, n'y a pas pensé!
— evuez le
17

Perl, 177 163

Une version améliorée grâce à 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;

Sortie:

  .-~-.   .-~-.   .-~-. 
 /     \ /     \ /     \
|       |       |       |       
 \    ./~\.   ./~\.    /
  '-./'   '\-/'   '\.-'
    |       |       |   
     \     / \     /
      '-.-'   '-.-'
— ossifrage délirant
source
2
Hourra pour Perl! Quelques économies supplémentaires: au lieu d’utiliser "\n"as $r, vous pouvez utiliser la valeur par $/défaut "\n", les retours à la ligne littéraux pourraient même vous faire économiser davantage à plusieurs endroits. Vous pouvez également enregistrer 1 caractère supplémentaire en utilisant $s=$"x3plutôt que $s=" ". J'espère que ça t'as aidé!
— Dom Hastings
15

C, 257 octets

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

Cela aurait pu être joué un peu plus au golf.

Cela doit être exécuté sur un Tektronix 4010 (ou un émulateur tel que xterm -t). Sortie:

Sortie

C’est en effet un art ASCII, puisque ce sont tous des "." personnages. Et il envoie la sortie à la console, comme demandé. Certains émulateurs Tektronix prennent en charge la couleur. La mienne non, alors je ne pouvais pas faire ça.

— Pseudonyme
source
12

Java, 181 179 161 156 octets

enum M{M;{System.out.print(new java.math.BigInteger("2b13bp4vx9rreb1742o0tvtpxntx0mgsfw48c4cf",36).toString(2).replaceAll(".{29}","$0\n"));System.exit(1);}}

(Ne compilera pas sur jdk 1.7, nécessite 1.6 ou moins)

Le résultat:

11100011111110001111111000111
10111110111011111011101111101
01111111000111111100011111110
10111100111001110011100111101
11100011111110001111111000111
11111101111101110111110111111
11111111000111111100011111111

Certainement pas un gagnant, mais bon, c'est java .

— Yurii Shylov
source
2
2 caractères par rechange ne capturant dans l' replaceAll()expression régulière de » et remettre toute la partie matched: replaceAll(".{29}","$0\n"). (Il se peut qu'il y ait un saut de ligne supplémentaire à la fin de votre fichier, car je ne compte que 181 caractères dans le code envoyé.)
— manatwork
1
Une dernière chose: supprimez le importet mettez le nom du paquet directement dans l’appel du constructeur. Cela réduit la taille à 161 caractères.
— Manatwork
Épargné 5 octets supplémentaires en passant class M{static{...à enum M{M;{.... La prochaine grande étape consiste à se débarrasser de BigInteger, est-ce possible? J'essaie de faire de la magie avec String.format mais je n'ai pas encore de résultats.
— 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]

Sortie:

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

joué au golf sur: 

{-# 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
source
2
Je ris encore à map.mapcause de ça parce que ça a l'air drôle. : D
— Vektorweg
Il semble un peu boursouflé ...
— SamB
les anneaux ou le code?
— Vektorweg
Je veux dire les bagues :-)
— SamB
11

Rubis, 9

p"\044"*5

#satire

Les règles permettent un art qui ne ressemble pas exactement à l'exemple, mais il doit "représenter les anneaux olympiques assez bien pour qu'il soit reconnaissable" .

Vous pouvez reconnaître cette représentation du logo des Jeux Olympiques.

— Darren Stone
source
Drôle :) En tant que Chicagoien, je peux vous dire que c’est exactement ce que le maire a vu lorsqu’il faisait la cour!
— Dean Radcliffe
En tant que Vancouverite (Jeux de 2010), je peux aussi vous raconter. :-)
— Darren Stone
8
Je sens que je suis absent sur une blague ici :-P
— Doorknob
2
@DoorknobofSnow Désolé, je pensais que vous deveniez confus à propos des codes de caractères. Si vous n'obtenez pas le lien entre les Jeux olympiques et les signes dollar, je ne pourrai pas vous aider.
— AmeliaBR
8
la sortie est:
$
— 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,' '))})

Sortie:

   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

2e javascript - 25 caractères

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

Sortie:

O O O 
 O O

Le second est paresseux

— Eduard Florinescu
source
1
Vous pouvez épargner; 2 caractères en utilisant «4» comme séparateur au lieu de «.» Et en utilisant le chiffre 4 (sans guillemets) comme split()paramètre; 2 caractères en supprimant les 2 dernières ;s.
— Manatwork
A (actuellement) Firefox version seule du plus peut être réduite ci - dessus, à 172 caractères: 'kpvbkq041re099tu43ifszg1t43iwiuayp41sdk52824kpvbkq04httbls45trxmo'.split(4).map(x=>{a=parseInt(x,36).toString(2);console.log(' '.repeat(39-a.length)+a.replace(/0/g,' '))}).
— Manatwork
Merci, a ajouté votre suggestion, je vais laisser le navigateur indépendant pour le moment.
— Eduard Florinescu
N'est pas ascii ...
— njzk2
@ njzk2 Oui, résolu _סּ
— Eduard Florinescu
11

Binaire! (265 CHARS) 

0001111100000000111110000000011111000
0100000001000010000000100001000000010
1000000001111100000000011111000000001
0100000011000011000001100001100000010
0001111100000000111110000000011111000
0000000010000001000001000000100000000
0000000001111100000000011111000000000

C'est trop gros pour gagner, mais au moins ça a l'air cool!

— Dozer789
source
Logo olympique dans la matrice.
— user13107
@ user13107 Quoi?
— Dozer789
10

PHP - 99 (-20?)

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

C'est clairement reconnaissable. Je dis que mes "couleurs" comptent; c'est une représentation proche.

Si vous n'aimez pas cela, alors voici

GolfScript - 101 (-20?)

' bbbb  ####  rrrr
b    b#    #r    r
b   ybyy  g#gg   r
 bbyb  ##g#  rrrr
   y    yg    g
    yyyy  gggg'
— Justin
source
16
Où est le code?
— Annuler
14
Ce @Undo est le code ;-)
— Doorknob
En vérité, je ne connais pas PHP. C’est le seul programme / style que je sache écrire en PHP. (Bien sûr, j'ai suivi un tutoriel, mais je l'ai oublié).
— Justin
2
La version PHP ne serait-elle pas publiée sous le nom bbbb #### rrrr bb # #rrb ybyy g # gg r bbyb ## g # rrrr y yg g yyyy gggg à l'écran?
— M. Lister
4
Vous devez ajouter que header("Content-Type: text/plain")la valeur par défaut pour les serveurs Web est text / html
— Kroltan le
10

Bash + ImageMagick: 163 caractères

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

Exemple de sortie:

.

     ...........             ...........             ...........
   ....       ....         ....       ....         ....       ....
 ...             ...     ...             ...     ...             ...
..                 ..   ..                 ..   ..                 ..
..                 ..   ..                 ..   ..                 ..
.                ...........             ...........                .
..             ......   ......         ......   ......             ..
..           ...   ..   ..   ...     ...   ..   ..   ...           ..
 ...        ..   ...     ...   ..   ..   ...     ...   ..        ...
   ....     ......         ......   ......         ......     ....
     ...........             ...........             ...........
            ..                 ..   ..                 ..
            ..                 ..   ..                 ..
             ...             ...     ...             ...
               ....       ....         ....       ....
                 ...........             ...........
— homme au travail
source
10

Perl 6: 112 77 56 caractères, 75 octets

say flip .ord.base(2).trans("01"=>" @")for"𜜜𢢢񃣡𦶲𜜜䔐㣠".comb
  • Unicde cordes! (La chaîne ci-dessus est "\ x1C71C \ x228A2 \ x438E1 \ x26DB2 \ x1C71C \ x4510 \ x38E0")
  • .comb donne une liste des caractères séparés dans une chaîne (sans argument de toute façon)
  • .ord donne le numéro de code du caractère à partir du caractère
  • .base(2) retourne une chaîne avec un encodage en base 2 de cet Int
  • .trans remplace les chiffres par des espaces et @ pour une meilleure visibilité
  • flip inverse les caractères d'une chaîne pour que les 0 manquants ne gâchent pas le dessin.
  @@@ @@@ @@@
 @ @ @ @ @ @
@ @@@ @@@ @
 @ @@@@@@@@@
  @@@ @@@ @@@
    @ @ @ @
     @@@ @@@

edit2: solution plus récente utilisant des mots qwote et encodés en base 36

say flip :36($_).base(2).trans("01"=>" @")for<2HWC 315U 5XI9 3ESY 2HWC DN4 B8G>
  • <ABC DEF GHI> est une syntaxe de mots de citation en perl6, vous obtenez donc une liste de chaînes
  • :36($_)crée un Int à partir d'une chaîne encodée en base 36 $_( forvariable de boucle par défaut)

edit: l'ancienne solution a un dessin plus joli (copié) mais est plus longue:

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

Mathematica 185 175

10 octets enregistrés par mathe.

Les anneaux ci-dessous sont des ASCII 'O's.

La lettre "O", légèrement translucide, de style gothique centré, imprimée 5 fois avec une taille de police = 145 points d’imprimante.

Ce n'est pas un art terminal. Cependant, il correspond pleinement à la définition de l'art ascii dans 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"}]

anneaux olympiques

— DavidC
source
2
Comme il ne s'agit pas d'une sortie console, vous avez tout intérêt à participer au
— CousinCocaine le
FontSize -> Peut être enlevé.
— Mathé
@mathe, vrai. J'ai utilisé la taille de la police simplement pour rendre la sortie une taille raisonnable.
— DavidC
@ David C, je veux dire que vous pourriez remplacer FontSize -> 145par 145.
— Mathe
@mathe. Oui! Merci.
— DavidC
8

JavaScript: 153 caractères

Je voulais voir si je pouvais le faire plus rapidement en utilisant l'algèbre pour représenter graphiquement les cercles:

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

( cest un tableau de cinq (x, y) paires, les centres des cercles, aplatis pour enregistrer dix caractères.)

sortie:

1110000000111111111000000011111111100000001111
1000111110001111100011111000111110001111100011
0011111111100111001111111110011100111111111001
0011111111100000001111111110000000111111111001
0011111110000111000011111000011100001111111001
1000111100001111100001110000111110000111100011
1110000000111111111000000011111111100000001111
1111111100111111111001110011111111100111111111
1111111110001111100011111000111110001111111111
1111111111100000001111111110000000111111111111

159 caractères est un peu plus lisible:

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

sortie:

   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 caractères, nous avons des "couleurs":

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

sortie:

   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

Et avec 189 caractères , je peux également régler le rayon 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
source
7

APL, 8 caractères / octets *

Voici une réponse qui demande le plus petit nombre de caractères (c'est le code de golf après tout)

2 5⍴'○ '

Sortie:

○ ○ ○
 ○ ○

Le symbole est ○, opérateur de cercle APL. Vous pouvez mettre un "O" à la place, au cas où vous voudriez une sortie strictement ASCII. Je pensais qu'il était approprié d'utiliser un symbole APL.

Juste pour le plaisir, voici une version couleur (37 caractères - 20 = 17 points)

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

Sortie: couleur anneaux sortie terminal ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
*: APL peut être écrit dans son propre jeu de caractères codé sur un octet (existant) qui mappe les symboles APL sur les valeurs supérieures à 128 octets. Par conséquent, aux fins de la notation, un programme de N caractères qui utilise uniquement des caractères ASCII et des symboles APL peut être considéré comme ayant une longueur de N octets.

— Tobia
source
7

CSS, 1176 922 855 771 octets, bonus de -20 couleurs = 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 uniquement, aucun balisage requis. Voir le violon sans bille ici: http://jsfiddle.net/XcBMV/12/

Anneaux

En couleur et avec le bon chevauchement.

— M. Lister
source
6

Perl - 12 caractères

say"OOO\nOO"

OK, ce n'est donc pas un rendu particulièrement artistique. ;-)

Légèrement plus mignon:

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

Chargeur OL pour BIOS 16 bits GAS Assembly - 617 - 20 = 597

Devenir fou ici, alors, rien que pour le plaisir.

Ça charge peu, mais ça charge le logo des Jeux Olympiques en ASCII avec des couleurs;)

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) Construire et extraire une image MBR

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

Courir dans un émulateur

(Je ne l'ai pas encore testé sur mon ordinateur personnel ...)

qemu-system-i386 olymp.img

Résultat

entrez la description de l'image ici

— Runium
source
4
Vous prenez bien l’idée de ne pas utiliser de ressources externes à l’extrême, n’est-ce pas? +1
— Adam Maras
@AdamMaras: Oui, et voilà;), a dû essayer. Suivant consiste à incorporer une charge réelle de l'OS. O`Loader II.
— Runium
Quel est le résultat si vous mesurez le binaire, en supposant que le disque possède déjà un secteur de démarrage afin que vous puissiez ignorer le 55h AAh à la fin (ainsi que tout remplissage associé)?
— SamB
@ SamB: Ce serait 275 octets, 255 pt où la partie de code est d'environ 91 octets et la variable + données de tracé 184 octets.
— Runium
5

TI-Basic (16 octets)

Remarque: TI-Basic est segmenté. Si je me souviens bien, ClrHomeet Dispsont des jetons d'un octet.

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

Fabriqué dans le compilateur turbo c ++ 3.0. J'ai essayé de rendre le code le plus court possible

— Archon
source
7
1) Veuillez utiliser Markdown pour marquer le bloc de code et garder le code affiché lisible. 2) Comme il s’agit d’un défi code-golf , veuillez essayer de réduire la taille de votre code au strict nécessaire. 3) Veuillez ajouter une ligne d’en-tête à votre réponse (soulignée par un balisage jusqu’à votre préférence (en- tête 1 ou gras habituellement )), en spécifiant la langue utilisée, la longueur du code et le score obtenu.
— Manatwork
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.