Ir ao conteúdo
  • Cadastre-se
edgargoncalveslimajr

C++ Cortar energia de um comodo de uma casa de acordo com o dia da semana em c++

Recommended Posts

Galera como posso exibir se a energia esta ligada ou nao dependendo do dia da semana? a regra é que em cada dia diferente , um comodo tera sua energia cortada... ai o usuario vai digitar a opcao correspondente ao dia da semana e tera que ser exibido se a energia esta ligada ou nao em cada comodo da casa (tipo, segunda feira, a sala de visita devera estar com a energia desligada, enquanto o resto estara ligada...ai o usuario escolhe o dia da semana digitando a opcao, por exemplo, da segunda feira, e aparece que a sala de visita esta desligada e o resto dos comodos esta ligada...)

 

outra coisa, eu queria que ao final as informações estivessem gravadas em cada variavel (comodo) de acordo com o fato que é o dia da semana, pra poder adicionar mais um fato ( se a energia esta ligada de acordo com a presenca de pessoas nos comodos)

 

 sou iniciante, bem iniciante mesmo e estava tentando , me ajudem urgente pls:

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(){
    
    struct casa{
        
        int energia_ligada = 1;
        int energia_desligada = 2;
        
        int jardim;
        
        int sala_de_visita;
        int cozinha;
        int banheiro;
        int quarto1;
        int quarto2;
        int quarto3;
        int quarto4;
};
    struct casa energia_ligada;
    struct casa energia_desligada;
        
    struct casa jardim;
        
    struct casa sala_de_visita;
    struct casa cozinha;
    struct casa banheiro;
    struct casa quarto1;
    struct casa quarto2;
    struct casa quarto3;
    struct casa quarto4;
    
    int opcao, i=0;
    
    while(true){
    printf("Bem vindo!\n");
    printf("Qual o dia da semana?\n");
    printf("1.Domingo\n");
    printf("2.Segunda\n");
    printf("3.Terca\n");
    printf("4.Quarta\n");
    printf("5.Quinta\n");
    printf("6.Sexta\n");
    printf("7.sábado\n");
    scanf("%d", &opcao);
    
    switch(opcao){
        case 1:
            if(opcao = 1){
                sala_de_visita = energia_desligada;
            }else{
                cozinha = energia_ligada;
                banheiro = energia_ligada;
                quarto1 = energia_ligada;
                quarto2 = energia_ligada;
                quarto3 = energia_ligada;
                quarto4 = energia_ligada;
            }
            i++;
            break;
                case 2:
            if(opcao = 2){
                cozinha = energia_desligada;
            }else{
                sala_de_visita = energia_ligada;
                banheiro = energia_ligada;
                quarto1 = energia_ligada;
                quarto2 = energia_ligada;
                quarto3 = energia_ligada;
                quarto4 = energia_ligada;
            }break;
                case 3:
            if(opcao = 3){
                banheiro = energia_desligada;
            }else{
                cozinha = energia_ligada;
                sala_de_visita = energia_ligada;
                quarto1 = energia_ligada;
                quarto2 = energia_ligada;
                quarto3 = energia_ligada;
                quarto4 = energia_ligada;
            }break;
                case 4:
            if(opcao = 4){
                quarto1 = energia_desligada;
            }else{
                cozinha = energia_ligada;
                banheiro = energia_ligada;
                sala_de_visita = energia_ligada;
                quarto2 = energia_ligada;
                quarto3 = energia_ligada;
                quarto4 = energia_ligada;
            }break;
                case 5:
            if(opcao = 5){
                quarto2 = energia_desligada;
            }else{
                cozinha = energia_ligada;
                banheiro = energia_ligada;
                quarto1 = energia_ligada;
                sala_de_visita = energia_ligada;
                quarto3 = energia_ligada;
                quarto4 = energia_ligada;
            }break;
                case 6:
            if(opcao = 6){
                quarto3 = energia_desligada;
            }else{
                cozinha = energia_ligada;
                banheiro = energia_ligada;
                quarto1 = energia_ligada;
                quarto2 = energia_ligada;
                sala_de_visita = energia_ligada;
                quarto4 = energia_ligada;
            }break;
                case 7:
            if(opcao = 7){
                quarto4 = energia_desligada;
            }else{
                cozinha = energia_ligada;
                banheiro = energia_ligada;
                quarto1 = energia_ligada;
                quarto2 = energia_ligada;
                quarto3 = energia_ligada;
                sala_de_visita = energia_ligada;
            }break;
    }break;
  }
}

Compartilhar este post


Link para o post
Compartilhar em outros sites

1º Não use o tag de c++ se você está programando em C. você só consegue fazer as pessoas perderem tempo entrando e pensando que você quer em c++ quando na real é em C.
2º Antes de postar um código passe por aqui:


3º Existe muitas formas de se fazer isso. Podemos por exemplo considerar o uso de uma matriz em vez de estruturas. Para você fazer uma ideia:
 

#include <stdio.h>

#define NDIAS 7     //numero de dias que tem uma semana
#define NCOMODOS 6 //numero de comodos que tem a casa

#define DESLIGADO 0
#define LIGADO 1
#define OCUPADO 2
#define CHOVENDO -1

enum {DOMINGO, SEGUNDA, TERCA, QUARTA, QUINTA, SEXTA, sábado};    //DOMINGO=0, SEGUNDA=1, TERCA=2, QUARTA=3, QUINTA=4, SEXTA=5, sábado=6
enum {COZINHA, BANHEIRO, SALA, DORMITORIO1, DORMITORIO2, JARDIM}; //COZINHA=0, BANHEIRO=1, SALA=2, DORMITORIO1=3, DORMITORIO2=4, JARDIM=5
char dia[NDIAS][10]={{"Domingo"}, {"Segunda"}, {"Terça"}, {"Quarta"}, {"Quinta"}, {"Sexta"}, {"sábado"}};
char comodo[NCOMODOS][20]={{"Cozinha"}, {"Banheiro"}, {"Sala"}, {"Dormitorio 1"}, {"Dormitorio 2"}, {"Jardim"}};

int main(){
    int d, c; //d de dia e c de comodo. São contadores para os indices do for

    //Matriz que registrará a informação das luzes da casa.
    int data[7][6] = {
        {0, 0, 0, 0, 0, 0}, //domingo
        {0, 0, 0, 0, 0, 0}, //segunda
        {0, 0, 0, 0, 0, 0}, //terça
        {0, 0, 0, 0, 0, 0}, //quarta
        {0, 0, 0, 0, 0, 0}, //quinta
        {0, 0, 0, 0, 0, 0}, //sexta
        {0, 0, 0, 0, 0, 0}  //sábado
    };

    //Modificando a mão o dia de domingo
    data[DOMINGO][COZINHA    ] = LIGADO;
    data[DOMINGO][BANHEIRO   ] = LIGADO;
    data[DOMINGO][SALA       ] = LIGADO;
    data[DOMINGO][DORMITORIO1] = DESLIGADO;
    data[DOMINGO][DORMITORIO2] = LIGADO;
    data[DOMINGO][JARDIM     ] = LIGADO;

    //Imprimir
    for(d = 0; d<NDIAS; d++){
        printf("%s\n======================\n", dia[d]);
        for(c = 0; c<NCOMODOS; c++){
            printf("%-12s %s\n", comodo[c], ((data[d][c]== 0)? "DESLIGADA":"LIGADA") );
        }
        putchar('\n');
    }

    return 0;
}

 

adicionado 2 minutos depois

você só precisa fazer um menuzinho com as opções para editar essa matriz.

 

  • Curtir 2

Compartilhar este post


Link para o post
Compartilhar em outros sites
#include <iostream>             // std::cout, std::cin
#include <Windows.h>            // Sleep
#include <string>               // std::string
#include <map>                  // std::map
#include <list>                 // std::list
#include <locale>               // setlocale
#include <algorithm>            // std::find

enum Dias
{
    Segunda = 1,
    Terca,
    Quarta,
    Quinta,
    Sexta,
    sábado,
    Domingo
};

std::map<std::string, bool> comodoEnergia;

/// <summary>
/// Pega o dia da semana conforme o valor passado no argumento da funcao
/// </summary>
/// <param name="dia">
/// Codigo do dia da semana, comecando do zero, para ver o codigo equivalente de cada dia olhe na enum "Dias"
/// </param>
/// <returns>
/// Retorna o nome do dia da semana
/// </returns>
std::string pegarNomeDoDia(int dia)
{
    switch (dia)
    {
    case Segunda:               return "Segunda feira";
    case Terca:                 return "Terça feira";
    case Quarta:                return "Quarta feira";
    case Quinta:                return "Quinta feira";
    case Sexta:                 return "Sexta feira";
    case sábado:                return "Sábado";
    case Domingo:               return "Domingo";
    default:                    return "Dia informado é invalido";
    }
}

/// <summary>
/// Verifica se o dia passado no argumento "idDia" existe na lista que foi passada no argumento "l"
/// </summary>
/// <param name="l">
/// Lista para verificar se existe
/// </param>
/// <param name="idDia">
/// Código do dia para verificar, para ver o código dos dias veja na enum "Dias" 
/// </param>
/// <returns>
/// Retorna true se já foi usado ou false caso nao foi usado ainda
/// </returns>
bool diaJaFoiUsado(std::list<int>& l, int idDia)
{
    for (std::list<int>::iterator it = l.begin(); it != l.end(); ++it)
    {
        std::cout << "It: " << *it << std::endl;
        if (*it == idDia)
            return true;
    }
    return false;
}

/// <summary>
/// Verifica se a lista "l" que foi passada no argumento possui todos os dias da semana
/// </summary>
/// <param name="l">
/// Lista para verificar se existe
/// </param>
/// <returns>
/// Retorna true se a lista "l" possui todos os dias da semana ou false caso contrario
/// </returns>
bool todosOsDiasForamUsados(std::list<int>& l)
{
    for (int dias = 1; dias <= 7; dias++)
    {
        std::list<int>::iterator existIterator = std::find(l.begin(), l.end(), dias);

        if (existIterator == l.end())
            return false;
    }
    return true;
}

/// <summary>
/// Verifica se o dia que foi passado pelo argumento "dia" do usuario é válido para evitar problemas no código
/// </summary>
/// <param name="dia">
/// Código do dia para verificar se é válido, veja o código do dia na enum "Dias"
/// </param>
/// <returns>
/// Retorna true se o dia que foi passado pelo usuario é valido ou false caso contrario
/// </returns>
bool diaPassadoEhValido(int dia)
{
    return (dia >= 1 && dia <= 7);
}

/// <summary>
/// Mostra as informações do comodo atraves do nome
/// </summary>
/// <param name="nome">
/// Nome do comodo para mostrar as informações
/// </param>
void mostraComodo(std::string nome)
{
    std::cout << "Comodo: " << nome << std::endl;
    std::cout << "Energia ligada: " << comodoEnergia[nome] << std::endl;
}

int main()
{
    setlocale(LC_ALL, "Portuguese");

    int dia = 0;
    std::list<int> diasUsados;
    
    while (true)
    {
        system("cls");
        
        // Loop onde vai escrever os dias da semana na tela
        for (int i = 1; i <= 7; i++)
            std::cout << i << "." << pegarNomeDoDia(i) << std::endl;

        std::cout << "Informe o dia da semana: ";
        
        // Pega o dia
        std::cin >> dia;

        // Verifica se o dia que foi passado pelo usuario é valido
        if (!diaPassadoEhValido(dia))
        {
            std::cout << "O dia que você informou não existe, retornando para o inicio." << std::endl;

            // Pausa de 2 segundos para o usuário ler antes de voltar para o inicio do loop
            Sleep(2000);

            // Quebra o loop atual, voltando para o inicio do loop
            continue;
        }

        // Verifica se todos os dias já foram usados, se for, reseta a lista
        if (todosOsDiasForamUsados(diasUsados))
        {
            std::cout << "Todos os dias foram usados, resetando a lista de dias usados.\n";
            diasUsados.clear();
        }

        // Verifica se o dia foi usado, se nao foi usado, adiciona na lista e volta para o inicio do loop
        if (diaJaFoiUsado(diasUsados, dia))
        {
            diasUsados.push_back(dia);
            continue;
        }

        switch (dia)
        {
        case Segunda: // Se o dia da semana for segunda desliga a energia do Jardim
            comodoEnergia["Jardim"] = false;

            comodoEnergia["Quarto 1"] = true;
            comodoEnergia["Quarto 2"] = true;
            comodoEnergia["Quarto 3"] = true;
            comodoEnergia["Quarto 4"] = true;
            comodoEnergia["Sala de visita"] = true;
            comodoEnergia["Cozinha"] = true;
            comodoEnergia["Banheiro"] = true;
            break;
        case Terca: // Se o dia da semana for terca desliga a energia da sala de visita
            comodoEnergia["Sala de visita"] = false;

            comodoEnergia["Quarto 1"] = true;
            comodoEnergia["Quarto 2"] = true;
            comodoEnergia["Quarto 3"] = true;
            comodoEnergia["Quarto 4"] = true;
            comodoEnergia["Jardim"] = true;
            comodoEnergia["Cozinha"] = true;
            comodoEnergia["Banheiro"] = true;
            break;
        case Quarta: // Se o dia da semana for quarta desliga a energia da sala da cozinha
            comodoEnergia["Cozinha"] = false;

            comodoEnergia["Quarto 1"] = true;
            comodoEnergia["Quarto 2"] = true;
            comodoEnergia["Quarto 3"] = true;
            comodoEnergia["Quarto 4"] = true;
            comodoEnergia["Sala de visita"] = true;
            comodoEnergia["Jardim"] = true;
        
            comodoEnergia["Banheiro"] = true;
            break;
        case Quinta:
            comodoEnergia["Banheiro"] = false;

            comodoEnergia["Quarto 1"] = true;
            comodoEnergia["Quarto 2"] = true;
            comodoEnergia["Quarto 3"] = true;
            comodoEnergia["Quarto 4"] = true;
            comodoEnergia["Sala de visita"] = true;
            comodoEnergia["Jardim"] = true;
            comodoEnergia["Cozinha"] = true;
            break;
        case Domingo: // Se o dia da semana for domingo desliga a energia de todos os quartos
            comodoEnergia["Quarto 1"] = false;
            comodoEnergia["Quarto 2"] = false;
            comodoEnergia["Quarto 3"] = false;
            comodoEnergia["Quarto 4"] = false;

            comodoEnergia["Jardim"] = true;
            comodoEnergia["Sala de visita"] = true;
            comodoEnergia["Cozinha"] = true;
            comodoEnergia["Banheiro"] = true;
            break;
        }

        // Mostra as informações de todos os comodos
        mostraComodo("Quarto 1");
        mostraComodo("Quarto 2");
        mostraComodo("Quarto 3");
        mostraComodo("Quarto 4");
        mostraComodo("Jardim");
        mostraComodo("Sala de visita");
        mostraComodo("Cozinha");
        mostraComodo("Banheiro");

        // Faz um pause 4.5 segundos para o usuário ler as informações
        Sleep(4500);
    }
    return 0;
}

 

Já tinha feito algo parecido, apenas mudei algumas coisas.

 

Não sei se é em C++ que você quer, talvez até seja pelo fato de muita gente usar funções do C mesmo em C++.

 

Sei que o código tá um pouco complexo para quem é iniciante, então qualquer duvida diga a onde que eu respondo.

  • Amei 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Olá todo!

Tudo está ligado, desligado. Apenas variações de 0-1.

Deu-me uma insight: Inicialmente  com penas uma variável é possível representar toda casa porque o tipo int tem 32 zeros ou 32 uns. Só precisa operar cada um deles, seja com operadores Bitwise, ou com Struct Fields. Na media com a mesma lógica apresentada por @cyer @vangodp @edgargoncalveslimajr diminuiríamos tanto em código, velocidade e espaço na memória  de tal forma que apenas unsigned int[ 100000 ] representaria o statos de todas as casas na cidade onde moro.

  struct casa{
        
        int energia_ligada: 1;
        int energia_desligada: 1;
        
        int jardim: 1;
        
        int sala_de_visita: 1;
        int cozinha: 1;
        int banheiro: 1;
        int quarto1: 1;
        int quarto2: 1;
        int quarto3: 1;
        int quarto4: 1;
};

Mais legal é que para desligar tudo basta fazer:

casa = 0;

e para ligar tudo basta fazer algo como:

casa = 0b1111111111

Minha intromissão foi só pra isso mesmo.

 

Quero ver esse código e bem levinho.

Vou fazer aqui, e a medida que for elaborando ousarei posta-lo.

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@Mauro Britivaldocredito nao que consegue simplificar tanto o programa. Eu já tava super satisfeito com a resposta do cyer haha

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@santos container Teoricamente é possível, assim já disse toda BASE é feita 0s e 1s.

Editado:

Como pode ver a lógica é a mesma, porém mais leve!

Precisou de apenas 1 tipo char de 1 byte para Representar 1 casa.

Citação

/*  Programa:
    Escrito por: Mauro Britivaldo
    Data da Criação: 16/03/2018.

    Propósito: Ilustração para Fórum C/C++ CdHardware
    */


#include <stdio.h>  // Incluir as rotinas que fazem Entra e Saída (E/S).
#include <stdlib.h> // Incluir as rotinas que fazem uso da memória.
#define OFF 0
#define ON 255;

/// IMPRIMIR NA TELA DO PROMPT UM MENSAGEM
unsigned int DisplayStrings (char *MeuTexto) {
   unsigned int CountChar = 0; //< Variável escanea o ponteiro em busca do caractere '\0'
   char ch; //< Buffer de Entrada para função putchar que impremirá no prompt valor de ch.

   while (ch = *(MeuTexto+(CountChar))) { putchar (ch), ++CountChar; }
   return CountChar;
   }
/// LIGAR AS LUZES, FUNÇÃO PRINCIPAL VEJAMOS COMO OPERAÇÃO Bit a Bit é fodinha rsrs
void LigarLuzNo (unsigned int IndexComodo, char* MeuLar) {
   *MeuLar = *MeuLar | 1 <<--IndexComodo;
   return;
   }
/// EXIBIR OS STATUS DA RESIDENCIA PARA CADA COMODO.
void DisplayHomeStatus (unsigned int IndexComodo, char MeuLar) {
   //< Aqui usamos os operadores Bitwise, porém é optativo poderia ser SWITCH.
   if (MeuLar & 1 <<--IndexComodo) DisplayStrings ("LIGADO!");
   else DisplayStrings ("DESLIGADO.");
   return;
   }

int main (void) {
   unsigned char MeuLar = OFF,   //< Todas as Luzes DESLIGADAS.
  *NomesDosComodos[ 9 ] = {    "Comodos da Casa",
                               "Jardim",
                               "Sala de Visitas",
                               "Cozinhas",
                               "Banheiro",
                               "Quarto 1",
                               "Quarto 2",
                               "Quarto 3",
                               "Quarto 4"
                               };

   DisplayStrings ("ONDE QUERES LIGAR A LUZ? ");
   int comodo = getchar ();
   if ((('1' - 1) < comodo && comodo < ('8' + 1))) {
      comodo = comodo - '0';
      LigarLuzNo (comodo, &MeuLar);
      DisplayStrings(NomesDosComodos[comodo]), DisplayStrings (" - "),
      DisplayHomeStatus(comodo, MeuLar), DisplayStrings ("\n");
      } else { DisplayStrings ("TODA AS LUZES LIGADAS\n"), MeuLar = ON; }
   DisplayStrings("================= STATUS ===============\n");
   comodo = 1;
   while (9 > comodo) {
      DisplayStrings(NomesDosComodos[comodo]),
      DisplayStrings (" "),
      DisplayHomeStatus(comodo, MeuLar),
      DisplayStrings("\n");
      ++comodo;
      }
   DisplayStrings("================== DONE ================\n");
   return 0;
   }

 

Ficou mais leve :thumbsup:

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×