Finden Sie eine Möglichkeit, mit Zeichen in einer Konsole Kreise mit einem bestimmten Radius zu erstellen. Bitte geben Sie den Schriftnamen und die Schriftgröße an. Geben Sie außerdem mindestens ein Beispiel für die Ausgabe an.

Zum Beispiel:

Eingang:

3

Ausgabe:

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

... Nun, etwas sieht besser aus als dieser "handgezeichnete" "Kreis" mit einem Radius von 3.

Bonusfrage: Ellipsen. :) :)

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/ ( fist ein Korrekturfaktor für das Verhältnis von Zeilenhöhe zu Schriftbreite. Wenn Sie eine quadratische Schriftarteneinstellung verwenden, dh Zeilenhöhe = Schriftgröße festlegen, können Sie diese festlegen f = 1 und erhalte "quadratische" Kreise. Oder setze fwillkürlich für Ellipsen.)

Ausgabe für 3 (interessanterweise versehentlich genau die gleiche Form wie OP), 5, 15:

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

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

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

ein Bresenham-Kreis in der Scala (35)

Der Bresenham - Algorithmus hat 2 Hauptpunkte:

• arbeitet ohne Sünde / Cosinus.
• Sie berechnen nur ¼ * ½ Kreis, die anderen Punkte werden durch Spiegeln gefunden.

Wie es geht:

       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 'x B 3'
CC
DE ED
 FF
 GJ JG
  IJ JI
   GFE EFG
     DCBABCD
       2'1 ' 

• Wir berechnen nur die Zahlen von A im Zenit bis I.
  • Punkt I liegt bei 45 °, definiert durch x == y.
  • Ground Zero ist dort, wo das + ist.
  • Das A im Zenit ist der Punkt (x = 0, y = r), r = Radius.
  • Um einen geschlossenen Kreis zu zeichnen, bewegen wir uns im Uhrzeigersinn (++ x) nach rechts (x + = 1) oder nach unten zum nächsten Punkt (y- = 1).
  • Jeder Punkt (x, y) auf dem Kreis ist r vom Zentrum entfernt. Pythagoras sagt, r² = x² + y².
  • Dies riecht nach Quadratwurzel und Equitations mit 2 Lösungen, aber Vorsicht!
  • Wir beginnen bei A und wollen wissen, ob wir als nächstes den Punkt darunter oder den Punkt darunter rechts malen.
• Wir berechnen für beide Punkte (x² + y²) und bauen für beide die Differenz zu r² (die natürlich konstant bleibt).
  • Da der Unterschied negativ sein kann, nehmen wir die Bauchmuskeln daraus.
  • dann schauen wir, welcher Punkt näher am Ergebnis liegt (r²), eo ipso kleiner.
  • je nachdem zeichnen wir den rechten oder unteren nachbarn.
• der so gefundene Punkt
  • 1 x, y wird gespiegelt
  • 2 -x, y nach links
  • 3 y, x in der Diagonale
  • 4 -y, x von dort nach links
• Alle diese Punkte werden im Süden wieder gespiegelt
  • 1 'x, -y
  • 2 '-x, -y
  • 3 'y, -x
  • 4 '-y, -x fertig.

Dies ist kein Code-Golf, aber all diese Zahlen an der Spitze der vorhandenen Lösungen ließen mich denken, dass dies der Fall ist, und so verbrachte ich nutzlose Zeit damit, meine Lösung zu spielen. Deshalb habe ich auch oben eine nutzlose Nummer hinzugefügt. Es ist 11 mal Pi gerundet.

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

Die Schriftartfrage wird vom Webserver der Website und Ihren Browsereinstellungen festgelegt. Nun, da ich es sehe, ist es

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

Die Schriftgröße beträgt 12px. Ziemlich nutzlose Informationen, wenn Sie mich fragen, aber wer tut das?

Bonus: Ellipsen und Probenausgabe:

Der Aufruf ist

    scala BresenhamCircle SIZE RATIO

zum Beispiel

    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     

Ich habe den Ratio-Parameter für Int eingeschränkt, um ihn einfach zu halten, aber er kann leicht erweitert werden, um Floats zu ermöglichen.

Python (172)

172 Zeichen einschließlich der beiden obligatorischen Zeilenumbrüche. Verwendet den Bresenham-Algorithmus für konische Kurven (keine Divisionen oder Multiplikationen); Es werden nur Kreise für quadratische Schriftarten ausgegeben, sie sollten jedoch von Treppeneffekten ausgenommen sein ( dh sie haben immer die gleiche Breite).

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)

Nicht sehr hübsch, aber gut, ich dachte, ich würde es versuchen.

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

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

Bearbeiten : Tippfehler, Ergänzung durch Division ersetzt .

Perl (92)

Ich habe mich für die „Bonusfrage“ entschieden und das Seitenverhältnis der Charaktere ausgenutzt, um Ellipsen zu zeichnen :)

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

Beispielausgaben:

>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

Dies funktioniert, indem überprüft wird, ob x² + y² - r² <n für alle Punkte ist. Alle Punkte, für die dies zutrifft, sind Sterne, alle anderen sind Leerzeichen.

Beispiele:

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

Ein großes Beispiel finden Sie hier: http://www.ideone.com/t042u

Python, 180 Zeichen

Dieser Code macht Kreise, wenn die Schrift quadratisch ist. Es ist ziemlich einfach zu ändern, um nominelle Ellipsen zu erzeugen, wenn Sie das Verhältnis von Schrifthöhe zu -breite kennen.

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

Beispiele:

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

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

C, 127 Bytes, Schriftname: 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");}

Ergebnis:

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