C++ Sequência de números 36X37/1...

[phk1]

Eu estou no início do treinamento. Fiz um pequeno algoritmo no qual há uma sequência de números e começa de 36 X 37 / 2 + 35 X 36 /3 + ... 1 X 2 / 37.

int deno,a,b;
a = 37;
b = 38;
for (deno=1;deno<=38;deno++){
a = a - 1;
b = b - 1;

cout << a << " X " << b << "/" << deno << "\n";

O problema está no final da impressão, quando chega ao final é impresso -1 X 0 / 38. Quero que termine com 0 X 0 / 38.

[Ansi C]

Em 16/07/2018 às 21:10, phk1 disse:

O problema está no final da impressão, quando chega ao final é impresso -1 X 0 / 38. Quero que termine com 0 X 0 / 38.

De imediado a solução é usar operador lógico E (&&)

Asserção && Operação

 

Nesse caso se b tem 0 então o valor da expressão será 0, senão  executa operação.

Analise:

/** funcao principal do programa  */
int main (void){
    int a = 37;
    int b = 38;
    int deno = 0;
    
        for (deno = 1; deno <= 38; deno++){
                a && (a = a - 1);  // Se a tem 0; não faça a - 1
                b && (b = b - 1);  // Se b tem 0; não faça b - 1
                std ::cout << a << 'X' << b << '/' << deno << '\n';
        }
    return 0;
}

 

Dúvidas, sugestões ou criticas?

Ps.: A quem defenda o uso de IF ou até mesmo operador ternário (?:) para esse caso.

[Visitante]

@phk1 Olá. Por acaso não seria esse o enunciado do exercício: 

 

2) Fazer um programa que calcule e escreva a seguinte soma:
S= (37*38)/1 + (36*37)/2 + (35*36)/3 .... (1*2)/37     (!!??)

 

Dá uma olhada:

https://programaremc.blogspot.com/2010/02/exercicios-resolvidos-de-series-em-c.html

[Ansi C]

4 minutos atrás, giu_d disse:

@phk1 Olá. Por acaso não seria esse o enunciado do exercício: 

 

2) Fazer um programa que calcule e escreva a seguinte soma:
S= (37*38)/1 + (36*37)/2 + (35*36)/3 .... (1*2)/37     (!!??)

Têm muitas semelhanças, bem observado: Enquanto esse pede a somatória (S), o atual que pede apenas os muitos valores.

 

[Visitante]

@AnsiC Se for ver o enunciado do tópico e esse q passei (pedindo a soma) não faz sentido terminar com 0 X 0 / 38

Seria 1 X 2 / 37

 

[Ansi C]

7 minutos atrás, giu_d disse:

@AnsiC Se for ver o enunciado do tópico e esse q passei (pedindo a soma) não faz sentido terminar com 0 X 0 / 38

Seria 1 X 2 / 37

 

Sim faz muito mais sentido! Agora só nos resta ele explicar essa viagem: 0 x 0 / 38

[Visitante]

@AnsiC Gostei do termo: 

33 minutos atrás, AnsiC disse:

essa viagem: 0 x 0 / 38

Desculpa mas acabei rindo sozinho aqui. E parece q seria algo assim mesmo: Algo sem sentido. 

Daria para ajustar o código para terminar da forma q o autor do tópico está querendo, mas aí quebraria a lógica da sequência  

[phk1]

Desculpe, errei. Termina com 1 X 2 / 37.  Ignorar o 0 na contagem, o motivo não entendi bem, mas parece que é feito um teste para ver se a ou b tem o valor 0 e ignorá-los na contagem para que o for não ultrapasse o limite da sequência. É esse o raciocínio?

[phk1]

Não conhecia sobre asserções em c++.

adicionado 1 minuto depois

Estou até pesquisando sobre a palavra, seu significado para compreender um pouco mais.

[Visitante]

@phk1 Iniciando com a impressão 37 X 38 / 1, q me parece a mais correta, o código poderia ficar assim:

#include <iostream>
using namespace std;

int main() {

    int deno, a, b;

    a = 38;
    b = 39;

    for (deno = 1; deno < 38; deno++){
        a--;
        b--;
        cout << a << " X " << b << "/" << deno << endl;
    }

    return 0;
}

só q ainda não ficou bem claro de como iniciar

[phk1]

Pelo que entendi, quando o programa alcança um ponto específico, para o programa continuar as variáveis tem de ter o valor 0, quer dizer, tem determinado valor e sabemos que este valor é com certeza total 0 então este tipo de teste é ignorado e nada é feito?

[Visitante]

@phk1 Mas em casos assim o exercício deve ser feito conforme o enunciado.

A dúvida é como iniciar, pois se trata de um exercício onde é usada uma sequência lógica.

No título do tópico está como 36 X 37 / 1... Já no enunciado do exercício está 36 X 37 / 2 (!?)

[phk1]

Na asserção quero garantir quando a ou b forem 0 não faça a = a - 1, ou seja, forço o compilador para sempre nesta situação específica ignorar o 0 e quando surgir outra situação que não está, o programa compila.

adicionado 4 minutos depois

É para fazer de 37 X 38 / 1 + 36 X 37 / 2 + 35 X 34 /3 + 34 X 33 ? 4 + ... 1 X 2 / 37 ou 0 X 0 / 38.

adicionado 6 minutos depois

É uma sequência de dígitos sempre diminuindo até chegar a 0 X 0 / 38.

[Ansi C]

8 horas atrás, phk1 disse:

Na asserção quero garantir quando a ou b forem 0 não faça a = a - 1, ou seja, forço o compilador para sempre nesta situação específica ignorar o 0 e quando surgir outra situação que não está, o programa compila.

adicionado 4 minutos depois

É para fazer de 37 X 38 / 1 + 36 X 37 / 2 + 35 X 34 /3 + 34 X 33 ? 4 + ... 1 X 2 / 37 ou 0 X 0 / 38.

adicionado 6 minutos depois

É uma sequência de dígitos sempre diminuindo até chegar a 0 X 0 / 38.

tá, então é isso que você deseja fazer, pois bem; o código postado faz isso!

#include <iostream>

/** funcao principal do programa  */

int main (void){
    int a = 37;
    int b = 38;
    int deno = 0;
    
        for (deno = 1; deno <= 38; deno++, b && std :: cout << " + "){
                a && (a = a - 1);  // Se a tem 0; não faça a - 1
                b && (b = b - 1);  // Se b tem 0; não faça b - 1
                std :: cout << a << " X " << b << " / " << deno;
        }
        std :: cout << '\n';
        
    return 0;
}

 

 

Ou será que não faz?! Eu já não sei!!!!!!! Dúvidas, criticas ou perguntas?

 

[Visitante]

@phk1 Taí. O código postado pelo @AnsiC faz o que você quer.

Só q vale lembrar q terminando do modo como você quer:  0 X 0 / 38 a lógica da sequência e quebrada e também o enunciado do exercício é claramente ignorado! 

adicionado 28 minutos depois

Esse seria o exercício q usa uma sequência parecida com a essa do tópido (senão a mesma) q está no link q foi passado acima:

/* 2) Fazer um programa que calcule e escreva a seguinte soma:

S/= (37*38)/1 + (36*37)/2 + (35*36)/3 .... (1*2)/37 */

#include <stdio.h>

int main(void)
{
    int numerador,denominador;
    float soma;

    numerador=37;
    soma=0;

    for(denominador=1; denominador<=37; denominador++) {
        // perceba aqui: numerador * (numerador + 1)
        soma=soma+((float)numerador*(numerador+1))/denominador;
        numerador--;
    }
    
    printf("%f",soma);
   
}

 

[Ansi C]

Perfeito com os dois algoritmos será mais fácil de perceber: Cada qual com suas especificações,  as diferenças lógicas e não lógicas! Agora é com você @phk1 ! 

[isrnick]

@phk1

 

Isto:

a && (a = a - 1);

É o mesmo que isto:

a != 0 && (a = a - 1) != 0;

ou para deixar ainda mais claro:
  
(a != 0) && ((a = a - 1) != 0);

(Pois em C zero é igual a Falso, e qualquer valor diferente de zero é Verdadeiro, então sabendo disso pense um pouco sobre os valores de a para entender como essas 2 expressões são equivalentes.)

 

Nessa segunda versão fica mais claro o que está acontecendo, existem duas comparações de diferença, que checam se valores são diferentes de 0, e é efetuada a operação booleana E (&&) entre os resultados dessas 2 comparações.

 

Mas note que a operação booleana "Falso E qualquer-coisa" sempre resulta em "Falso". E isso significa que se a primeira parte for falsa a segunda parte não precisa ser checada pois já sabe-se que o resultado será falso, independentemente do valor da segunda parte, logo nesse caso por otimização essa segunda parte do comando nem se quer é executada, pois é desnecessário. A segunda parte só é executada e verificada se a primeira parte for verdadeira.

 

Ou seja, quando a for igual a 0 a segunda parte da operação booleana E não é executada, então não subtrai 1 de a pois isso só é feito na segunda parte, resultando que a não fica menor que 0.

 

 

 

Algo similar acontece na operação booleana OU (||), onde "Verdadeiro OU qualquer-coisa" sempre resulta em "Verdadeiro". Eu dei uma explicação sobre um caso usando essa propriedade da operação booleana OU nesse post:

 

[phk1]

Todas as questões foram muito esclarecedoras, muito obrigado a todos.