Dibuja un polígono regular

21

El objetivo de este código de golf es dibujar un polígono regular (uno con lados de igual longitud) dado el número de lados y el radio (distancia del centro al vértice).

  • La cantidad de lados y el radio se pueden ingresar a través de un archivo, STDIN o simplemente una variable antigua. Use lo que sea más corto en su idioma.
  • -25% del total de caracteres / bytes si la imagen se dibuja realmente en lugar del arte ASCII.
El coco
fuente
3
¿Cuál es el radio de un polígono? El radio de su incircle? ¿Su circunferencia?
Peter Taylor
Allí. Lo arreglé. Perdón por eso: P.
Taconut
2
@PeterTaylor El radio de un polígono regular es la distancia a cualquier vértice (radio de circunferencia o circunradio ). El radio de la circunferencia inscrita (o la distancia a los lados) se llama la apotema . Esto no debería ser "poco claro lo que está preguntando", ya que tiene una definición fácil de encontrar (resultado # 1 para "radio de un polígono" en Google).
Geobits
@Geobits Estoy de acuerdo, pero igual lo edité de todos modos.
Taconut
@PeterTaylor Lo etiquetaré como ambos: I
Taconut

Respuestas:

20

LOGO 37 - 25% = 27.75 (con variables)

REPEAT:S[FD:R*2*sin(180/:S)RT 360/:S]

LOGOTIPO 49 - 25% = 36.75 (como una función)

TO P:R:S REPEAT:S[FD:R*2*sin(180/:S)RT 360/:S]END

Triángulo

Llamado con variables

Make "R 100
Make "S 3
REPEAT:S[FD:R*2*sin(180/:S)RT 360/:S]

Utilizado como una función P 100 3

ingrese la descripción de la imagen aquí

Cuadrado

Llamado con variables

Make "R 100
Make "S 4
REPEAT:S[FD:R*2*sin(180/:S)RT 360/:S]

Utilizado como una función P 100 4

ingrese la descripción de la imagen aquí

Pentágono

Llamado con variables

Make "R 100
Make "S 5
REPEAT:S[FD:R*2*sin(180/:S)RT 360/:S]

Utilizado como una función P 100 5

ingrese la descripción de la imagen aquí

Decágono

Llamado con variables

Make "R 100
Make "S 10
REPEAT:S[FD:R*2*sin(180/:S)RT 360/:S]

Utilizado como una función P 100 10

ingrese la descripción de la imagen aquí

Circulo

Llamado con variables

Make "R 100
Make "S 360
REPEAT:S[FD:R*2*sin(180/:S)RT 360/:S]

Utilizado como una función P 100 360

ingrese la descripción de la imagen aquí

Abhijit
fuente
2
¿Puedes publicar una captura de pantalla?
Gabe
En mi opinión, los polígonos tienen el mismo lado, no el radio.
Ross Millikan
@RossMillikan: Las imágenes no estaban a escala. Acabo de actualizar las imágenes
Abhijit
17

Mathematica, 40 - 25% = 30

ListPolarPlot[r&~Array~n]/.PointPolygon

ingrese la descripción de la imagen aquí

silbido
fuente
Excelente. Eso superó lo que probé Graphics.
DavidC
2
¡No es justo! ¡Demasiado fácil!
Robbie Wxyz
Bien hecho, esto nunca se me habría ocurrido.
Michael Stern
Se Graphics@RegularPolygonno permitido?
Greg Martin
@GregMartin Está permitido, pero es mucho más difícil especificar el radio con él.
Solo ASCII
12

Java 8: 533322 - 25% = 241.5

Bueno, es Java: / Solo dibuja líneas, punto a punto. Debería funcionar para cualquier polígono de tamaño arbitrario. Reducirlo un poco del tamaño original. Gran crédito a Vulcan (en comentarios) por la lección de golf.

import java.awt.*;class D{public static void main(String[]v){new Frame(){public void paint(Graphics g){int i=0,r=Short.valueOf(v[0]),s=Short.valueOf(v[1]),o=r+30,x[]=new int[s],y[]=x.clone();for(setSize(o*2,o*2);i<s;x[i]=(int)(Math.cos(6.28*i/s)*r+o),y[i]=(int)(Math.sin(6.28*i++/s)*r+o));g.drawPolygon(x,y,s);}}.show();}}

Saltos de línea:

import java.awt.*;
class D{
    public static void main(String[]v){
        new Frame(){
            public void paint(Graphics g){
                int i=0,r=Short.valueOf(v[0]),s=Short.valueOf(v[1]),o=r+30,x[]=new int[s],y[]=x.clone();
                for(setSize(o*2,o*2);i<s;x[i]=(int)(Math.cos(6.28*i/s)*r+o),y[i]=(int)(Math.sin(6.28*i++/s)*r+o));
                g.drawPolygon(x,y,s);
            }
        }.show();
    }
}

La entrada es argumentos [radio] [lados]:

java D 300 7

Salida:

un polígono!

Geobits
fuente
2
Elimine 12 bytes importando en java.awt.image.*lugar dejava.awt.image.BufferedImage
FThompson
1
Lo he reducido a 500 bytes usando algunos trucos. 1) Use en Short.valueOflugar de Integer.valueOfguardar cuatro bytes, ya que la entrada nunca debe exceder el rango de cortos. 2) y[]=x.clone()ahorra un byte y[]=new int[s]. 3) Use el obsoleto en f.show();lugar de f.setVisible(1>0);guardar nueve bytes adicionales. 4) Use en 6.28lugar de Math.PI*2, ya que la estimación es lo suficientemente precisa para este propósito, ahorrando tres bytes. 5) Declare en Graphics glugar de Graphics2D gcrear la instancia de gráficos para guardar dos bytes.
FThompson
1
@Vulcan lo tengo por otro 120 (principalmente por destrozar el BufferedImagey Graphicspor completo y sólo tirar todo en paint()). Cambió el color de la imagen, aunque todavía se ve bien en la OMI. Gracias por hacerme echar otro vistazo a esto :)
Geobits
1
@Geobits Grandes mejoras. Trabajando fuera de su versión reducida, lo he reducido aún más a 349 bytes eliminando Framecomo una variable local, eliminando el dentero y usando / abusando del ciclo for para guardar algunos caracteres, principalmente puntos y comas. Aquí hay una versión con espacios en blanco también.
FThompson
1
Reducido a 325 bytes usando en drawPolygonlugar de drawLine. Versión de espacios en blanco .
FThompson
11

TeX / TikZ (60 - 80.25)

Archivo polygon.tex:

\input tikz \tikz\draw(0:\r)\foreach\!in{1,...,\n}{--(\!*360/\n:\r)}--cycle;\bye

(80 bytes)

El radio y el número de lados se proporcionan como variables / macros \ry \n. Se puede dar cualquier unidad TeX para el radio. Sin unidad, cmse utiliza la unidad predeterminada . Ejemplos:

\def\r{1}\def\n{5}    % pentagon with radius 1cm
\def\r{10mm}\def\n{8} % octagon with radius 10mm

(16 bytes sin valores)

Si se debe suprimir el número de página, entonces puede hacerlo

\footline{}

(11 bytes)

Ejemplos para generar archivos PDF:

pdftex "\def\r{1}\def\n{3}\input polygon"

Triángulo

pdftex "\def\r{1}\def\n{5}\input polygon"

Polígono

pdftex "\def\r{1}\def\n{8}\input polygon"

Octágono

pdftex "\def\r{1}\def\n{12}\input polygon"

Dodecágono

Puntuación:

No está claro qué se necesita contar. El rango para la puntuación sería:

  • El código base es 80 bytes menos 25% = 60

  • O todo incluido (definiciones de variables de entrada, sin número de página): (80 + 16 + 11) menos 25% = 80.25

  • Si la conexión entre el primer y el último punto no necesita ser suave, entonces --cyclepodría eliminarse, ahorrando 7 bytes.

Heiko Oberdiek
fuente
8

Geogebra , 42-25 % = 31.5 bytes

Si cuenta en caracteres en lugar de bytes, esto sería 41 - 25% = 30.75 caracteres.

(Es decir, si considera Geogebra como un idioma ...)

Asume que el radio se almacena en la variable ry el número de lados almacenados en la variable s.

Polygon[(0,0),(sqrt(2-2cos(2π/s))r,0),s]

Utiliza el teorema del coseno c 2 = a 2 + b 2 - 2 ab cos C para calcular la longitud del lado a partir del radio dado.

Salida de muestra para s= 7, r= 5

ingrese la descripción de la imagen aquí

usuario12205
fuente
6

C: 229 180

#include<stdio.h>
#include<math.h>
main(){float n=5,r=10,s=tan(1.57*(1.-(n-2.)/n))*r*2.,i=0,j,x,c,t;int u,v;for(;i<n;i++)for(j=0;j<s;j++)x=i*6.28/n,c=cos(x),t=sin(x),x=j-s/2.,u=c*r+t*x+r*2.,v=-t*r+c*x+r*2,printf("\e[%d;%dH*",v,u);}

(r es el radio de incircle)

Por favor, ejecute en la terminal ANSI

Editar:

  • toma la sugerencia de as
  • usar variables antiguas (o #definir) como entrada
  • use el radio circunferencial ahora
u;main(v){float p=3.14,r=R*cos(p/n),s=tan(p/n)*r*2,i=0,j,x,c,t;for(;i++<n;)for(j=0;j<s;)x=i*p/n*2,c=cos(x),t=sin(x),x=j++-s/2,u=c*r+t*x+r*2,v=c*x-t*r+r*2,printf("\e[%d;%dH*",v,u);}

compilar:

gcc -opoly poly.c -Dn=sides -DR=radius -lm
cybcaoyibo
fuente
Cuando usa gcc, puede omitir el #includes. Además, puede declarar vcomo global fuera mainy declarar ucomo un parámetro de main, entonces no es necesario int(es decir v;main(u){//...). Finalmente, puede cambiar el último forciclo enfor(j=0;j<s;)/*...*/x=j++-s/2.,//...
user12205
5

C, 359 caracteres

Mi primer intento de jugar al golf. Al menos supera a la solución de Java ;-)

int r,n,l,g,i,j,x,y;char* b;float a,c,u,z,p,q,s,t;main(int j,char**v){r=atoi(v[1]);b=malloc(g=(l=r*2+1)*r*2+1);memset(b,32,g);for(j=g-2;j>0;j-=l){b[j]='\n';}b[g-1]=0;a=2*3.14/(n=atoi(v[2]));for(;i<=n;i++,p=s,q=t){c=i*a;s=sin(c)*r+r;t=cos(c)*r+r;if(i>0){u=(s-p)/r,z=(t-q)/r;for(j=0;j<r;j++){x=p+u*j;y=q+z*j;if(x>=0&&y>=0&&y<r*2&&x<l-1)b[y*l+x]='#';}}}puts(b);}

sin golf:

int r,n,l,g,i,j,x,y;
char* b;
float a,c,u,z,p,q,s,t;
main(int j,char**v){
    r=atoi(v[1]);
    b=malloc(g=(l=r*2+1)*r*2+1);
    memset(b,32,g);
    for(j=g-2;j>0;j-=l){b[j]='\n';} 
    b[g-1]=0;
    a=2*3.14/(n=atoi(v[2]));
    for(;i<=n;i++,p=s,q=t){
        c=i*a;s=sin(c)*r+r;t=cos(c)*r+r;
        if(i>0){
            u=(s-p)/r,z=(t-q)/r;
            for(j=0;j<r;j++){
                x=p+u*j;y=q+z*j;
                if(x>=0&&y>=0&&y<r*2&&x<l-1)b[y*l+x]='#';
            }
        }
    }
    puts(b);
}

Y es el único programa que genera el polígono en ASCII en lugar de dibujarlo. Debido a esto y algunos problemas de redondeo de punto flotante, el resultado no se ve particularmente bonito (los caracteres ASCII no son tan altos como anchos).

                 ######
               ###    ###
            ####        ####
          ###              ###
        ###                  ####
     ###                        ###
     #                            #
     #                            ##
    #                              #
    #                              #
   ##                              ##
   #                                #
  ##                                ##
  #                                  #
  #                                  #
 ##                                  ##
 #                                    #
##                                    ##
#                                      #
#                                      #
#                                      #
#                                      #
##                                    ##
 #                                    #
 ##                                  ##
  #                                  #
  #                                  #
  ##                                ##
   #                                #
   ##                              ##
    #                              #
    #                              #
     #                            ##
     #                            #
     ###                        ###
        ###                  ####
          ###              ###
            ###         ####
               ###    ###
                 ######
MarcDefiant
fuente
El primero intse puede eliminar ya que se supone que intel compilador lo hace. Además, el último forbucle se puede cambiar afor(j=0;j<r;){x=p+u*j;y=q+z*j++;//...
user12205
El if(i<0)podría ser cambiado a if(i). Lo que todavía se necesita solo en una iteración, pero no pudo encontrar una manera eficiente de eliminarlo :(
Allbeert
4

Mathematica, 54 * 75% = 40.5

Graphics@Polygon@Table[r{Cos@t,Sin@t},{t,0,2Pi,2Pi/n}]

Ni siquiera creo que haya un punto para una versión sin golf. Solo contendría más espacios en blanco.

Espera el radio en variable ry el número de lados en variable n. El radio no tiene sentido sin mostrar ejes, porque Mathematica escala todas las imágenes para que quepan.

Ejemplo de uso:

ingrese la descripción de la imagen aquí

Martin Ender
fuente
Graphics@Polygon@Array[r{Sin@#,Cos@#}&,n+1,{0,2π}]
chyanog
@ Chyaong ah, tiendo a olvidar Array .
Martin Ender
4

HTML / JavaScript: 215 - 25% = 161.25 , 212 - 25% = 159

<canvas><script>R=100;i=S=10;c=document.currentScript.parentNode;c.width=c.height=R*2;M=Math;with(c.getContext("2d")){moveTo(R*2,R);for(;i-->0;){a=M.PI*2*(i/S);lineTo(R+M.cos(a)*R,R+M.sin(a)*R)}stroke()}</script>

Versión sin golf:

<canvas><script>
    var RADIUS = 100;
    var SIDES_COUNT = 10;
    var canvas = document.currentScript.parentNode;
    canvas.width = canvas.height = RADIUS * 2;
    var context = canvas.getContext("2d");
    context.moveTo(RADIUS * 2, RADIUS);
    for(i = 1 ; i <= SIDES_COUNT ; i++) {
        var angle = Math.PI * 2 * (i / SIDES_COUNT);
        context.lineTo(
            RADIUS + Math.cos(angle) * RADIUS,
            RADIUS + Math.sin(angle) * RADIUS
        );
    }
    context.stroke();
</script>
sebcap26
fuente
Ahorre 4 caracteres por i=S=5;y for(;i-->0;).
Matt
@ Matt Gracias! No conocía esta sintaxis y no puedo encontrar ninguna información al respecto. Como se llama ?
sebcap26
@ sebcap26 ¿Te refieres a la i-->0parte? Es lo mismo que i-- > 0. Algunas personas también lo llaman el operador de flecha o el operador de ir a ;)
ComFreek
No se preocupe :) Como dijo @ sebcap26, solo está disminuyendo cada vez que el ciclo for evalúa la condición.
Matt
Creo que puede guardar caracteres eliminando c=document.currentScript.parentNode;y reemplazando <canvas>por<canvas id="c">
Hedi
3

Posdata 156 - 25% = 117

translate exch 1 exch dup dup scale div currentlinewidth mul setlinewidth
1 0 moveto dup{360 1 index div rotate 1 0 lineto}repeat closepath stroke showpage

Pase el radio, el número de lados y el punto central en la línea de comando

gs -c "100 9 300 200" -- polyg.ps

o anteponer a la fuente

echo 100 9 300 200 | cat - polyg.ps | gs -

Traslade al centro, escale hasta el radio, muévase a (1,0); luego repita n veces: gire 360 ​​/ n, dibuje una línea a (1,0); dibuja la línea final, traza y emite la página.

luser droog
fuente
3

Salvia , 44 - 25% = 33

Asume que el número de lados está almacenado en la svariable y el radio está almacenado en la rvariable.

polytopes.regular_polygon(s).show(figsize=r)

Salida de muestra:

s= 5, r= 3

ingrese la descripción de la imagen aquí

s= 5, r= 6

ingrese la descripción de la imagen aquí

s= 12, r= 5

ingrese la descripción de la imagen aquí

usuario12205
fuente
La escala de los ejes es engañosa. ¿Eso es reparable? (por ejemplo, primer punto en (0,3) cuando el radio = 3, en lugar de (0,1))
Trauma digital el
1
@DigitalTrauma Mi programa básicamente genera el polígono regular "estándar", luego amplía la imagen por un factor de escala. Hasta donde sé, la regular_polygonfunción siempre genera polígonos con el primer vértice en (0,1). Una solución sería no mostrar los ejes con 7 bytes adicionales ( ,axes=0después figsize=r)
user12205
3

bc + ImageMagick + xview + bash, 104.25 (139 bytes - 25%)

Este desafío estaría incompleto sin una respuesta de ImageMagick ...

convert -size $[$2*2]x$[$2*2] xc: -draw "polygon `bc -l<<Q
for(;i++<$1;){t=6.28*i/$1;print s(t)*$2+$2,",";c(t)*$2+$2}
Q`" png:-|xview stdin

Por ejemplo, ./polygon.sh 8 100produce esta imagen:

ingrese la descripción de la imagen aquí

Trauma digital
fuente
2

JavaScript 584 (867 sin golf)

Este código usa N Raíces complejas de unidad y traduce los ángulos a puntos X, Y. Luego, el origen se mueve al centro del lienzo.

Golfed

function createPolygon(c,r,n){
c.width=3*r;
c.height=3*r;
var t=c.getContext("2d");
var m=c.width/2;
t.beginPath(); 
t.lineWidth="5";
t.strokeStyle="green";
var q=C(r, n);
var p=pts[0];
var a=p.X+m;
var b=p.Y+m;
t.moveTo(a,b);
for(var i=1;i<q.length;i++)
{
p=q[i];
t.lineTo(p.X+m,p.Y+m);
t.stroke();
}
t.lineTo(a,b);
t.stroke();
}
function P(x,y){
this.X=x;
this.Y=y;
}
function C(r,n){
var p=Math.PI;
var x,y,i;
var z=[];
var k=n;
var a;
for(i=0;i<k;i++)
{
a = 2*i*p/n;
x = r*Math.cos(a);
y = r*Math.sin(a);
z.push(new P(x,y));
}
return z;
}

Salida de muestra:

Salida en cromo

Sin golf

function createPolygon(c,r,n) {
c.width = 3*r;
c.height = 3*r;
var ctx=c.getContext("2d");
var mid = c.width/2;
ctx.beginPath(); 
ctx.lineWidth="5";
ctx.strokeStyle="green";
var pts = ComplexRootsN(r, n);
if(null===pts || pts.length===0)
{
alert("no roots!");
return;
}
var p=pts[0];
var x0 = p.X + mid;
var y0 = p.Y + mid;
ctx.moveTo(x0,y0);
for(var i=1;i<pts.length;i++)
{
p=pts[i];
console.log(p.X +"," + p.Y);
ctx.lineTo(p.X + mid, p.Y + mid);
ctx.stroke();
}
ctx.lineTo(x0,y0);
ctx.stroke();
}

function Point(x,y){
this.X=x;
this.Y=y;
}

function ComplexRootsN(r, n){
var pi = Math.PI;
var x,y,i;
var arr = [];
var k=n;
var theta;
for(i=0;i<k;i++)
{
theta = 2*i*pi/n;
console.log('theta: ' + theta);
x = r*Math.cos(theta);
y = r*Math.sin(theta);
console.log(x+","+y);
arr.push(new Point(x,y));
}
return arr;
}

Este código requiere un elemento de lienzo HTML5, c es un objeto de lienzo, r es el radio yn es el número de lados.

bacchusbeale
fuente
2

PHP 140 - 25% = 105

<?
for(;$i++<$p;$a[]=$r-cos($x)*$r)$a[]=$r-sin($x+=2*M_PI/$p)*$r;
imagepolygon($m=imagecreatetruecolor($r*=2,$r),$a,$p,0xFFFFFF);
imagepng($m);

Asume dos variables predefinidas: $pel número de puntos y $rel radio en píxeles. Alternativamente, uno podría anteponer list(,$r,$p)=$argv;y usar argumentos de línea de comando en su lugar. La salida será un png, que debe canalizarse a un archivo.


Salida

$r=100; $p=5;

$r=100; $p=6;

$r=100; $p=7;

$r=100; $p=50;

primo
fuente
1

TI-80 BASIC, 25 bytes - 25% = 18.75

PARAM
2π/ANS->TSTEP
"COS T->X1ᴛ
"SIN T->Y1ᴛ
DISPGRAPH

Asume que todas las configuraciones están establecidas en los valores predeterminados. Ejecute el programa como 5:PRGM_POLYGON(para un pentágono)

Funciona dibujando un círculo con un número muy bajo de pasos. Por ejemplo, un pentágono tendría pasos de 2π / 5 radianes.

Los ajustes de la ventana son lo suficientemente bueno por defecto, y TMINy TMAXse establecen en 0y , así que todo lo que tenga que cambiar es TSTEP.

12Me21
fuente
1

SmileBASIC 3, 183 159 - 25% = 119.25 bytes

Toma los lados y el radio de INPUT, calcula y almacena los puntos, y luego los dibuja usando GLINE. Siento que esto podría ser más corto, pero es como la 1 AM, lo que sea. Asume un entorno de visualización limpio y predeterminado, por lo que es posible que lo necesite ACLSal ejecutarlo desde DIRECTO.

INPUT S,R
DIM P[S,2]FOR I=0TO S-1
A=RAD(I/S*360)P[I,0]=COS(A)*R+200P[I,1]=SIN(A)*R+120NEXT
FOR I=0TO S-1GLINE P[I,0],P[I,1],P[(I+1)MOD S,0],P[(I+1)MOD S,1]NEXT

captura de pantalla

caracol_
fuente
1
Un byte es un byte, no se puede decir que es solo la mitad.
12Me21
Restando la regla del 25%.
Matthew Roh
1

OpenSCAD: 31 menos 25% = 23.25

module p(n,r){circle(r,$fn=n);}

¡Primera publicación aquí! Sé que llego tarde a la fiesta, pero esta parecía una pregunta tan buena como cualquier otra para empezar. Llamar usando p(n,r).

Julian Wolf
fuente
Bienvenido al sitio!
Wheat Wizard
0

ActionScript 1, Flash Player 6: 92 - 25% = 69

n=6
r=100
M=Math
P=M.PI*2
lineStyle(1)
moveTo(r,0)
while((t+=P/n)<=P)lineTo(M.cos(t)*r,M.sin(t)*r)
canadiense
fuente
0

C # en LINQPAD

El crédito para la parte de matemáticas va a Geobits (¡espero que no te importe!) Con la respuesta de Java. No tengo esperanza en las matemáticas :)

Hice esto en LINQPAD ya que tiene una ventana de salida incorporada. Así que esencialmente puedes arrastrar y soltar lo siguiente y dibujará el polígono. Simplemente cámbielo a 'Programa C #' e importe System.Drawing lib en las propiedades de consulta.

//using System.Drawing;

void Main()
{
// Usage: (sides, radius)
    DrawSomething(4, 50);
}

void DrawSomething(int sides, int radius)
{
    var points = new Point[sides];
    var bmpSize = radius*sides;
    var bmp = new Bitmap(bmpSize,bmpSize);
    using (Graphics g = Graphics.FromImage(bmp))
    {   
        var o = radius+30;
        for(var i=0; i < points.Length; i++)
        {
            // math thanks to Geobits
            double w = Math.PI*2*i/sides;
            points[i].X = (int)(Math.Cos(w)*radius+o);
            points[i].Y = (int)(Math.Sin(w)*radius+o);
        }
        g.DrawPolygon(new Pen(Color.Red), points);
    }
    Console.Write(bmp);
}

ingrese la descripción de la imagen aquí

jzm
fuente
0

Matlab 58 bytes - 25% = 43.5

No vi ninguna solución de Matlab, así que aquí hay una que es bastante sencilla:

f=@(n,r) plot(r*cos(0:2*pi/n:2*pi),r*sin(0:2*pi/n:2*pi));

Puede eliminar algunos bytes si r y n ya están en el espacio de trabajo.

Llamada de ejemplo:

f(7,8)

7-gon con radio 8

ptev
fuente
0

Python 2, 222 bytes

from math import*
def f(s,r):
 r*=cos(pi/s)
 v,R=2*pi/s,[(2*t)/98.-1for t in range(99)]
 print"P1 99 99 "+" ".join(["0","1"][all(w*(w-x)+z*(z-y)>0for w,z in[(r*cos(a*v),r*sin(a*v))for a in range(s)])]for x in R for y in R)

Comprueba si un píxel está en el lado interno de todos los hiperplanos (líneas) del polígono. Se toca el radio porque en realidad se usa la apotema.

ingrese la descripción de la imagen aquí ingrese la descripción de la imagen aquí

Karl Napf
fuente
0

Mathematica 27 (= 36 - 25%)

Graphics[Polygon[CirclePoints[r, n]]]

Cuando enviamos el código de Mathematica, a menudo nos olvidamos de las nuevas funciones que se siguen incorporando al lenguaje, con el vocabulario actual del lenguaje acumulando alrededor de 5000 funciones principales . El vocabulario de idiomas amplio y en expansión es, por cierto, bastante útil para el golf de códigos. CirclePoints se introdujeron en la versión actual 11.X. Un ejemplo específico del radio 5 de 7 lados es:

ingrese la descripción de la imagen aquí

También solo necesita ingresar el parámetro de ángulo para controlar la orientación de su polígono:

Graphics[Polygon[CirclePoints[{1, 2}, 5]]]

ingrese la descripción de la imagen aquí

Vitaliy Kaurov
fuente
0

Python 2, 74 bytes - 25% = 55.5

La entrada está en las variables r,n. Si se incluye en el recuento, lo sería r,n=input(), por 12 bytes más.

import math,turtle as t
exec"t.fd(2*r*math.sin(180/n));t.rt(360/n);"*n

Pruébelo en línea : (utiliza un código diferente ya execque no está implementado en el intérprete en línea)

mbomb007
fuente
0

SmileBASIC, 85 75 - 25% = 56.25 bytes

FOR I=0TO S
A=I/S*6.28N=X
M=Y
X=R+R*COS(A)Y=R+R*SIN(A)GLINE N,M,X,Y,-I
NEXT

Las variables S y R se utilizan para la entrada.

Explicado:

FOR I=0 TO Sides        'Draw n+1 sides (since 0 is skip)
 Angle=I/Sides*6.28     'Get angle in radians
 OldX=X:OldY=Y          'Store previous x/y values
 X=Radius+Radius*COS(A) 'Calculate x and y
 Y=Radius+Radius*SIN(A)
 GLINE OldX,OldY,X,Y,-I 'Draw line. Skip if I is 0 (since old x and y aren't set then)
NEXT

Los lados se dibujan usando el color -I, que generalmente está cerca de -1 (& HFFFFFFFF blanco) (excepto cuando Ies 0, cuando es transparente).

También puede dibujar un polígono relleno utilizando en GTRI N,M,X,Y,R,R,-Ilugar deGLINE...

12Me21
fuente
0

Tikz, 199 bytes

\documentclass[tikz]{standalone}\usetikzlibrary{shapes.geometric}\begin{document}\tikz{\def\p{regular polygo}\typein[\n]{}\typein[\r]{}\node[draw,minimum size=\r,\p n,\p n sides=\n]{}}\end{document}

Esta solución usa la biblioteca tikz shapes.geometric.

Así es como se ve un polígono con 5lados y radio 8incuando se ve en evidencia .

Cuadro obligatorio

Asistente de trigo
fuente