Ansi C

x é desnecessário porque o parâmetro é n. A impressão acontece somente fora e não dentro-e-fora do escopo da função verifica. Um retorno acontece de duas maneiras: parâmetro de saída ou fim de escopo. No caso de fim de escopo fica assim: #include <stdio.h> #include <string.h> char * verif(int n){ static char y [8] = {'\000'}; switch (n){ case 1:strcpy( y, "Domingo"); break; case 2:strcpy( y, "Segunda"); break; case 3:strcpy( y, "Terça"); break; case 4:strcpy( y, "Quarta"); break; case 5:strcpy( y, "Quinta"); break; case 6:strcpy( y, "Sexta"); break; case 7:strcpy( y, "sábado"); break; default: y [0] = '\000'; } return y; } int main(void){ int n; printf("De 1 a 7, digite semana que você deseja ver: "); scanf ("%d", &n); printf("Dia da semana: %s", verif(n)); return 0; }

Interpretação é que cada dígito que compõe a senha é também as fases da tranca. Em código, as fases são simuladas pela comparação direta de tipos primitivos (a, b). Assim pensamos que a soma das fases é a validação da senha por meio de um bloco SE-SENAO. SE senha == sequência ENTAO "Porta Aberta" SENAO "Sequência Incorreta"

Imprecisão: Fração Decimal --> Binário Por conta da imprecisão ao representar frações de décimos em binários; conclui-se, por exemplo, que 0.01 é representado não exatamente 1/100; E a propagação dessa imprecisão aumenta na medida das operações ou que no final o valor 0.01 restante na variável é ≅ 0.0099...d

Declaro-se variável na expressão booleana bem aqui. Não Pode, é errado. Essa expressão correta no caso é ... if (1 == prod) Corrija onde houver e teste novamente. Boa Sorte.

As funções de entrada e saída padrão também são uteis quando a interpretação é string. Lê com scanf e: printf ("%s\n%s\n%s\n%s", str1, str2, str3, str4); /* Imprima as 4 linhas de inteiros do problema com printf */

Pense como uma criancinha @herbertbahia @_Pedro_1002_ Mesma lógica nos macros. #define _MAIOR(A1, A2) (((A1) > (A2)) ? (A1) : (A2)) #define _MENOR(A1, A2) (((A1) < (A2)) ? (A1) : (A2)) #define SELECIONE(FUNC, A1, A2, A3) (FUNC(FUNC(A1, A2), A3)) __typeof__(int) maior = SELECIONE(_MAIOR, 3, 2, 1), menor = SELECIONE(_MENOR, 3, 2, 1), medio = ((3 + 2 + 1) - (maior + menor)); printf ("%d %d %d \n", menor, medio, maior); printf ("%d %d %d \n", maior, medio, menor); Boa Sorte!

Termina com (char) e mais nada. "Houve um equivoco", regra nas especificações que não pode envolver número flutuante em mod (%). Não pode terminar em (float), e a regra do mod aplica-se também ao operador de binário. Parei!

PRINTF A essa altura entende que especificador correto inicia com 0, assim: "%03d\n" E a última linha nos arquivos de saída é impressa com dois e não 3 dígitos, e sem o caractere de nova linha porque uma linha nula também conta e exame diz; "no máximo é 4 por arquivo". PS.: Tratando-se de URI e outras plataformas, o como resolve é importante para colocação no rank, entretanto quando se fala de exames de curso o como se resolve está restrito e vinculado ao apresentado em sala.

Dos 5 números inseridos "sobrevive" 4. Acredito que é um exame básico de Vetores em C. Onde se Avalia acesso e classificação de valores em variáveis indexáveis. Preencha-se, tipicamente, o vetor de 4 elementos. Aplique uma classificação qualquer de modo que no final entendamos onde localizar o menor de todos valores por decisão. No final compare esse valor com a última entrada: Se menor que a última entrada então troque.

@marvelous12 Um Problema encontrei no método Eu acho que precisa para de pensar em uma solução aplicada para casos gerais e foca no que é aparentemente o solicitado: um caso especifico em que a saída é aos pares um abaixo do outro. (Se errei então ignore) Identifique o que é mutável e o que é imutável, pois existem de caso especifico e ajuda amortizando o número de operações aritmética exigidas, o que é bem util. Com uso de matrizes amortizamos um pouco a aritmética de ponteiros, no exemplo usei um vetor mesmo, mas pode ser notação de matrizes. Então dado ... __typeof__(char []) matriz = { "|-----------------------------||-----------------------------|\n" "|MES 1 ||MES 2 |\n" "|-----------------------------||-----------------------------|\n" "| dom seg ter qua qui sex sab || dom seg ter qua qui sex sab |\n" "| -- -- -- -- -- -- -- || -- -- -- -- -- -- -- |\n" "| -- -- -- -- -- -- -- || -- -- -- -- -- -- -- |\n" "| -- -- -- -- -- -- -- || -- -- -- -- -- -- -- |\n" "| -- -- -- -- -- -- -- || -- -- -- -- -- -- -- |\n" "| -- -- -- -- -- -- -- || -- -- -- -- -- -- -- |\n" "| -- -- -- -- -- -- -- || -- -- -- -- -- -- -- |\n" }; printf ("%s", matriz); /* ^ Imprimir string 'matriz' na saida padrão */ Identificam matriz uma variável de tipo (char [10 * 63 + 1]) ou 631 caractere(s). E como o último caractere é '\000' dizem também que em C matriz se define de tipo string. Certos que de nada adianta imprimir 'MES 1' é preciso altera essa string. Pra tanto declaro a sub-string: mes_1, porém é preciso antes defini-la, então digamos que a matriz tem 10 linhas e 63 colunas assim tal qual um plano no R2. Disso As coordenadas (2, 2), que em aritmética de ponteiros equivale à [(2 - 1) * 63 + (2 - 1)], inicia a minha sub-string mes_1 no caractere 'M'. Logo declaramos o apontador: mes_1 assim: #define X 2 #define Y 2 __typeof__(char *) mes_1 = (matriz + ((Y) - 1) * 0x3F + ((X) - 1)); Note: A distância de 'M', pertencente a 'MES 1', e 'M' de 'MES 2' equivale à 31 caracteres. Disso definimos o apontador: mes_2 #define X 2 #define Y 2 __typeof__(char *) mes_1 = (matriz + ((Y) - 1) * 0x3F + ((X) - 1) + 0x00); __typeof__(char *) mes_2 = (matriz + ((Y) - 1) * 0x3F + ((X) - 1) + 0x1F); Agora antes de imprimir os dois meses escrevemos seus nomes assim: (void) (mes_1 [sprintf (mes_1, "%-28s", "Janeiro")] = ' '); (void) (mes_2 [sprintf (mes_2, "%-28s", "Fevereiro")] = ' '); printf ("%s", matriz); /* ^ Imprimir string 'matriz' na saida padrão */ Para mais informações: sprintf Outros últimos valores mutáveis são as 42 sub-strings: defina todas, use opcionalmente a mesma lógica matemática que apresentei para os dois nomes (mes_1 e _2) e com isso reduza pela metade o número de operações aritmética na solução em discussão. -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- Boa Sorte!

Quando consulto listas on-line as duas são próximas, igualmente utilizadas e tenho razões pessoais que me lavam acreditar que não é verdade, pois C é mais usada que C++ principalmente porque os maus programadores preferem C++ e tem 50% do código escrito em C. Aprenda as duas porque são orientações diferentes, e você só tem a ganhar com isso.

@Miranda_a O jogo instalou corretamente? Por padrão a aplicação, que no caso é um game, solicita permissão de instalação e downloads adicionais antes que complete sua instalação ou pouco tempo depois que começa. Se completou todas as etapas da instalação corretamente sem erros é porque tem os pacotes certos e não há mais nada.

Matriz Painel Gostou da recomendação do colega @devair1010, então aplique numa matriz; Tem-se uma matriz que substitui a área prompt e sua função de posicionamento gotoxy se posiciona respectivamente nessas coordenadas dessa matriz. Logo, XY é respectivamente Coluna e Linha dessa matriz. Depois que 'desenha' ao menos um par de meses coloque a matriz num loop (0 à 10) para imprimir no Prompt de Comando ou qualquer outra saída; Um estrutura para modela matriz: char matriz [10][64] = { "|-----------------------------||-----------------------------|\n", "|_____________________________||_____________________________|\n", "|-----------------------------||-----------------------------|\n", "| dom seg ter qua qui sex sab || dom seg ter qua qui sex sab |\n", "| -- -- -- -- -- -- -- || -- -- -- -- -- -- -- |\n", "| -- -- -- -- -- -- -- || -- -- -- -- -- -- -- |\n", "| -- -- -- -- -- -- -- || -- -- -- -- -- -- -- |\n", "| -- -- -- -- -- -- -- || -- -- -- -- -- -- -- |\n", "| -- -- -- -- -- -- -- || -- -- -- -- -- -- -- |\n", "| -- -- -- -- -- -- -- || -- -- -- -- -- -- -- |\n", }; Atenção: Receberá alertas com relação a sintaxe de inicialização se tem compilador desatualizado.

Desentendimento de Codificação O GCC é um compilador inteligente, identifica a codificação do arquivo fonte (.c; .txt) e por padrão codifica igualmente a saída do programa. Daí suponho que os arquivos gerados no 'Dev' tem a mesma codificação atual que o cmd.exe e o sublime text 3 parece que ainda não. Experimentei inconsistência semelhante com notepad++ que suporta gravar arquivos fontes em várias codificações incluindo a 850 que é a mesma usada no nosso Prompt de Comando. Faz alguns anos que notepad++ suporta gravar em codificação OEM 850, verifique se também o sublime text permite essas mudanças na configuração.

@arfneto Desculpa cara, mas não tenho paciência ... Agradeço sua explicação, mas ele é inútil para mim, então se quiser dizer alguma coisa inutilmente fale mais sem me citar por favor.

Achou errado, porque não ficou ao menos pra uma pessoa. adicionado 0 minutos depois Obrigado!

Matrizes ou Variável Indexada Matrizes é tipo de estrutura somente lógica, sua notação na linguagem remete as tabelas como um resumo da representação física de tabelas na matemática. Todavia, na memória são codificações de uma coleção de elementos linearmente dispostos ou bytes numa sequência contígua a partir do nome, por isso chamam de variável indexada. Melhor: em duas 2x3 porque duas 3x3 não pode não ou vai além da capacidade da primeira que é de 12 elementos. * Falta detalhes na sua pergunta porque fracionar significa dividir, porém não tenho certeza se que fracionar a matriz propriamente dita ou se apenas copiar a matade dos elementos para duas outras.

Ponteiro e Identificador de Matrizes Agradou-me bastante essa sua função @Midori, note mais tarde @Malcolm X que apontadores e nomes de matrizes tem operação de notação intercambiável, ou seja, o que tem num tem no outro e se existe uma diferença que precisa ser ressaltada é na declaração; onde no caso das matrizes existe memória associada de imediato. /*---[ Declaração de Variavéis ]----*/ char str [25]; //_ Aqui tem memória char *str; //_ Aqui ~tem memória # Uma solução ... Apontador com Notação de Vetores + 'top-down' /*============================================================[ COMPARE ]=*/ int str_compare (const char *s1, const char *s2){ unsigned int index = -0x1; do { ++ index; if ((s1 [index]) - (s2 [index])){ if (s1 [index] > s2 [index]) return 2; /*_s2 é menor */ else return 1; /*_s1 é menor */ } } while ((s2 [index]) != '\000'); return 0; /*_ são iguais */ } /*-----[ FIM_COMPARE ]----------------------------------------------------*/ O ponteiro é subestimado por quase todo mundo, mas é interessante, útil e fácil depois de um tempo. ~~

Vai porque esse é o padrão mesmo; Letra por Letra As exceções são abstrações do padrão, por exemplo; uma implementação que fez alinhamento com tipo int compara não 1 simples char (nome para 1 byte ou uma letra), bem precisamente falando da arquitetura 32 bits, compara 4 por 4 bytes ou uma palavra por ciclo. Contudo, como já disse de início a lógica ainda é a mesma . Sim e muito bem colocado; a única peculiaridade é que essa string, que é um vetor e por padrão do tipo char, termina sempre-sempre com o caractere nulo '\0' e seus outros elementos são codificações geralmente usadas para representar palavras nos programas. Qualquer definição diferente dessa é uma abstração ou sinônimo da intepretação padrão igual à essa. Foram boas perguntas; A Melhor Ficou por Último A forma bruto ou também para mim uma comparação com tipos de dados padrão ou primitivos é possível porque a arquitetura no processador e as especificações do idioma permite, da maneira primitiva (ou bruta), realizar de pouco código a comparação de primitivos; uma operação lógica com blocos\estrutura de bytes pré-fixados pela própria arquitetura chamados de variáveis; É natural imaginar que dentro do processador, quando comparado tipos de dados brutos (char, int, float ...), aconteça também um loop byte a byte ou bit a bit; Os engenheiros da Intel, por exemplo, é um grupo de pessoas que conhece profundamente o que acontece e como eletronicamente acontece as operações de lógica com tipos primitivos na CPU e podemos destemidamente afirma que a função strcmp; compara byte por byte ou letra por letra e é esse motivo de existir um limitador da string e para as funções que manipulam strings: O caractere nulo '\0'. Por último; é exatamente isso que pede o seu exercício; A tua versão da strcmp que compara letra a letra.

C Strings ? Em C, string não é um tipo de dado padrão tal qual é int, float e char. Mas sim uma coleção de tipos char, quase sempre, um tipo matriz de char ou uma sequencia de bytes contíguos terminando com valor '\0'. Na comparação de strings, compara-se os seus elementos, ou seja, os caracteres em cada índice percorrendo as strings com um loop até o limite delas.

Opções de Alerta Compiladores emitem alertas para os casos ambíguos e não; ambíguos porque declaração nula é uma das especificações da linguagem e do Idioma C'18, significa dizer que não é um erro, entretanto não será ignorado. O GCC, um dos mais importantes quiçá o melhor compilador porque é livre e atualizado, tem duas importantes opções. -Wall -Wextra que usamos p.ex.: gcc -std=c18 -Wall -Wextra draft.c No Caso Inteligentemente define que (;) é talvez engano porque vem uma declaração nula seguida de um bloco anônimo com indentação. Logo fica fácil presumir que possivelmente um pertence ao outro. Veja um alerta de código semelhante #include <stdio.h> int main(void){ for (unsigned int index = 0; index < 10; ++ index); { printf ("Oh! Que inteligente !!!"); } return 0; } GCC

O IDE é requisito para aprendizagem C Sou ridículo se pensar ou vincular tamanha besteira. Não importa sua instituição, mesmo no IMT, provavelmente ninguém sofre com uso de um misero bloco de notas enquanto aprende os fundamentos de programação com linguagem C, pelo contrário, se aprofunda do contexto. Evitar !? Se acha que isso é um problema que precisa de escapatória se enganou porque é assim as especificações da linguagem e o VS também não tem nada a ver com isso; Siga as recomendações de formatação e/ou ainda mais faça de uma hábito consultar neste link para mais informações: http://www.cplusplus.com/reference/cstdio/printf/

Se faz questão disso podemos verificar; a necessidade de um teste de diferença negativa acontece para correção nos casos em que um ciclo de hora não foi concluído. Nesse exemplo: 5 3 5 2, isso ocorre e se considera apenas para efeito de teste resultado 24 horas, tem-se a entrada: 5 0 5 0 porque desconsidera os minutos 3 e 2. Entretanto, quando os minutos são calculados a diferença é -1 entendendo que o ciclo de 1 hora (60 min) não é completo na última hora das 24. Na aritmética do Ensino Básico, eu digo: Você tem que pegar 10 emprestado. Semelhante à: 12(-1)2 -3 = 119 Disso talvez, tira-se ideia de que preciso determinar antes o sinal dos minutos para calcula na hora final quando necessário, ou seja; ciclo de horas incompleto. Com isso, primeiro trabalhe com o sinal da diferença dos minutos. #include <iostream> using namespace std; int main(){ int hi, hf, mi, mf, tempo_hora, tempo_minuto; cin >> hi >> mi >> hf >> mf; tempo_hora = hf - hi; tempo_minuto = mf - mi; if(tempo_minuto < 0){ tempo_minuto += 60; tempo_hora --; } if(tempo_hora < 0){ tempo_hora += 24; } if(hi == hf && mi == mf){ cout << "O JOGO DUROU 24 HORA(S) E 0 MINUTO(S)\n"; } else{ cout << "O JOGO DUROU " << tempo_hora << " HORA(S) E " << tempo_minuto << " MINUTO(S)\n"; } } Passo no teste: 5 3 5 2;

No caso mais simples use: getline http://www.cplusplus.com/reference/istream/istream/getline/

Simplesmente porque 'tempo_hora' recebe da expressão valor 0 O código é pequeno então vamos depurar. Para isso use a imaginação com esquema que acha melhor. Seguimos o programa passo a passo igual aos acontecimentos em uma processo. Veja t'horas < 0: Entrada$ 5 3 5 2 T'Horas: (5 - 5); T'Minutos: (2 - 3); SE (0) < 0 T'Horas: (24); SE (-1) < 0 T'Minutos: (59), T'Horas:-1; SE ((5) == (5)) E ((3) == (2)) EXIBIR "O JOGO DUROU 24 HORA(S) E 0 MINUTO(S)\n"; SENAO EXIBIR "O JOGO DUROU " (-1) " HORA(S) E " (59) " MINUTO(S)\n"; e se a expressão lógica é para caso em que t'horas é <= 0 Veja t'horas <= 0: Entrada$ 5 3 5 2 T'Horas: (5 - 5); T'Minutos: (2 - 3); SE (0) <= 0 T'Horas: (24); SE (-1) < 0 T'Minutos: (59), T'Horas: 23; SE ((5) == (5)) E ((3) == (2)) EXIBIR "O JOGO DUROU 24 HORA(S) E 0 MINUTO(S)\n"; SENAO EXIBIR "O JOGO DUROU " (23) " HORA(S) E " (59) " MINUTO(S)\n";