Citação de: Sr. Pedro Reis em 02 de Novembro de 2018, 09:08:32

CONSTRUÍDO COM SUCESSO (tempo total: 58 segundos)

No meu NetBeans levou BUILD SUCCESSFUL (total time: 2 minutes 11 seconds)
Sem formatar reduzi pra 6

run:
P(3) = 0.001
P(4) = 0.002
P(5) = 0.003
P(6) = 0.003999
P(7) = 0.004997
P(8) = 0.005994
BUILD SUCCESSFUL (total time: 6 seconds)

Citação de: Gorducho em 02 de Novembro de 2018, 12:40:01

Citação de: Sr. Pedro Reis em 02 de Novembro de 2018, 09:08:32

CONSTRUÍDO COM SUCESSO (tempo total: 58 segundos)

No meu NetBeans levou BUILD SUCCESSFUL (total time: 2 minutes 11 seconds)
Sem formatar reduzi pra 6

run:
P(3) = 0.001
P(4) = 0.002
P(5) = 0.003
P(6) = 0.003999
P(7) = 0.004997
P(8) = 0.005994
BUILD SUCCESSFUL (total time: 6 seconds)

Ah, eu não me preocupei com eficiência.

Mas 6 segundos é muito bom.

Põe o código aí!!!

Não precisa formatar o string...
Depois vou ver o tempo que leva em Python...

Citação de: Gorducho em 02 de Novembro de 2018, 13:21:02

Não precisa formatar o string...
Depois vou ver o tempo que leva em Python...

É, foi burrice formatar. Mas a minha cabeça estava na ideia de fazer a simulação "literalmente".

Foi por isso.

Mas acho que tenho a solução para rodar em .... 0 segundos...

Se o teste der certo eu posto aqui.

Calculando até P(35) em .... 0 segundos!!

run:
P(3) = 0.001
P(4) = 0.002
P(5) = 0.003
P(6) = 0.003999
P(7) = 0.004997
P(8) = 0.005994
P(9) = 0.006990001
P(10) = 0.007985004
P(11) = 0.00897901
P(12) = 0.009972019999
P(13) = 0.010964034995
P(14) = 0.011955055985
P(15) = 0.012945083965001
P(16) = 0.013934119930006
P(17) = 0.014922164874021
P(18) = 0.015909219790056
P(19) = 0.01689528567012599
P(20) = 0.017880363505251972
P(21) = 0.01886445428546191
P(22) = 0.019847558999791792
P(23) = 0.020829678636286538
P(24) = 0.02181081418200107
P(25) = 0.02279096662300129
P(26) = 0.023770136944365
P(27) = 0.024748326130182994
P(28) = 0.02572553516356
P(29) = 0.02670176502661564
P(30) = 0.027677016700485453
P(31) = 0.02865129116532189
P(32) = 0.029624589400295265
P(33) = 0.03059691238359479
P(34) = 0.03156826109242946
P(35) = 0.03253863650302918
CONSTRUÍDO COM SUCESSO (tempo total: 0 segundos)

Até P(40) em 1 segundo:

run:
P(3) = 0.001
P(4) = 0.002
P(5) = 0.003
P(6) = 0.003999
P(7) = 0.004997
P(8) = 0.005994
P(9) = 0.006990001
P(10) = 0.007985004
P(11) = 0.00897901
P(12) = 0.009972019999
P(13) = 0.010964034995
P(14) = 0.011955055985
P(15) = 0.012945083965001
P(16) = 0.013934119930006
P(17) = 0.014922164874021
P(18) = 0.015909219790056
P(19) = 0.01689528567012599
P(20) = 0.017880363505251972
P(21) = 0.01886445428546191
P(22) = 0.019847558999791792
P(23) = 0.020829678636286538
P(24) = 0.02181081418200107
P(25) = 0.02279096662300129
P(26) = 0.023770136944365
P(27) = 0.024748326130182994
P(28) = 0.02572553516356
P(29) = 0.02670176502661564
P(30) = 0.027677016700485453
P(31) = 0.02865129116532189
P(32) = 0.029624589400295265
P(33) = 0.03059691238359479
P(34) = 0.03156826109242946
P(35) = 0.03253863650302918
P(36) = 0.03350803959064557
P(37) = 0.03447647132955316
P(38) = 0.03544393269305011
P(39) = 0.03641042465345947
P(40) = 0.03737594818212993
CONSTRUÍDO COM SUCESSO (tempo total: 1 segundo)

p() é a função que eu iria solicitar ao Alquimista superdotado para encontrar. É a função que calcula e desconta todas as ocorrências redundantes no cálculo.

Mas acho que essa versão só dá o resultado correto se todos os dígitos da sequência que está sendo procurada na série (que está se calculando a probabilidade de encontrar) forem distintos. Esse cáculo deve falhar para uma subsequência como 1111.

public class Serie
{

public static double p(int n, int k)
{
if (n return 0;
else
{
double s = Math.pow(10,n-k) * (n-k+1);

for (int i = 0; i <= (n-k); i++)
s = s - p(n-k-i,k) * Math.pow(10,i);
return s;
}
}//fim de p()

public static void main(String[] args)
{

for (int i = 3; i <=40; i++)
System.out.println("P("+i+") = "+p(i,3)/Math.pow(10,i));


}//fim de main()

}

Citar

p() é a função que eu iria solicitar ao Alquimista superdotado para encontrar.

Jura?

Não entendi bulhufas
Em algumas situações não acontecem loops e "n" se repete...
Pus em Python pra ficar + light de lidar, mas os resultados são os mesmos que em Java
Em particular n = 6 (fazendo aquele original n = 8, k sempre 3 claro)
n = 6, s0 = 4000
n = 3, s0 = 1
loop(0) s = 1
loop(0) s = 3999
loop(1) s = 3999
loop(2) s = 3999
loop(3) s = 3999
P(6) = 0.003999

E s não varia durante os loops...

def p(n, k):
if n < k : return 0
else:
s = (n - k + 1) * 10**(n - k)
print("n = " + str(n) + ", s0 = " + str(s))
for i in range(n - k + 1):
s = s - p(n - k - i, k) * 10**i
print("loop(" + str(i) + ") s = " + str(s))
return s
def main(n, k):
for i in range(k, n + 1): print("P(" + str(i) + ") = " + str(p(i, k)/10**i))
input("Qualquer tecla pra sair...")
main(int(input("n: ")), int(input("k: ")))

Em Java (pro looping i (que é o n) da vez = 6)
n - k = 3, s0 = 4000.0
n - k = 0, s0 = 1.0
loop(0): s = 1.0
loop(0): s = 3999.0
loop(1): s = 3999.0
loop(2): s = 3999.0
loop(3): s = 3999.0
P(6) = 0.003999