Citação de: Gorducho em 02 de Novembro de 2018, 19:29:52

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

Não manjo de Python mas esta implementação está incorreta. P() é uma função recursiva. Esse código está errado.

Rodou a versão Java? Você vai ver que os resultados são os mesmos da versão que faz a simulação.

O raciocínio é meio enjoadinho mesmo.

Mas nessa linha é calculada todas as ocorrências da subsequência na série.

double s = Math.pow(10,n-k) * (n-k+1);

Porém este cálculo está errado, porque calculando assim está se computando algumas ocorrências mais de uma vez.

Então, nesse loop, o algoritmo subtrai de s as ocorrências que foram computadas redundantemente.

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

Fazendo uma chamada recursiva para p()

Citação de: Gorducho

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

Basta copiar e colar o código que eu botei ali em cima. Sem mudar nada.

Var dar os resultados que estão listados.

Citação de: Gorducho em 02 de Novembro de 2018, 19:29:52

Não entendi bulhufas

Vou pensar em um jeito simples de explicar o código.

Só pus em Python pra ficar + light de lidar inclusive c/os parâmetros.
Claro que os resultados fecham, só que eu não entendi
Em Python pra n = 40
...
P(39) = 3,641%
P(40) = 3,738%

Vamos pensar em uma série com 7 dígitos como exemplo.

Suponha que, tomando TODAS as séries possíveis e distintas com 7 dígitos, você queira saber em QUANTAS destas séries há PELO MENOS uma sequência 123 ( para simularmos o experimento de Sagan ).

Veja que qualquer série com 123XXXX, por exemplo, satisfaz esta condição. E para XXXX nós podemos ter 10 mil combinações distintas. Então há 10 mil séries, entre todas as possíveis com 7 dígitos, que começam com 123.

Podemos então incluir 10.000 na nossa soma.

O mesmo para X123XXX, e para XX123XX e para XXX123X e também para XXXX123.

Então contamos para cada uma destes casos 10 mil combinações, dando um total de 50 mil combinações.

E a linha abaixo realizou este somatório:

double s = Math.pow(10,n-k) * (n-k+1);

Só que esta conta estaria errada! Tem que ser menos que 50 mil, pois somando assim, estamos somando algumas combinações mais de uma vez. Por exemplo: a combinação 1231237 foi computada tanto no grupo 123XXXX quanto no grupo XXX123X.

Deu para entender? Então a ideia é como descontar estas somas redundantes desse total de 50 mil.

Podemos fazer isto raciocinando recursivamente...

Eu desconto todas as somas redundantes em 123XXXX chamando p() recursivamente para que ele me retorne quantas ocorrências de 123 pode haver em XXXX (uma sequência de 4 dígitos) e então subtraio do total de 50 mil. É preciso fazer isso também para X123XXX, para XX123XX, para XXX123X e para XXXX123.

Bom, vou tentar explicar melhor o parágrafo acima porque ficou péssimo.

Na minha cabeça, imagino a subsérie 123 "escorregando" da esquerda para a direita pela série de 7 dígitos.

Assim:

(0) 123XXXX
(1) X123XXX
(2) XX123XX
(3) XXX123X
(4) XXXX123

Por isso, no loop abaixo, i assume valores de 0 até (n-k)=(7-3)=4

Para que 123 "escorregue" do início até o final.

Quando 123 está na posição (0), a chamada recursiva p(n-k-i,k) me retorna que é possível formar 20 séries distintas com XXXX (os Xs que estão à direita de 123), onde apareça pelo menos uma subsérie 123.

Então eu desconto estas 20 séries, das 10 mil que computei para 123XXXX. Porque quando o 123 escorregar para aquele XXXX, estas 20 seriam somadas de novo. ( Na verdade todas já foram somadas na linha double s = Math.pow(10,n-k) * (n-k+1); agora só estou "tirando" o que foi somado em excesso).

Mas note que é preciso multiplicar este resultado ( 20 ) por 10 elevado ao número de Xs que ficaram à esquerda do 123. Nesse caso, na posição (0), não há nenhum X ainda à esquerda. Logo Math.pow(10, i) multiplica por 1. (i=0)

Então para a posição (0) são subtraídos apenas 20 de 50 mil. E "s" assume o valor 49.980

Na próxima iteração, quando 123 estiver na posição (1), a chamada recursiva p(n-k-i,k) me retorna que é possível formar apenas uma série de 3 dígitos onde 123 apareça. No entanto agora há um X à esquerda (X123XXX), e como isto será verdade para este X à esquerda assumindo valores de 0 a 9, o resultado retornado por p(n-k-i,k) = 1 é multiplicado por Math.pow(10,1).

Ou seja, é multiplicado agora por 10, e 10 é subtraído dos 49.980 restantes. E "s" assume o valor 49.970

Nas próximas iterações (2),(3) e (4), sobram respectivamente 2, 1 e 0 Xs à direita do 123. Portanto não é possível "encaixar" 123 nestas posições e (n) = TRUE, logo a chamada recursiva p(n-k-i,k) retornará 0.

Então o procedimento termina retornando o valor 49.970, que é exatamente o número de séries de 7 dígitos onde a sequência 123 aparece PELO MENOS uma vez.

E este é o loop que faz isso, com a chamada recursiva:

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

Mas tem umas sutilezas lógicas aí que precisam de uma "craneada" para entender... Por exemplo, a condição de parada da recursão (n), detecta que a subsérie é maior que série, portanto retorna 0 ocorrências possíveis para a subsérie.

Bom, esta é mais ou menos a ideia que fez o programa funcionar. Mas isso é muita masturbação mental para um dia de Finados.

O que tava + me confundindo é que, claro , na 1ª chamada da recursão (loop interno) de novo gera o s inicial fora desse loop. Então eu via repetido e sem imprimir paux que é as chamadas internas da própria função...

n: 7
k: 3
50000
looping recursivo...
20
looping recursivo...
0
0 ,0
20
looping recursivo...
0
1 ,0
20
-20
0 ,-20
49980
looping recursivo...
1
looping recursivo...
0
0 ,0
1
-10
1 ,-10
49970
looping recursivo...
0
2 ,0
49970
looping recursivo...
0
3 ,0
49970
looping recursivo...
0
4 ,0
49970
P(7) = 0.004997
Qualquer tecla pra sair...
>>>

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

Já disse outras vezes: meus queridos amigos do fcc têm enorme facilidade de criar debates paralelos que pouco ou nada têm com o tema central.
Debates paralelos costumam enriquecer, pois desenvolvem interessantes perspectivas; mas alguns afastam definitivamente do assunto que promete a possibilidade de bela argumentação.

Citação de: Sr. JungF em 03 de Novembro de 2018, 13:00:47

meus queridos amigos do fcc têm enorme facilidade de criar debates paralelos

pero no mucho en este caso en pantalla...
Foi com propriedade lembrada a ficção do Sagan e depois feitas considerações até mesmo práticas acerca da tendência a que qq. sequencia de dígitos apareça n'algum momento dentro duma sequencia de infinitos contáveis dígitos.
Não TÃO fora do tema...
De qq. modo, da minha parte acho sólido seu argumento no sentido de que se acaso se algum dia pude(sse/r)mos comprovar que o real se comporta conforme postulado por determinad(a/o) {seita, "religião", grupo de crentes, you name it...} seria forte indício que a divindade postulada por esses de fato exista

Citação de: Fernando Silva em 31 de Outubro de 2018, 07:35:11

Enquanto não pudermos definir o que é um deus (e isto o diferencia de uma entidade superpoderosa), não teremos como definir critérios de verificação.

Sim Fernando, o diferencia de uma entidade superpoderosa.
Contudo, podemos definir Deus em conceituação filosófica: O único Criador, Onipotente.
Daí, tudo o mais é decorrente, pela lógica. Bondade, Justiça, Onisciência, etc.
Citar

Como já disseram, ele só precisa de um poder: aquele de nos convencer de que é um deus. Mesmo que não seja.

Com certeza ele não está interessado em convencer-nos de que ele existe como um Deus, caso contrário isto já teria ocorrido.

Restaria uma questão: para os crentes, por qual razão ele não prova a sua existência?
Quero dizer, se eu acredito que ele existe, por qual razão ele não prova aos que não acreditam, a sua existência?

Tudo ficaria mais fácil?!!

Ou, tudo seguiria do mesmo modo, como sempre?