Znajdź sposób tworzenia kręgów o danym promieniu za pomocą znaków w konsoli. Podaj nazwę i rozmiar czcionki. Podaj także co najmniej jeden przykład wyniku.

Na przykład:

Wejście:

3

Wynik:

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

... Cóż, coś lepszego niż ten „ręcznie rysowany” „okrąg” o promieniu 3.

Pytanie bonusowe: Elipsy. :)

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/ ( fjest współczynnikiem korygującym stosunek wysokości linii do szerokości czcionki. Jeśli używasz ustawienia czcionki kwadratowej, tj. ustaw wysokość linii = rozmiar czcionki, możesz ustawić f = 1 i uzyskaj okręgi „kwadratowe” lub ustaw fdowolnie dla elips.)

Wyjście dla 3 (co ciekawe, przypadkowo dokładnie tego samego kształtu co OP), 5, 15:

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

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

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

koło Bresenham w Scali (35)

Algorytm Bresenhama ma 2 główne punkty:

• działa bez sin / cosin.
• obliczasz tylko okrąg ¼ * ½, pozostałe punkty można znaleźć przez odbicie lustrzane.

Jak to zrobić:

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

• Liczymy tylko liczby od A w zenicie do I.
  • Punkt I wynosi 45 °, zdefiniowany przez x == y.
  • Punkt zerowy jest tam, gdzie jest +.
  • A w zenicie to punkt (x = 0, y = r), r = promień.
  • Aby narysować zamknięty okrąg, poruszamy się zgodnie z ruchem wskazówek zegara (++ x), czyli w prawo (x + = 1) lub w dół do następnego punktu, (y- = 1).
  • każdy punkt (x, y) na okręgu jest r od środka. Pitagoras mówi: r² = x² + y².
  • To pachnie jak pierwiastek kwadratowy i równania z 2 rozwiązaniami, ale uwaga!
  • zaczynamy od litery A i chcemy wiedzieć, czy malujemy następny punkt poniżej, czy punkt poniżej po prawej.
• obliczamy dla obu punktów (x² + y²) i budujemy dla obu różnic do r² (co pozostaje oczywiście stałe).
  • ponieważ różnica może być ujemna, bierzemy z niej abs.
  • następnie sprawdzamy, który punkt jest bliższy wynikowi (r²), eo ipso mniejszy.
  • w zależności od tego rysujemy prawego lub dolnego sąsiada.
• tak znaleziony punkt
  • 1 x, zostanie dublowany
  • 2 -x, y w lewo
  • 3 lata, x na przekątnej
  • 4 -y, x stamtąd po lewej stronie
• wszystkie te punkty zostają ponownie odzwierciedlone na południu
  • 1 'x, -y
  • 2 '-x, -y
  • 3 'y, -x
  • 4 '-y, -x gotowe.

To nie jest kod golfowy, ale wszystkie te liczby na szczycie istniejących rozwiązań sprawiły, że tak pomyślałem, więc spędziłem bezużyteczny czas na grze w golfa. Dlatego też dodałem bezużyteczną liczbę na górze. Zaokrągla się 11 razy Pi.

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

Pytanie o czcionkę określa serwer witryn i ustawienia przeglądarki. Teraz to szukam

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

Rozmiar czcionki to 12 pikseli. Dość bezużyteczne informacje, jeśli mnie pytasz, ale kto to robi?

Bonus: elipsy i wyjście próbki:

Wywołanie to

    scala BresenhamCircle SIZE RATIO

na przykład

    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     

Ogranicziłem parametr ratio dla Int, aby było to proste, ale można go łatwo rozszerzyć, aby umożliwić float.

Python (172)

172 znaki, w tym dwie obowiązkowe nowe znaki. Używa algorytmu Bresenhama dla krzywych stożkowych (bez podziałów i mnożenia); wypisuje tylko koła dla kwadratowych czcionek, ale powinien być zwolniony z efektów schodów ( tzn. zawsze ma tę samą szerokość).

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)

Niezbyt ładna, ale cóż, myślałem, że spróbuję.

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

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

Edit : literówka, otrzymuje dodatek z podziałem .

Perl (92)

Wybrałem „pytanie dodatkowe” i wykorzystałem proporcje postaci do rysowania elips :)

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

Przykładowe wyniki:

>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

Działa to poprzez sprawdzenie, czy x² + y² - r² <n dla wszystkich punktów. Wszystkie punkty, dla których jest to prawdą, są gwiazdami, wszystkie pozostałe są pustymi.

Przykłady:

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

Zobacz tutaj duży przykład: http://www.ideone.com/t042u

Python, 180 znaków

Ten kod tworzy koła, jeśli czcionka jest kwadratowa. Łatwo jest zmodyfikować, aby wygenerować nominalne elipsy, jeśli znasz swój stosunek wysokości do szerokości czcionki.

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

Przykłady:

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

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

C, 127 bajtów, nazwa czcionki: 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");}

Wynik:

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