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

edgargoncalveslimajr · 14 de março de 2018

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;
}
}

cyer · 14 de março de 2018

#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.

Ansi C · 14 de março de 2018

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 e 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.

TomJohn · 14 de março de 2018

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

Ansi C · 16 de março de 2018

@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;
   }