Trouvez un moyen de faire des cercles d'un rayon donné en utilisant des caractères dans une console. Veuillez spécifier le nom et la taille de la police. Veuillez également fournir au moins un exemple de sortie.

Par exemple:

Contribution:

3

Production:

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

... Eh bien, quelque chose de plus beau que ce "cercle" "dessiné à la main" avec un rayon de 3.

Question bonus: Ellipses. :)

Javascript (360)

function c(r){var f=1.83;var e=2*Math.PI/(r*r*r*r*r);var s=r*2+1;var g=Array(s);for(var i=0;i<s;i++){g[i]=Array(Math.round(s*f))};for(var i=0;i<=2*Math.PI;i+=e) {var x=Math.round(f*r*Math.cos(i)+f*r);var y=Math.round(r*Math.sin(i))+r;g[y][x]=1;}for(var j=0;j<g.length;j++){for(var i=0;i<g[j].length;i++)document.write((g[j][i]==1)?'*':' ');document.writeln()}}

http://jsfiddle.net/YssSb/3/ ( fest un facteur de correction pour le rapport hauteur de ligne / largeur de police. Si vous utilisez un paramètre de police carré, par exemple, définissez line-height = font-size, vous pouvez définir f = 1 et obtenez des cercles "carrés". Ou définissez farbitrairement les ellipses.)

Sortie pour 3 (assez intéressant, accidentellement exactement la même forme que OP), 5, 15:

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

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

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

un cercle de Bresenham à Scala (35)

L'algorithme de Bresenham a 2 points principaux:

• fonctionne sans péché / cosinus.
• vous ne calculez que ¼ * ½ cercle, les autres points sont trouvés en miroir.

Comment faire:

       2 1  
     DCBABCD
   GFE | EFG
  IJ y | ---- JI
 GJ | / JG
 F | / | F
DE | r / | ED
C | / | C
B 4 | / | B 3
A + ------- A
B 4 pi x B 3 pi
CC
DE ED
 FF
 GJ JG
  IJ JI
   GFE EFG
     DCBABCD
       2'1 ' 

• Nous calculons uniquement les nombres de A dans le zénit à I.
  • Le point I est à 45 °, défini par x == y.
  • Le zéro du sol est l'endroit où se trouve le +.
  • Le A dans le zénit est le point (x = 0, y = r), r = rayon.
  • Pour dessiner un cercle fermé, nous nous déplaçons dans le sens des aiguilles d'une montre (++ x), ce qui est à droite (x + = 1) ou au point suivant, (y- = 1).
  • chaque point (x, y) du cercle est r éloigné du centre. Pythagore dit, r² = x² + y².
  • Cela sent la racine carrée et les équations avec 2 solutions, mais attention!
  • nous commençons en A et voulons savoir si nous peignons ensuite le point en dessous ou le point en dessous à droite.
• nous calculons pour les deux points (x² + y²) et construisons pour les deux la différence à r² (qui reste bien sûr constante).
  • puisque la différence peut être négative, on en retire les abdos.
  • on regarde ensuite quel point est le plus proche du résultat (r²), eo ipso plus petit.
  • en fonction de cela, nous dessinons le voisin droit ou inférieur.
• le point ainsi trouvé
  • 1 x, y se reflète
  • 2 -x, y à gauche
  • 3 y, x en diagonale
  • 4-y, x de là vers la gauche
• tous ces points se reflètent à nouveau au sud
  • 1 'x, -y
  • 2 '-x, -y
  • 3 'y, -x
  • 4 '-y, -x terminé.

Ce n'est pas du golf de code, mais tous ces chiffres en haut des solutions existantes m'ont fait penser que c'était le cas, alors j'ai passé un temps inutile à jouer au golf avec ma solution. J'ai donc ajouté un numéro inutile en haut aussi. C'est 11 fois Pi arrondi.

object BresenhamCircle extends App {
    var count = 0
    val r = args(0).toInt
    // ratio > 1 means expansion in horizontal direction
    val ratio = args(1).toInt
    val field = ((0 to 2 * r).map (i=> (0 to 2 * r * ratio).map (j=> ' ').toArray)).toArray
    def square (x: Int, y: Int): Int = x * x + y * y
    def setPoint (x: Int, y: Int) {
        field (x)(y*ratio) = "Bresenham"(count)
        field (y)(x*ratio) = "Bresenham"(count)
    }
    def points (x: Int, y: Int)
    {
        setPoint (r + x, r + y)
        setPoint (r - x, r + y)
        setPoint (r + x, r - y)
        setPoint (r - x, r - y)
    }
    def bresenwalk () {
        var x = 0;
        var y = r;
        val rxr = r * r
        points (x, y);
        do 
        {
            val (dx, dy) = { if (math.abs (rxr - square ((x+1), y)) < math.abs (rxr - square (x, (y-1))))
                (1, 0)
            else
                (0, -1) 
            }
            count = (count + 1) % "Bresenham".length
            x += dx
            y += dy
            points (x, y)
        }while ((x <= y))
    }
    bresenwalk ()
    println (field.map (_.mkString ("")).mkString ("\n"))
}

La question de police est décidée par le serveur Web des sites et les paramètres de votre navigateur. Maintenant que je regarde c'est

'Droid Sans Mono',Consolas,Menlo,Monaco,Lucida Console,Liberation Mono,DejaVu Sans Mono,Bitstream Vera Sans Mono,Courier New,monospace,serif

La taille de la police est de 12 pixels. Des informations assez inutiles, si vous me demandez, mais qui le fait?

Bonus: ellipses et exemple de sortie:

L'invocation est

    scala BresenhamCircle SIZE RATIO

par exemple

    scala BresenhamCircle 10 2
              s e r B r e s              
          h n e           e n h          
      e m a                   a m e      
    e r                           r e    
    m                               m    
  h a                               a h  
  n                                   n  
s e                                   e s
e                                       e
r                                       r
B                                       B
r                                       r
e                                       e
s e                                   e s
  n                                   n  
  h a                               a h  
    m                               m    
    e r                           r e    
      e m a                   a m e      
          h n e           e n h          
              s e r B r e s           

A ratio of 2 will print a circular shape for most fonts which happen to be about twice as tall than wide. To compensate for that, we widen by 2. 
# As smaller value than 2 only 1 is available: 

scala BresenhamCircle 6 1
    erBre    
  aes   sea  
 ah       ha 
 e         e 
es         se
r           r
B           B
r           r
es         se
 e         e 
 ah       ha 
  aes   sea  
    erBre    

# widening it has more freedom:

scala BresenhamCircle 12 5
                                             s    e    r    B    r    e    s                                             
                              a    h    n    e                             e    n    h    a                              
                         B    m                                                           m    B                         
                    e    r                                                                     r    e                    
               e    s                                                                               s    e               
          B    r                                                                                         r    B          
     a    m                                                                                                   m    a     
     h                                                                                                             h     
     n                                                                                                             n     
s    e                                                                                                             e    s
e                                                                                                                       e
r                                                                                                                       r
B                                                                                                                       B
r                                                                                                                       r
e                                                                                                                       e
s    e                                                                                                             e    s
     n                                                                                                             n     
     h                                                                                                             h     
     a    m                                                                                                   m    a     
          B    r                                                                                         r    B          
               e    s                                                                               s    e               
                    e    r                                                                     r    e                    
                         B    m                                                           m    B                         
                              a    h    n    e                             e    n    h    a                              
                                             s    e    r    B    r    e    s     

J'ai restreint le paramètre ratio pour Int pour qu'il reste simple, mais il peut facilement être élargi pour autoriser les flottants.

Python (172)

172 caractères, y compris les deux sauts de ligne obligatoires. Utilise l'algorithme de Bresenham pour les courbes coniques (sans divisions ni multiplications); il ne produit que des cercles pour les polices carrées, mais doit être exempté des effets d'escalier ( c'est-à-dire qu'il a toujours la même largeur).

y=input();t=[y*[' ']for x in range(y)];x=0;y-=1;p=3-2*y
while x<=y:t[x][y]=t[y][x]='*';n,y=((x-y+1,y-1),(x,y))[p<0];p+=4*n+6;x+=1
for s in t[::-1]+t:print"".join(s[::-1]+s)

Pas très joli, mais bon, j'ai pensé que je pourrais essayer.

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

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

Edit : faute de frappe, ajout remplacé par division .

Perl (92)

Je suis allé pour la "question bonus" et l'ai fait exploiter le rapport hauteur / largeur des caractères pour dessiner des ellipses :)

($w)=@ARGV;for$x(-$w..$w){$p.=abs($x*$x+$_*$_-$w*$w)<$w?'*':$"for(-$w..$w);$p.=$/;}print $p;

Exemples de sorties:

>perl circle.pl 3
  ***
 *   *
*     *
*     *
*     *
 *   *
  ***

>perl circle.pl 5
   *****
  *     *
 *       *
*         *
*         *
*         *
*         *
*         *
 *       *
  *     *
   *****

>perl circle.pl 8
      *****
    **     **
   *         *
  *           *
 *             *
 *             *
*               *
*               *
*               *
*               *
*               *
 *             *
 *             *
  *           *
   *         *
    **     **
      *****

Haskell ( 112 109)

g n=map(zipWith(?)f.repeat)f where x?y|abs(x^2+y^2-n^2)<n='*'|0<1=' ';f=[-n..n]
main=interact$unlines.g.read

Cela fonctionne en vérifiant si x² + y² - r² <n pour tous les points. Tous les points pour lesquels cela est vrai sont des étoiles, tous les autres sont des blancs.

Exemples:

$ echo 3 | runhaskell circ.hs
  ***  
 * * 
* *
* *
* *
 * * 
  ***  
$ echo 10 | runhaskell circ.hs
       *******       
     ** **     
    * *    
   * *   
  * *  
 * * 
 * * 
* *
* *
* *
* *
* *
* *
* *
 * * 
 * * 
  * *  
   * *   
    * *    
     ** **     
       *******       

Voir ici pour un grand exemple: http://www.ideone.com/t042u

Python, 180 caractères

Ce code fait des cercles si la police est carrée. Il est assez facile de modifier pour générer des ellipses nominales si vous connaissez le rapport hauteur / largeur de votre police.

import math
r=input()
d=2*r+1
c=[' '*d]*d
for a in xrange(9*d):f=math.pi*a/r/9; x=int(r+r*math.sin(f)+.5);y=int(r+r*math.cos(f)+.5);c[y]=c[y][:x]+'*'+c[y][x+1:]
for s in c:print s

Exemples:

4:
  *****  
 **   ** 
**     **
*       *
*       *
*       *
**     **
 **   ** 
  *****  

7:
     *****     
   **     **   
  **       **  
 **         ** 
**           **
*             *
*             *
*             *
*             *
*             *
**           **
 **         ** 
  **       **  
   **     **   
     *****     

C, 127 octets, nom de la police: Arial Super Bold

#include<math.h>
main(){int r=10,c=r*2+1,q=c*c,d;for(;q--;)d=hypot(r-q%c,r-q/c),printf("%c%s",d>r-4&&d<=r?42:32,q%c?"":"\n");}

Résultat:

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