Considere três seqüências numéricas A, Be C:

• A: Uma sequência baseada em relações de recorrência f(n) = f(n-1)+f(n-2), começando com f(1) = 3, f(2) = 4. Então, a sequência começa assim:3 4 7 11 18 29 47 76 ...
• B: Os números compostos , ou seja, todos os números inteiros que não são números primos (ou 1):4 6 8 9 10 12 14 15 16 ...
• C: Os dígitos do Pi: 3 1 4 1 5 9 2 6 5 ...

Dado um número inteiro positivo N < 50, como argumento da função ou STDIN, retorne o valor decimal da fração A(N)/B(N)com C(N)dígitos após o ponto decimal. Aplicam-se regras normais para arredondamento (arredondar para cima se o dígito N + 1'th for 5 ou superior). Se o enésimo dígito de pifor zero, um número inteiro deve ser impresso. notação científica / formulário padrão é aceito para números maiores que 1000.

Isso é código de golfe, então a resposta mais curta em bytes vence.

Alguns exemplos:

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

Obviamente, aplicam-se as regras padrão do código de golfe.

A função deve terminar em menos de dois minutos em qualquer laptop moderno.

Pitão, 60 57 58 bytes

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

Equipamento de teste

É bem simples - calcule pi, a série fibonacci e os compósitos, arredondados para dígitos C (n), preenchidos para dígitos C (n) mais a localização dos dígitos decimais, concluídos.

A): hu,eGsGQjT7

B (n): e.ftPZQ)

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

60 -> 57: Limpou o caso especial n = 1 no cálculo pi.

57 -> 58: não estava usando precsão alta o suficiente para pi para toda a faixa de entrada - aumentou 99 iterações para 1000 iterações.

Nota sobre o arredondamento: usa o sistema de arredondamento "mais próximo" do Python, em vez do sistema operacional "especificado para o infinito". No entanto, a diferença só importa se os dígitos imediatamente após o ponto de arredondamento forem 5000..., por exemplo, 1,25 arredondados para 1 dígito. Eu verifiquei o intervalo de entrada, e isso nunca acontece, então o resultado correto é sempre retornado.

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

_{Obrigado a isaacg por salvar 41 bytes, por calcular como a pergunta é arredondada. Significa que eu não precisava incluir o horrendo [MidpointRounding]::AwayFromZeroe não precisava explicitamente escalar como a [double].}

Este foi muito 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")

A recursão no PowerShell é ... lenta, digamos, então precisamos construir A(N)a outra direção e armazená-la em uma matriz e depois indexá-la.

VELHO

Além disso, vaca sagrada, os requisitos de saída acabaram com isso. O PowerShell usa como padrão o arredondamento para o arredondamento a / k / a do banqueiro mais próximo, o que exige a utilização de detalhes extraordinários [MidpointRounding]::AwayFromZeropara alternar os estilos de arredondamento . Além disso, precisamos preencher os zeros à direita, se houver. Esses dois requisitos combinados para transformar o último par de linhas de 20 bytes [math]::Round($r,$q) para 102 bytes (do $s=""para +$s)) ... uau.

Javascript (ES6), 302 bytes

Uma palavra: inacabada.

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}

Os primeiros 49 dígitos de pi são armazenados em uma sequência e as outras duas seqüências são geradas automaticamente. Isso foi jogado no meio do caminho; Tenho (quase) certeza de que poderia extrair outros 50 bytes dele.

Funciona para todos os casos de teste e deve funcionar para o resto. Falha em algo maior que 49 ou menor que 0 (nunca deve encontrar essas situações de qualquer maneira). Eu gosto especialmente do resultado para 0:

NaN.

Oitava, 276 236 bytes

Antes de tudo, achei que seria legal usar alguma precisão ilimitada nessas ferramentas matemáticas (e atualizar algum conhecimento sobre isso), então comecei a escrever alguns algoritmos e depois finalmente descobri que o pivalor não é tão preciso que eu terá que usar a matriz novamente. Então, novamente, sem grande sucesso:

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

Ainda bem legível, não é?

Uso

função copiar-colar na oitava, chamar função ccom argumento do valor necessário:

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

Otimizações:

• Substituto endif, endfore semelhante com endo que funciona da mesma maneira
• variável decrescente iem um, salvar um byte
• remover num2str(str2num(p(A)))absurdo :)