britivaldo

Olá Primeiro seria bom uma Descrição do seu programa, o que faz ou que deveria fazer.

Nossa, não faz sentido nenhum.

Não entendi, seu professor disse que o processo para e é mais lento que gravar e depois aplicar uma ordenação. Por conta do IF Else ser mais lento e você notou um acréscimo de 3x. Então depende de como está sendo feito esse teste, eu aqui fiz assim porque penso que assim deve ser: int main() { clock_t begin = clock(); vector <int> contri; int N = 10000000; for(int i = 0; i < N; ++i) { contri.push_back(i); } stable_sort(contri.begin(), contri.end(), less<int>()); cout << contri[N-1] << endl; cout << contri[N-2] << endl; cout << contri[N-3] << endl; clock_t end = clock(); double time_spent = (double)(end - begin) / CLOCKS_PER_SEC; cout << "Time taken to process : " << time_spent << endl; return 0; } O tempo: ~8.275 segundos. O algoritmo que proponho, faz em: ~0.1 segundos. Discordo!

Olá, tudo bem? Então, você está armazenado todos os N-valores, quando na verdade se quer apenas 3 dos N. Logo a medida que os valores vão entrando você já vai colocando eles em 3 variáveis, e selecionado sempre o maior valor s depois transferindo para as outras sempre que encontras um maior ainda. Por exemplo: x E [1, 2, 3, 4, 5, 6] Se x > c então c = x, b = c, a = b, se não então x E [1, 2, 3, 4, 5, 6] Se x > b então b = x, a = b, se não então x E [1, 2, 3, 4, 5, 6] Se x > a então a = x. No fim imprima: a, b , c. Entendeu como é mais simples que isso que você fez. O.k. !? Tchau.

Olá, tudo bem? Então, observe que humanamente falamos 'e' quando sabemos previamente que a grandeza continua em sua ordem decrescente de grandeza sempre omitindo o 'e' quando a unidade é zero. Por exemplo: 424 -- Quatrocentos e vinte e quatro. 404 -- Quatrocentos e 4. <--[ ! ] Omitindo nas dezenas 10. 400 -- Quatrocentos. <--[ ! ] Omitindo nas dezenas 10 e nas unidades 0. Ou seja, quando as unidades decimais, de qualquer ordem tem valor 0, não nos pronunciamos com 'e'. O.K. !? Tchau.

Olá, tudo bem? Então, basta apenas armazenas as respectivas partes do tempo em 3 variáveis do tipo int. Depois que capturar a entrada da hora converta tudo em segundo e atribua a 4 variável, também do tipo int, por último exibir. É um problema bem básico. OK!? Tchau.

resposta a pergunta. string1 += j Ok!? Tchau.

Olá, tudo bem? Então, o erro é aqui: int j; j = *tamanho1; for (string1 + j; (*tamanho1) != (j + (*tamanho2)); *tamanho1 ++) { *string1 = *string2; string2 ++; string1 ++; } A parte em vermelho não faz sentido, pois a operação não teve efeito nenhum na variável string1. Você precisa fazer com que a variável seja igual a soma. Ok!? Tchau.

Olá, tudo bem? O valor 1 digitado no começo do programa não é testado dentro do laço while. Apenas os próximos valores que são solicitados pelo scanf dentro do laço serão avaliados / testados. Ok!? Tchau.

Quanto Se a matriz[TAM][TAM] seus índices são -1< (i,j) < TAM. j = rand () % TAM; ✓

Obrigatoriamente todo aplicação deve ter a função int main()

Na verdade você meio que já está, com pequenas diferenças. Por exemplo, eu escrevo: std::cout <<("Digite o valor A: "); você escreve: cout << "Digite o valor A: "; São dois comandos sinônimos porque fazem a mesma coisa no programa. Com relação ao seu problema, já que não respondeu a si mesmo. Eu respondo! Isso acontece porque você esta calculando a raiz de delta negativo. E NaN[ not a number] que dizer; não é um número. tente usar a função sqrt(-9), vai obter NaN. Obrigado, comecei a alguma tempo já.

Observem esse código que está funcionando para raízes reais bhaskara c++: /** * * programa C++ C --- Resolução de Polinômios do 2 Grau Cpp (Bhaskara) * * enconding: OEM 860, compiler: MinGW GCC-6.3.0-1 32 bits * * editor: Notepad++ 7.5.7 32 bits - 2018, OS: win7 64 bits * * file: bhaskara.c ver: 1.0.0 */ /* INCLUSOES */ #include <iostream> #include <cmath> /* DEFINICOES */ /* FUNCOES */ /* main ---função principal do programa */ int main(void) { /* TIPOS LOCAIS */ /// Coeficiente de uma Função do Tipo Quadrática float coefa = 0.f, // Coeficiente ângular / forma da parábola coefb = 0.f, // Coeficiente secante ao eixo das coordenadas coefc = 0.f, // Coeficiente do termo independente delta = 0.f, // Delta da fórmula canônica b²-4.a.c x1, x2= 0.f; // Raizes reais da função bool haraiz= true; // Há raiz real somente se delta é não negativo /* ENTRADA DE DADOS */ std::cout <<("Por favor entre com os valores para os coeficientes a, b, c." "\nRespectivamente e separados por espaços: "); std::cin >>(coefa)>>(coefb)>>(coefc); /* PROCESSAMENTO */ /// Determinar o Delta da Função, e o(s) valor(es) da(s) raiz(es) /// somente se delta for maior que 0. delta = (coefb*coefb) - 4*coefa*coefc; haraiz= 0 <= delta; if (haraiz == true) { x1 = (-coefb + sqrt(delta))/(2*coefa); x2 = (-coefb - sqrt(delta))/(2*coefa); if (x1 > x2) { float x = x1; x1 = x2; x2 = x; } } std::cout << std::endl; /* RESULTADO */ std::cout <<("Para resolução do problema, dados os coeficientes ...\n"); if (haraiz == true) { std::cout <<("Determinou-se que as raiz(es) são respectivamente: "); std::cout <<(x1)<<(" e ")<<(x2)<<("!"); std::cout << std::endl; } else { std::cout <<("Determinou-se não existe raízes reais" " para a questão!\n"); } /* FIM */ return 0; } Procurei entender esse código, e dele descobrir tudo para fazer o seu funcionar.

***[ Olá ... ] Fiz alguns correções; percebi que não a necessidade explicita de termos uma função interna a outra, que você chama um função dentro da main que não existe, e que parece ter confundido um pouco o método. Inclusive aconselho a verificar como é o procedimento mais um vez, sugiro esse site: https://www.somatematica.com.br/curiosidades/c59.php metodo_multiplicacao_russa.cpp // INCLUSOES #include <iostream> // using namespace std; // DEFINICOES // FUNCOES // multRussa ---operação de multiplicação pelo método camponês russo int multRussa(int a, int b) { if (a == 0) { return 0;} else if ((a % 2) == 1) {a -= 1; return multRussa(a/2, b*2) + b; } else { return multRussa(a/2, b*2);} return 0; } // main ---função principal do programa int main(void) { // TIPOS LOCAIS int x, y, rest; x = 0; // multiplicando ---é o que será sucessivamente dividido por 2 y = 0; // multiplicador ---é ... multiplicado por 2 rest = 0; // Resultado ---é o produto da multiplicação // ENTRADA DE DADOS std::cout <<("Informe o primeiro valor:")<< std::endl; std::cin >>(x); std::cout <<("Informe o segundo valor:")<< std::endl; std::cin >>(y); // PROCESSAMENTO rest = multRussa(x, y); // RESULTADO std::cout <<("Resultado: ")<<(rest)<< std::endl; // FIM return 0; }

Certo! São 3x erros: Está acontecendo porque a máscara de dados strings (%s) da função printf espera um tipo strings que no dialeto C é um ponteiro para tipos char. Concluindo esse ponto temos o seguinte problema o uso simultâneo de dois desreferenciadores (* ->), você deve escolher apenas 1 ou segundo modo de desreferenciar o ponteiro para struct. Assim: printf("Nome: %s\n", (pessoa + contador)->nome); /* Desreferenciador p. struct */ printf("Nome: %s\n", (*(pessoa + contador)).nome); /* Desreferenciador p. padrão */ Está acontecendo porque a máscara de dados decimal (%d) da função printf espera um tipo inteiro que no dialeto C é um int, long int ou até long long int para tipos inteiros. Concluíndo esse ponto temos o seguinte problema; o uso simultâneo de dois desreferenciadores (* ->), você deve escolher apenas 1 ou segundo modo de desreferenciar o ponteiro para struct. Assim: printf("Idade: %d\n", (pessoa + contador)->idade); /* Desreferenciador p. struct */ printf("Idade: %d\n", (*(pessoa + contador)).idade); /* Desreferenciador p. padrão */ É análogo o que já foi visto.

A necessidade de pressionar um tecla é inerente aos sistemas de entrada por teclado, até mesmo em comandos por voz é necessário pressionar um botão, ou um ação similar para que o evento possa ocorrer. Caso contrário, estaria falando de um sistema telepático no estilo Stephen Hawking. Isso não vai dar não, porém podemos redirecionar um ou mais comandos; Por exemplo para aspas: Ao abrir aspas o sistemas começa a capturar, e ao fechar aspas terminará a captura com saída do que foi capturado. Essa possibilidade é de simples implementação, contudo, notaremos que ainda é necessário pressionar uma ou mais duas teclas. Ou seja, o que você quer de fato não existe, não há agora com a atual tecnologia, no futuro talvez um sistema de inteligencia empatia seja real. Mesmo assim obrigado pela viagem 😁 "Acredito que você tem se expressado errado."

Olá ... ! A muito tempo pesquisei sobre esse mesmo problema, e não encontrei solução ideal; quando chamado setlocale modifica os padrões de entrada que se tornam incompatíveis com de saída. Assim a solução encontrada foi chamar setlocale segundo a condição no momento, ou seja, se de entrada restabeleço o padrão "C", se de saída o padrão "portuguese". #include <stdio.h> #include <locale.h> int main( void ) { char forca[]= "força"; setlocale( LC_ALL,"portuguese" ); // Liga printf( "%ls",L"Qual é o antônimo de fraqueza: " ); setlocale( LC_ALL,"C" ); // Desliga scanf( "%s",forca ); printf( "A %s.\n",forca ); return 0; }

Olá... ! Programação Com ANSI C' Números Primos Função é um bloco de códigos/declaração que atribuímos nome, parâmetros e retorno. Uma tipica função em C' tem o seguinte formato: tipo_retorno função_nome (lista_parâmetros) tipo_retorno: Refere-se ao tipo de dado que a função retorna por meia da declaração return. Pode ser um ou mais tipos primitivos: char, int, float, double e void que é um caso especial de retorno de tipo-nenhum. função_nome: Refere-se ao seu nome, ou identificador de função, esse é particular, é case sensitive, pois diferencia maiúsculas de minúsculas, assim var e Var são dois nomes. lista_parâmetros: Refere-se a lista de variáveis ou valores que podem operador pela função, também são dos tipos primitivos: char, int, float, double ou de mais que um dessas. void tem duais situações: Somente void: é a forma explicita d'informar que a função não tem lista de parâmetros; ponteiro void: é a forma que ponteiros de tipos não determinados são operador em funções genéricas, esse é uma assunto muito mais avançado e não merece muito destaque por enquanto. Enunciado: Essa função é uma caso especial com tipo_retorno de tipo-nenhum, pois observe que em nenhum momento no enunciado e solicitado retorno para função e também é "uma função que exiba" os resultados de sua tarefa. Essa tarefa que é "exibir todos os números primos inferiores a um inteiro N". Então nesse instante final do enunciado surgiu uma grave problema, pois existem infinitos números primos menores que N inteiro, por exemplo seja N:= 0, temos que exibir todos os infinitos números primos não positivos menores que 0. << Isso é um absurdo. >> Por conta do absurdo não existe resposta coerente para esse problema. Caso poste o enunciado mais adequadamente voltarei com a questão do problema [...] *** Até

Todos os processos dependem dessa matriz, portanto o mais fácil é: Declare a matriz no escopo de programa. Se essa variável for pública não há restrição para funções.

Oxi! Supomos, então para que atualizações simultâneas é preciso os respectivos campos Compartilhem o mesmo local na memória. Neste caso a estrutura 'sales' aponta para respectivas parceiras. typedef struct { int *idcustomersale; /**< Aponta para Id em Cliente. */ char *serialnumberproductsale; /**< Aponta para Id em produtos. */ float endprice; } stsales;

No meu entender da opção 4 temos: valor_extra = carro * 0.06f; //é o mesmo que 6% do valor do carro, 6% pois são 3 opcionais que taxa 2% cada um. valor_extra = valor_extra + carro * 0.08; //é valor_extra mais a taxa de IPI do valor do carro. valor_extra = (valor_extra + carro) * (1 - 0.035f); //agora temos o (-)desconto de 3,5% do valor do carro. valor_completo = valor_extra; //com todas as taxas, descontos e valor do carro e concluída a opção completa. Será que estou certo ou errado!? Tapatalk Mobile

Para eu entender. Quais são essas porcentagens ? Se você quiser diga mais fora do contexto do seu algoritmo.

Olá! Dei-me licença para 'palpitar' neste questão. Se eu entendi o problema é obter 2%, Vejamos em 2 etapas. Vou abstrair do problema o valor de R$30.000,00: 1ª ​Observe que C usa particularidades do sistema ANSI, ou seja, em 'C [.] ponto é usando para separa decimais de inteiros, então se o usuário entrar$ 30.000 C interpreta: 30.0f (ou seja 30 inteiros e 0 decimais). Será que intendemos essa parte!?! 2ª Se eu quero obter 2% de um número inteiro basta multiplicar ele por 0.02f está correto?! Se eu quero obter a porcentagem de 2% e somar o valor simultaneamente então basta multiplicar esse número por 1.02f está correto?! Será que eu entendi essa parte!? Uzumakit O fragmento abaixo é de seu algoritmo valorTotal = valorFabrica + valorFabrica*1.02F Observei que se o usuário entra com: 30000.00 o resultado será: 30000.00 + 30000.00 * 1.02 30000.00 + 30600.00 [seguindo a regra das precedências] = 60600.00 O resulta para valorTotal: 60600.00 Se sua intenção não era essa, então digamos que fosse: valorTotal = valorFabrica*1.02F Teremos o resultado que será: 30000.00 * 1.02 Assim valorTotal: 30600.00 (dando a devida formatação: R$30.600,00) Será que está tudo correto ou eu entendi mal!? Espero que toda essa 'falecia' tenha ajudado! De qualquer forma Obrigado.

Sim! Independentemente da arquitetura, os sistemas atuais, tem um inteiro CHAR de 8 bits. Se mapearmos um a um em estrutura, e aplicamos cast é possível manipula-los individualmente. Veja como: /** @authr Mauro Britivaldo * License all free on edition and published */ #include <stdio.h> //MANUAL TRACE typedef struct byte byte; //Definido a nossa estrutura struct byte { //Mapeamos Bit a Bit com campos da mesma unsigned char b0: 1; unsigned char b1: 1; unsigned char b2: 1; unsigned char b3: 1; unsigned char b4: 1; unsigned char b5: 1; unsigned char b6: 1; unsigned char b7: 1; }; int main (void) { // char c_caracter; //Declaramos uma variável inteira byte *bt; //Declaramos um ponteiro da estrutura bt = (byte*) &c_caracter; bt->b4 = 1; //Manipulamos em baixo nível; bit a bit := |16| //Observe o resultado // printf ("Before: Show byte: %d\n", c_caracter); bt->b4 = 0; printf ("After: Show byte: %d\n", c_caracter); return 0; }