Considere tres secuencias numéricas A, By C:

• A: Una secuencia basada en relaciones de recurrencia f(n) = f(n-1)+f(n-2), comenzando con f(1) = 3, f(2) = 4. Entonces, la secuencia comienza así:3 4 7 11 18 29 47 76 ...
• B: Los números compuestos , es decir, todos los números enteros que no son primos (o 1):4 6 8 9 10 12 14 15 16 ...
• C: Los dígitos de Pi: 3 1 4 1 5 9 2 6 5 ...

Dado un entero positivo N < 50, ya sea como argumento de función o STDIN, devuelve el valor decimal de la fracción A(N)/B(N)con C(N)dígitos después del punto decimal. Se aplican las reglas normales de redondeo (redondee hacia arriba si el dígito N + 1 'es 5 o más). Si el enésimo dígito de pies cero, se debe imprimir un número entero. Se acepta notación científica / forma estándar para números superiores a 1000.

Este es el código de golf, por lo que gana la respuesta más corta en bytes.

Algunos ejemplos:

N = 1: 0.750
N = 2: 0.7
N = 3: 0.8750
N = 4: 1.2
N = 6: 2.416666667
N = 10: 11.056
N = 20: 764.8750

Por supuesto, se aplican las reglas estándar de golf de código.

La función debe finalizar en menos de dos minutos en cualquier computadora portátil moderna.

Pyth, 60 57 58 bytes

.[K`.Rchu,eGsGQjT7e.ftPZQ)Je/u+/*GHhyHy^TQr^T3ZZT\0+xK\.hJ

Arnés de prueba

Es bastante sencillo: calcule pi, la serie de Fibonacci y los compuestos, redondeado a dígitos C (n), almohadilla a dígitos C (n) más la ubicación de los dígitos del punto decimal, hecho.

Un): hu,eGsGQjT7

B (n): e.ftPZQ)

C (n): e/u+/*GHhyHy^TQr99ZZT

60 -> 57: Limpió el caso especial n = 1 en el cálculo de pi.

57 -> 58: No estaba usando una precisión lo suficientemente alta para pi para todo el rango de entrada: aumentó 99 iteraciones a 1000 iteraciones.

Nota sobre el redondeo: Esto utiliza el sistema de redondeo "más cercano" de Python, en lugar del sistema OP especificado "hacia el infinito". Sin embargo, la diferencia solo es importante si los dígitos que siguen inmediatamente al punto de redondeo son 5000..., por ejemplo, 1,25 redondeados a 1 dígito. Verifiqué el rango de entrada, y esto nunca sucede, por lo que siempre se devuelve el resultado correcto.

PowerShell, 420 Bytes (ayyyyyyyy) 378 Bytes

param($n);[int[]]$p="03141592653589793238462643383279502884197169399375"-Split'';$a=@(0,3,4);for($i=3;$i-lt50;$i++){$a+=$a[$i-1]+$a[$i-2]};$c=[char[]]"00001010111010111010111011111010111110111010111011111011111010111110111";$b=@(0);for($i=4;$i-le70;$i++){if($c[$i]-eq'1'){$b+=$i}};[double]$r=$a[$n]/$b[$n];$q=$p[$n+1];$s="";(0..($q-1))|%{$s+="0"};([math]::Round($r,$q,[MidpointRounding]::AwayFromZero)).ToString("0.$s")

_{Gracias a isaacg por guardar 41 bytes, por calcular cómo se redondea la pregunta. Significa que no tuve que incluir lo horrendo [MidpointRounding]::AwayFromZeroy que no tuve que lanzarlo explícitamente como a [double].}

Este fue muy divertido!

Expandido:

# Take input N
param($n)

# First digits of pi, stored as integer array
[int[]]$p="03141592653589793238462643383279502884197169399375"-Split''

# Fibonacci sequence A(N)
$a=@(0,3,4)
for($i=3;$i-lt50;$i++){
  $a+=$a[$i-1]+$a[$i-2]
}

# Zero-indexed bitmask for if the n-th integer is composite (1) or not (0)
$c=[char[]]"00001010111010111010111011111010111110111010111011111011111010111110111"

# Populate B(N) as an array using the $c mask
$b=@(0)
for($i=4;$i-le70;$i++){
  if($c[$i]-eq'1'){
    $b+=$i
  }
}

# Calculation Time!
$r=(a($n))/$b[$n]

# A small golf, as $p[$n+1] gets used a couple times
$q=$p[$n+1]

# Need to generate a string of zeroes for padding
$s=""
(0..($q-1))|%{$s+="0"}

# Round the number, then send it to a string so we get the necessary number of zeroes
([math]::Round($r,$q)).ToString("0.$s")

La recursión en PowerShell es ... lenta, digamos, así que tenemos que construir A(N)la otra dirección y almacenarla en una matriz, luego indexarla.

ANTIGUO

Además, vaca sagrada, ¿los requisitos de salida mataron esto? El valor predeterminado de PowerShell es redondear al redondeo bancario más cercano a / k / a, lo que requiere la utilización de lo extraordinariamente detallado [MidpointRounding]::AwayFromZeropara cambiar los estilos de redondeo . Además de eso, necesitamos rellenar ceros finales, si los hay. Esos dos requisitos se combinaron para convertir el último par de líneas de 20 Bytes [math]::Round($r,$q) a 102 Bytes (del $s=""al +$s)) ... wow.

Javascript (ES6), 302 bytes

Una palabra: sin terminar.

x=>{a=[0,3,4],b=[0],c='03141592653589793238462643383279502884197169399375';for(i=1;i<x;a[i+2]=a[i]+a[++i]);for(i=1,p=[];++i<70;v=p.every(x=>i%x),(v?p:b).push(i));r=''+Math.round(a[x]/b[x]*(l=Math.pow(10,c[x])))/l;if(x==33)return r;r.indexOf`.`<0&&(r+='.');while(!r[r.indexOf`.`+ +c[x]])r+='0';return r}

Los primeros 49 dígitos de pi se almacenan en una cadena, y las otras dos secuencias se generan automáticamente. Esto ha sido golf alrededor de la mitad; Estoy (casi) seguro de que podría exprimir otros 50 bytes.

Funciona para todos los casos de prueba, y debería funcionar para el resto. Se bloquea en algo más de 49 o menos de 0 (nunca debería encontrarse con estas situaciones de todos modos). Me gusta especialmente su resultado para 0:

NaN.

Octava, 276 236 bytes

En primer lugar, pensé que sería genial hacer uso de una precisión ilimitada en estas herramientas matemáticas (y actualizar algunos conocimientos al respecto), así que comencé a escribir algunos algoritmos y finalmente descubrí que el pivalor no es tan preciso que yo tendrá que usar la matriz nuevamente. Así que de nuevo, no hay gran éxito:

function c(A)p="3141592653589793238462643383279502884197169399375";f=ones (1,50);f(1)=3;f(2)=4;for i=3:53f(i)=f(i-1)+f(i-2);end
i=0;x=1;while i<A
x++;for j=2:x/2
if mod(x,j)==0 i++;break;end end end
printf(["%." p(A) "f\n"],f(A)/x);end

Todavía bastante legible, ¿no?

Uso

función copiar-pegar en octava, llamar a la función ccon argumento de valor requerido:

>>> c(1)
0.750
>>> c(49)
407880480.04348

Optimizaciones:

• Sustituto endif, endfory similar con endla que funciona de la misma manera
• variable decreciente ien uno guardar un byte
• eliminar num2str(str2num(p(A)))tonterías :)