language agnostic - Código Golf-π día

language-agnostic code-golf

Question

El reto

Pautas para code-golf en SO

El código más corto por carácter cuenta para mostrar una representación de un círculo de radio R usando el carácter * , seguido de una aproximación de π.

La entrada es un número único, R

Como la mayoría de las computadoras parecen tener una relación de casi 2: 1, solo se deben generar líneas donde y es impar. Esto significa que cuando R es impar, debe imprimir líneas R-1 . Hay un nuevo caso de prueba para R=13 para aclarar.

p.ej.

Input
5
Output Correct Incorrect
3 ******* 4 *******
1 ********* 2 *********
-1 ********* 0 ***********
-3 ******* -2 *********
2.56 -4 *******
3.44

Editar: Debido a la confusión generalizada causada por los valores impares de R , se aceptarán todas las soluciones que superen los 4 casos de prueba que figuran a continuación.

La aproximación de π se da dividiendo el doble de la cantidad de * caracteres por R² .
La aproximación debería ser correcta hasta al menos 6 dígitos significativos.
Se permiten ceros 3.000000 o finales, por lo que cualquiera de 3 , 3.000000 , 003 es aceptado para las entradas de 2 y 4 .

El recuento de códigos incluye entrada / salida (es decir, programa completo).

Casos de prueba

Input
2
Output
***
***
3.0
Input
4
Output
*****
*******
*******
*****
3.0
Input
8
Output
*******
*************
***************
***************
***************
***************
*************
*******
3.125
Input
10
Output
*********
***************
*****************
*******************
*******************
*******************
*******************
*****************
***************
*********
3.16

Caso de prueba adicional

Input
13
Output
*************
*******************
*********************
***********************
*************************
*************************
*************************
*************************
***********************
*********************
*******************
*************
2.98224852071

Answer 1

APL: 59

Esta función acepta un número y devuelve los dos elementos esperados. Funciona correctamente en casos de bonificación.

{⍪(⊂'' *''[1+m]),q÷⍨2×+/,m←(2|v)⌿(q←⍵*2)>v∘.+v←2*⍨⍵-⍳1+2×⍵-1}

Dialect es Dyalog APL, con origen de índice predeterminado. El nivel de habilidad es un novato despistado , así que si cualquier gurú de APL quiere reducirlo a 10 caracteres, ¡sé mi invitado!

Puedes probarlo en línea en Try APL , simplemente pégalo y pon un número después de él:

 {⍪(⊂'' *''[1+m]),q÷⍨2×+/,m←(2|v)⌿(q←⍵*2)>v∘.+v←2*⍨⍵-⍳1+2×⍵-1} 13
*************
*******************
*********************
***********************
*************************
*************************
*************************
*************************
***********************
*********************
*******************
*************
2.98225

Answer 2

J: 47 , 46 , 45

La misma idea básica que otras soluciones, es decir, r ^ 2 <= x ^ 2 + y ^ 2 , pero la notación orientada a la matriz de J simplifica la expresión:

c=:({&'' *'',&":2*+/@,%#*#)@:>_2{./|@j./~@i:@<:

Lo llamarías como c 2 o c 8 o c 10 etc.

Bono: 49

Para manejar entradas impares, por ej. 13 , tenemos que filtrar las coordenadas x de valores impares, en lugar de simplemente tomar cada otra fila de salida (porque ahora los índices podrían comenzar en un número par o impar). Esta generalización nos cuesta 4 caracteres:

c=:*:({&'' *''@],&":2%(%+/@,))]>(|@j./~2&|#])@i:@<:

Versión desminnimizada:

c =: verb define
pythag =. y > | j./~ i:y-1 NB. r^2 > x^2 + y^2
squished =. _2 {./ pythag NB. Odd rows only
piApx =. (2 * +/ , squished) % y*y
(squished { '' *'') , ": piApx
)

Mejoras y generalizaciones debido a Marshall Lochbam en los J Foros .

Answer 3

Java: 234

class C{public static void main(String[] a){int x,y,s=0,r=Integer.parseInt(a[0]);for(y=1-r;y<r;y+=2){for(x=1-r;x<r;++x){boolean b=x*x+y*y<=r*r;s+=b?1:0;System.out.print(b?''*'':'' '');}System.out.println();}System.out.println(s*2d/r/r);}}

Sin minificar

class C{
public static void main(String[] a){
int x,y,s=0,r=Integer.parseInt(a[0]);
for(y=1-r;y<r;y+=2){
for(x=1-r;x<r;++x) {
boolean b=x*x+y*y<=r*r;
s+=b?1:0;
System.out.print(b?''*'':'' '');
}
System.out.println();
}
System.out.println(s*2d/r/r);
}
}

Answer 4

C: 131 caracteres

(Basado en la solución C ++ de Joey)

main(i,j,c,n){for(scanf("%d",&n),c=0,i|=-n;i<n;puts(""),i+=2)for(j=-n;++j<n;putchar(i*i+j*j<n*n?c++,42:32));printf("%g",2.*c/n/n);}

(Cambie el i|=-n a i-=n para eliminar el soporte de casos de números impares. Esto simplemente reduce el número de caracteres a 130).

Como un círculo:

 main(i,j,
c,n){for(scanf(
"%d",&n),c=0,i=1|
-n;i<n;puts(""),i+=
0x2)for(j=-n;++j<n;
putchar(i*i+j*j<n*n
?c++,0x02a:0x020));
printf("%g",2.*c/
n/n);3.1415926;
5358979;}

Answer 5

En dc: 88 y 93 93 94 96 102 105 129 138 141 caracteres

Por las dudas, estoy usando OpenBSD y algunas extensiones supuestamente no portátiles en este momento.

93 caracteres. Esto se basa en la misma fórmula que la solución FORTRAN (resultados ligeramente diferentes a los casos de prueba). Calcula X ^ 2 = R ^ 2-Y ^ 2 por cada Y

[rdPr1-d0<p]sp1?dsMdd*sRd2%--
[dd*lRr-vddlMr-32rlpxRR42r2*lpxRRAP4*2+lN+sN2+dlM>y]
dsyx5klNlR/p

88 caracteres. Solución iterativa Coincide con los casos de prueba. Para cada X e Y comprueba si X ^ 2 + Y ^ 2 <= R ^ 2

1?dsMdd*sRd2%--sY[0lM-[dd*lYd*+lRr(2*d5*32+PlN+sN1+dlM!<x]dsxxAPlY2+dsYlM>y]
dsyx5klNlR/p

Para ejecutar dc pi.dc

Aquí hay una versión anotada más antigua:

# Routines to print ''*'' or '' ''. If ''*'', increase the counter by 2
[lN2+sN42P]s1
[32P]s2
# do 1 row
# keeping I in the stack
[
# X in the stack
# Calculate X^2+Y^2 (leave a copy of X)
dd*lYd*+
#Calculate X^2+Y^2-R^2...
lR-d
# .. if <0, execute routine 1 (print ''*'')
0>1
# .. else execute routine 2 (print '' '')
0!>2
# increment X..
1+
# and check if done with line (if not done, recurse)
d lM!<x
]sx
# Routine to cycle for the columns
# Y is on the stack
[
# push -X
0lM-
# Do row
lxx
# Print EOL
10P
# Increment Y and save it, leaving 2 copies
lY 2+ dsY
# Check for stop condition
lM >y
]sy
# main loop
# Push Input value
[Input:]n?
# Initialize registers
# M=rows
d sM
# Y=1-(M-(M%2))
dd2%-1r-sY
# R=M^2
d*sR
# N=0
0sN
[Output:]p
# Main routine
lyx
# Print value of PI, N/R
5klNlR/p

Answer 6

FORTRAN - 101 caracteres

$ f95 piday.f95 -o piday && echo 8 | ./piday

READ*,N
DO I=-N,N,2
M=(N*N-I*I)**.5
PRINT*,('' '',J=1,N-M),(''*'',J=0,M*2)
T=T+2*J
ENDDO
PRINT*,T/N/N
END

 READ*,N
K=N/2*2;DO&
I=1-K,N,2;M=&
(N*N-I*I)**.5;;
PRINT*,('' '',J=&
1,N-M),(''*'',J=&
0,M*2);T=T+2*J;
ENDDO;PRINT*&
,T/N/N;END;
!PI-DAY

Answer 7

Haskell 139 145 147 150 230 caracteres:

x True='' '';x _=''*''
a n=unlines[[x$i^2+j^2>n^2|j<-[-n..n]]|i<-[1-n,3-n..n]]
b n=a n++show(sum[2|i<-a n,i==''*'']/n/n)
main=readLn>>=putStrLn.b

Manejando los números impares: 148 caracteres:

main=do{n<-readLn;let{z k|k<n^2=''*'';z _='' '';c=[[z$i^2+j^2|j<-[-n..n]]|i<-[1,3..n]];d=unlines$reverse c++c};putStrLn$d++show(sum[2|i<-d,i==''*'']/n/n)}

150 caracteres: (Basado en la versión C)

a n=unlines[concat[if i^2+j^2>n^2then" "else"*"|j<-[-n..n]]|i<-[1-n,3-n..n]]
main=do n<-read`fmap`getLine;putStr$a n;print$2*sum[1|i<-a n,i==''*'']/n/n

230 caracteres:

main=do{r<-read`fmap`getLine;let{p=putStr;d=2/fromIntegral r^2;l y n=let c m x=if x>r then p"/n">>return m else if x*x+y*y<r*r then p"*">>c(m+d)(x+1)else p" ">>c m(x+1)in if y>r then print n else c n(-r)>>=l(y+2)};l(1-r`mod`2-r)0}

Sin minificar

main = do r <- read `fmap` getLine let p = putStr d = 2/fromIntegral r^2 l y n = let c m x = if x > r then p "/n" >> return m else if x*x+y*y<r*r then p "*" >> c (m+d) (x+1) else p " " >> c m (x+1) in if y > r then print n else c n (-r) >>= l (y+2) l (1-r`mod`2-r) 0

Tenía la esperanza de que superaría algunas de las versiones imperativas, pero parece que no puedo comprimirlo más en este punto.

Answer 8

HyperTalk: 237 caracteres

La sangría no es requerida ni contada. Se agrega para mayor claridad. También tenga en cuenta que HyperCard 2.2 acepta los operadores relacionales no ASCII que utilicé.

function P R
put""into t
put 0into c
repeat with i=-R to R
if i mod 2≠0then
repeat with j=-R to R
if i^2+j^2≤R^2then
put"*"after t
add 1to c
else
put" "after t
end if
end repeat
put return after t
end if
end repeat
return t&2*c/R/R
end P

Dado que HyperCard 2.2 no es compatible con stdin / stdout, en su lugar se proporciona una función.

Answer 9

JavaScript (SpiderMonkey) - 118 caracteres

Esta versión acepta la entrada de stdin y pasa los casos de prueba de bonificación

r=readline()
for(t=0,i=-r;i<r;i++)if(i%2){for(s='''',j=-r;j<r;j++){t+=q=i*i+j*j<r*r
s+=q?''*'':'' ''}print(s)}print(t*2/r/r)

Uso: cat 10 | js thisfile.js cat 10 | js thisfile.js - la vista previa de jsbin agrega un alias para imprimir / leer para que pueda ver en el navegador

Javascript: 213 163

Actualizado

r=10;m=Math;a=Array;t=0;l=document;for(i=-r;i<r;i+=2){w=m.floor(m.sqrt(r*r-i*i)*2);t+=w*2;l.writeln(a(m.round(r-w/2)).join('' '')+a(w).join(''*''));}l.writeln(t/(r*r))

Nadie dijo que tenía que renderizarse correctamente en el navegador, solo la salida. Como tal, eliminé las etiquetas pre y las optimicé aún más. Para ver el resultado, debe ver la fuente generada o establecer su hoja de estilo en consecuencia. Pi es menos preciso de esta manera, pero ahora es específico.

r=10;m=Math;a=Array;t=0;s='''';for(i=-r;i<r;i++){w=m.floor((m.sqrt(m.pow(r,2)-m.pow(i,2)))*2);t+=w;if(i%2){z=a(m.round(r-w/2)).join('' '')+a(w).join(''*'');s+=z+''/n'';}}document.write(''<pre>''+(s+(t/m.pow(r,2)))+''</pre>'')

Sin minificar

r=10;
m=Math;
a=Array;
t=0;
s='''';
for(i=-r;i<r;i++){
w=m.floor((m.sqrt(m.pow(r,2)-m.pow(i,2)))*2);
t+=w;
if(i%2){
z=a(m.round(r-w/2)).join('' '')+a(w).join(''*'');
s+=z+''/n'';
}
}
document.write(''<pre>''+(s+(t/m.pow(r,2)))+''</pre>'');

Answer 10

PHP: 117

Basado en dev-null-dweller

for($y=1-$r=$argv[1];$y<$r;$y+=2,print"/n")for($x=1-$r;$x<$r;$x++)echo$r*$r>$x*$x+$y*$y&&$s++?''*'':'' '';echo$s*2/$r/$r;

Answer 11

PHP: 126 132 138

(basado en la solución Guffa C #)

126:

for($y=1-($r=$argv[1]);$y<$r;$y+=2,print"/n")for($x=1-$r;$x<$r;$s+=$i,++$x)echo($i=$x*$x+$y*$y<=$r*$r)?''*'':'' '';echo$s*2/$r/$r;

132:

for($y=1-($r=$argv[1]);$y<$r;$y+=2){for($x=1-$r;$x<$r;@$s+=$i,++$x)echo($i=$x*$x+$y*$y<=$r*$r?1:0)?''*'':'' '';echo"/n";}echo$s*2/$r/$r;

138:

for($y=1-($r=$argv[1]);$y<$r;$y+=2){for($x=1-$r;$x<$r;@$s+=$i){$t=$x;echo($i=$t*$x++ +$y*$y<=$r*$r?1:0)?''*'':'' '';}echo"/n";}echo$s*2/$r/$r;

Completo actual:

for( $y = 1 - ( $r = $argv[1]); $y < $r; $y += 2, print "/n")
for( $x = 1-$r; $x < $r; $s += $i, ++$x)
echo( $i = $x*$x + $y*$y <= $r*$r) ? ''*'' : '' '';
echo $s*2 /$r /$r;

Puede estar sin @ antes de first $s pero solo con error_reporting establecido en 0 (Notice outputs está estropeando el círculo)

Answer 12

Perl, 95 96 99 106 109 110 119 caracteres:

$t+=$;=1|2*sqrt($r**2-($u-2*$_)**2),say$"x($r-$;/2).''*''x$;for 0..
($u=($r=<>)-1|1);say$t*2/$r**2

(La nueva línea se puede quitar y solo está allí para evitar una barra de desplazamiento)

¡Hurra! ¡Versión circular!

 $t+=$;=
1|2*sqrt($r**
2-($u-2*$_)**2)
,say$"x($r-$;/2
).''*''x$;for 0..
($u=($r=<>)-1|1
);$pi=~say$t*
2/$r**2

Para los no iniciados, la versión larga:

#!/usr/bin/perl
use strict;
use warnings;
use feature ''say'';
# Read the radius from STDIN
my $radius = <>;
# Since we''re only printing asterisks on lines where y is odd,
# the number of lines to be printed equals the size of the radius,
# or (radius + 1) if the radius is an odd number.
# Note: we''re always printing an even number of lines.
my $maxline = ($radius - 1) | 1;
my $surface = 0;
# for ($_ = 0; $_ <= $maxline; $_++), if you wish
for (0 .. $maxline) {
# First turn 0 ... N-1 into -(N/2) ... N/2 (= Y-coordinates),
my $y = $maxline - 2*$_;
# then use Pythagoras to see how many stars we need to print for this line.
# Bitwise OR "casts" to int; and: 1 | int(2 * x) == 1 + 2 * int(x)
my $stars = 1 | 2 * sqrt($radius**2-$y**2);
$surface += $stars;
# $" = $LIST_SEPARATOR: default is a space,
# Print indentation + stars
# (newline is printed automatically by say)
say $" x ($radius - $stars/2) . ''*'' x $stars;
}
# Approximation of Pi based on surface area of circle:
say $surface*2/$radius**2;

Answer 13

Potencia Shell, 119 113 109 caracteres

($z=-($n=$args[($s=0)])..$n)|?{$_%2}|%{$l="";$i=$_
$z|%{$l+=" *"[$i*$i+$_*$_-lt$n*$n-and++$s]};$l};2*$s/$n/$n

y aquí hay una versión más bonita:

( $range = -( $R = $args[ ( $area = 0 ) ] ) .. $R ) |
where { $_ % 2 } |
foreach {
$line = ""
$i = $_
$range | foreach {
$line += " *"[ $i*$i + $_*$_ -lt $R*$R -and ++$area ]
}
$line
}
2 * $area / $R / $R

Answer 14

Ruby 1.8.x, 93

r=$_.to_f
q=0
e=r-1
(p((''*''*(n=1|2*(r*r-e*e)**0.5)).center r+r)
q+=n+n
e-=2)while-r<e
p q/r/r

Ejecutar con $ ruby -p piday

Answer 15

XSLT 1.0

Solo por diversión, aquí hay una versión XSLT. No es realmente un material de código de golf, pero resuelve el problema de una manera extraña-funcional-XSLT :)

<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:msxsl="urn:schemas-microsoft-com:xslt" >
<xsl:output method="html"/>
<!-- Skip even lines -->
<xsl:template match="s[@y mod 2=0]">
<xsl:variable name="next">
<!-- Just go to next line.-->
<s R="{@R}" y="{@y+1}" x="{-@R}" area="{@area}"/>
</xsl:variable>
<xsl:apply-templates select="msxsl:node-set($next)"/>
</xsl:template>
<!-- End of the line?-->
<xsl:template match="s[@x &gt; @R]">
<xsl:variable name="next">
<!-- Go to next line.-->
<s R="{@R}" y="{@y+1}" x="{-@R}" area="{@area}"/>
</xsl:variable><!-- Print LF-->&#10;<xsl:apply-templates
select="msxsl:node-set($next)"/>
</xsl:template>
<!-- Are we done? -->
<xsl:template match="s[@y &gt; @R]">
<!-- Print PI approximation -->
<xsl:value-of select="2*@area div @R div @R"/>
</xsl:template>
<!-- Everything not matched above -->
<xsl:template match="s">
<!-- Inside the circle?-->
<xsl:variable name="inside" select="@x*@x+@y*@y &lt; @R*@R"/>
<!-- Print "*" or " "-->
<xsl:choose>
<xsl:when test="$inside">*</xsl:when>
<xsl:otherwise>&#160;</xsl:otherwise>
</xsl:choose>
<xsl:variable name="next">
<!-- Add 1 to area if we''re inside the circle. Go to next column.-->
<s R="{@R}" y="{@y}" x="{@x+1}" area="{@area+number($inside)}"/>
</xsl:variable>
<xsl:apply-templates select="msxsl:node-set($next)"/>
</xsl:template>
<!-- Begin here -->
<xsl:template match="/R">
<xsl:variable name="initial">
<!-- Initial state-->
<s R="{number()}" y="{-number()}" x="{-number()}" area="0"/>
</xsl:variable>
<pre>
<xsl:apply-templates select="msxsl:node-set($initial)"/>
</pre>
</xsl:template>
</xsl:stylesheet>

Si desea probarlo, guárdelo como pi.xslt y abra el siguiente archivo XML en IE:

<?xml version="1.0"?>
<?xml-stylesheet href="pi.xslt" type="text/xsl" ?>
<R>
10
</R>

Answer 16

Y una entrada de bash: 181 186 190 caracteres

for((y=-(r=$1,r/2*2);y<=r;y+=2));do for((x=-r;x<=r;++x));do((x*x+y*y<r*r))&&{((++n));echo -n ''*'';}||echo -n " ";((x<r))||echo;done;done;((s=1000,p=n*2*s/r/r,a=p/s,b=p%s));echo $a.$b

Ejecutar con, por ejemplo, bash py.sh 13

Answer 17

Python: 101 104 107 110 caracteres

Basado en la otra versión de Python de Nicholas Riley.

r=input()
t=0
i=1
exec"n=1+int((2*i*r-i*i)**.5)*2;t+=2.*n/r/r;print'' ''*(r-n/2)+''*''*n;i+=2;"*r
print t

Créditos a AlcariTheMad para algunas de las matemáticas.

Ah, los impares están indexados con cero como el medio, lo explica todo.

Bonus Python: 115 caracteres (rápidamente pirateados)

r=input()
t=0
i=1
while i<r*2:n=1+int((2*i*r-i*i)**.5)*2;t+=2.*n/r/r;print'' ''*(r-n/2)+''*''*n;i+=2+(r-i==2)*2
print t

Answer 18

C #: 209 202 201 caracteres:

using C=System.Console;class P{static void Main(string[]a){int r=int.Parse(a[0]),s=0,i,x,y;for(y=1-r;y<r;y+=2){for(x=1-r;x<r;s+=i)C.Write(" *"[i=x*x+++y*y<=r*r?1:0]);C.WriteLine();}C.Write(s*2d/r/r);}}

Sin minificar

using C = System.Console;
class P {
static void Main(string[] arg) {
int r = int.Parse(arg[0]), sum = 0, inside, x, y;
for (y = 1 - r; y < r; y += 2) {
for (x = 1 - r; x < r; sum += inside)
C.Write(" *"[inside = x * x++ + y * y <= r * r ? 1 : 0]);
C.WriteLine();
}
C.Write(sum * 2d / r / r);
}
}

Answer 19

Python: 118 caracteres

Prácticamente un puerto sencillo de la versión Perl.

r=input()
u=r+r%2
t=0
for i in range(u):n=1+2*int((r*r-(u-1-2*i)**2)**.5);t+=n;print'' ''*(r-n/2-1),''*''*n
print 2.*t/r/r

Answer 20

Ruby, 96 caracteres

(basado en la solución Cf de Guffa):

r=gets.to_f
s=2*t=r*r
g=1-r..r
g.step(2){|y|g.step{|x|putc'' * ''[i=t<=>x*x+y*y];s+=i}
puts}
p s/t

109 caracteres (bonificación):

r=gets.to_i
g=-r..r
s=g.map{|i|(g.map{|j|i*i+j*j<r*r ?''*'':'' ''}*''''+"/n")*(i%2)}*''''
puts s,2.0/r/r*s.count(''*'')

Answer 21

Python: 148 caracteres.

Falló (es decir, no lo suficientemente corto) intentar abusar de las reglas y codificar los casos de prueba, como mencioné en respuesta a la publicación original. Abusarlo con un lenguaje más detallado puede haber sido más fácil:

a=3.0,3.125,3.16
b="1","23","3677","47899"
r=input()
for i in b[r/3]+b[r/3][::-1]:q=1+2*int(i);print '' ''*(int(b[r/3][-1])-int(i))+''*''*q
print a[r/5]

Answer 22

Ustedes están pensando demasiado.

switch (r) {
case 1,2:
echo "*"; break;
case 3,4:
echo " ***/n*****/n ***"; break;
// etc.
}

Answer 23

C ++: 169 caracteres

#include <iostream>
int main(){int i,j,c=0,n;std::cin>>n;for(i=-n;i<=n;i+=2,std::cout<<''/n'')for(j=-n;j<=n;j++)std::cout<<(i*i+j*j<=n*n?c++,''*'':'' '');std::cout<<2.*c/n/n;}

Sin minificar

#include <iostream>
int main()
{
int i,j,c=0,n;
std::cin>>n;
for(i=-n;i<=n;i+=2,std::cout<<''/n'')
for(j=-n;j<=n;j++)
std::cout<<(i*i+j*j<=n*n?c++,''*'':'' '');
std::cout<<2.*c/n/n;
}

(Sí, usar std :: en lugar de using namespace std usa menos caracteres)

El resultado aquí no coincide con los casos de prueba en la publicación original, así que aquí hay uno que sí (escrito para facilitar la lectura). Considérelo una implementación de referencia (si a Poita_ no le importa):

#include <iostream>
using namespace std;
int main()
{
int i, j, c=0, n;
cin >> n;
for(i=-n; i<=n; i++) {
if (i & 1) {
for(j=-n; j<=n; j++) {
if (i*i + j*j <= n*n) {
cout << ''*'';
c++;
} else {
cout << '' '';
}
}
cout << ''/n'';
}
}
cout << 2.0 * c / n / n << ''/n'';
}

C ++: 168 caracteres (con salida, creo que es correcto)

#include <iostream>
int main(){int i,j,c=0,n;std::cin>>n;for(i=-n|1;i<=n;i+=2,std::cout<<"/n")for(j=-n;j<=n;j++)std::cout<<" *"[i*i+j*j<=n*n&&++c];std::cout<<2.*c/n/n;}

Answer 24

Código de máquina x86: 127 bytes

Ensamblador Intel: 490 caracteres

 mov si,80h
mov cl,[si]
jcxz ret
mov bx,10
xor ax,ax
xor bp,bp
dec cx
a:mul bx
mov dl,[si+2]
sub dl,48
cmp dl,bl
jae ret
add ax,dx
inc si
loop a
mov dl,al
inc dl
mov dh,al
add dh,dh
mov ch,dh
mul al
mov di,ax
x:mov al,ch
sub al,dl
imul al
mov si,ax
mov cl,dh
c:mov al,cl
sub al,dl
imul al
add ax,si
cmp ax,di
mov al,32
ja y
or al,bl
add bp,2
y:int 29h
dec cl
jnz c
mov al,bl
int 29h
mov al,13
int 29h
sub ch,2
jnc x
mov ax,bp
cwd
mov cl,7
e:div di
cmp cl,6
jne z
pusha
mov al,46
int 29h
popa
z:add al,48
int 29h
mov ax,bx
mul dx
jz ret
dec cl
jnz e
ret

Esta versión maneja también el caso de prueba de bonificación y tiene 133 bytes:

 mov si,80h
mov cl,[si]
jcxz ret
mov bx,10
xor ax,ax
xor bp,bp
dec cx
a:mul bx
mov dl,[si+2]
sub dl,48
cmp dl,bl
jae ret
add ax,dx
inc si
loop a
mov dl,al
rcr dl,1
adc dl,dh
add dl,dl
mov dh,dl
add dh,dh
dec dh
mov ch,dh
mul al
mov di,ax
x:mov al,ch
sub al,dl
imul al
mov si,ax
mov cl,dh
c:mov al,cl
sub al,dl
imul al
add ax,si
cmp ax,di
mov al,32
jae y
or al,bl
add bp,2
y:int 29h
dec cl
jnz c
mov al,bl
int 29h
mov al,13
int 29h
sub ch,2
jnc x
mov ax,bp
cwd
mov cl,7
e:div di
cmp cl,6
jne z
pusha
mov al,46
int 29h
popa
z:add al,48
int 29h
mov ax,bx
mul dx
jz ret
dec cl
jnz e
ret

Answer 25

GAWK: 136 , 132 , 126 , 125 caracteres

Basado en la versión Python.

{r=$1
for(i=-1;r*2>i+=2;print""){n=1+int((2*i*r-i*i)**.5)*2
t+=2*n/r/r
printf"%*s",r-n/2,""
while(n--)printf"%c","*"}print t}

Answer 26

aC: 165 , 127 , 126 caracteres

Basado en la versión Python.

r=read()
for(i=-1;r*2>i+=2;scale=6){n=sqrt(2*i*r-i*i)
scale=0
n=1+n/1*2
j=r-n/2
t+=2*n
while(j--)" "
while(n--)"*"
"
"}
t/r/r

(La nueva línea después de la última línea no se puede omitir aquí).