RPGStreamer

Acho que a solução tá em dividir o vetor em pedaços iguais a k (passando k como n às funcões de menor soma e maior soma), e ir atualizando a menor e maior soma conforme caminha pelo vetor (indo de 0 a k, depois de 1 a k + 1, depois de 2 a k + 2, etc, até k + x == n. k não pode ser maior que o tamanho do vetor, e não pode ser menor que 2.

Também não entendi. É pra ordenar os vetores? O terceiro vetor vai ter o mesmo tamanho do primeiro e segundo, ou o dobro do tamanho? Não tá claro pra mim o exercício.

Eu acho que pra ficar mais seguro, seria algo assim int n = 0; for(size_t i = 0; cadeia[i] != '\0'; ++i) { if(cadeia[i] == '+' || cadeia[i] == '-' || cadeia[i] == '*' || cadeia[i] == '/') { ++n; } } Isso se voce tiver certeza que a funcao nunca vai ser mal usada (ou seja, sempre vão mandar um ponteiro pra char com o caractere nulo '\0' no final, chamado de uma "c-string")

Acho que você tem que incluir "peca.h" em tabuleiro.cpp, senao essa classe não existe pra aquele arquivo.

Ele está acessando memória além do array. Seu while tem que parar antes de acabar a string. @Pedroernesto64 Aliás, gets está deprecated. Está fora do standard e não precisa ser implementada mais. use fgets (com stdin como o handle do arquivo, pra ler do console).

esse constructo: friend class Peca::posAtual(v2); Não tem sentido. friend aparece na declaração das classes, nunca em outro lugar. Dentro do corpo de uma função então...

Se trabalhar com C é realmente o alvo, e os programas são apenas treinamento pro que você vai aprender no futuro, então tem certas boas práticas as quais você deve se ater, pra evitar problemas do seu código compilar de um jeito pra um sistema e de outro em outro sistema, inserindo bugs bem difíceis de achar. Por exemplo garantir que os tipos tenham sempre um certo tamanho é uma boa. Isso é feito usando a stdint.h. Outra coisa é os caracteres internacionais. Esse assunto você resolve com a uchar.h. Isso aí tudo vai ser explicado no futuro pelo seu professor, com certeza.

@Pepse Qualquer dica pra melhorar a refrigeracao eh muito bem vinda. O lugar fica quente mesmo no verao. Eh no sotao.

@Pepse Puxa, agora ja comprei! Na Kabum: Gabinete Gamer Corsair Carbide Series Spec Delta, Mid-Tower, RGB, Lateral em Vidro Temperado, Preto, CC-9011166-WW. Eh bom?

É C ou C++, gente? Acho que deveriam ser tags diferentes. C é uma baita linguagem, muito importante pra implementação de microsistemas e plataformas tipo Lua, Python, etc, logo, estudar C não é inválido, apenas tem um mercado restrito. Já pra realmente fazer algo pro usuário final, C não é conveniente e C++ é bem superior.

#include<iostream> #include<array> #include<string> #include<vector> #include<cctype> #include<algorithm> //IMPORTANTE: ja que voce nunca usa new ou malloc, não precisa de delete ou free. Esses objetos sabem se auto-destruir quando //saem de escopo //ao invés de importar o namespace inteiro, melhor importar apenas os tipos e objetos que mais vamos usar using std::cout; using std::cin; using std::endl; using std::string; using std::vector; const size_t code_size = 11u; //por uma peculiaridade da funcao std::cin.get, que introduz o caractere nulo \0 ao final do array //um apelido pro tipo std::array<char, 11> que usamos como identificador do produto using id_prod = std::array<char, code_size>; //aqui sua estrutura produto. Isso poderia ser feito com classes, e as funcoes transformadas em metodos. //Mas vamos aderir ao seu design struct produto { string nome{}; string tipo{}; double valor{};//dinheiro e melhor representado por um inteiro em centavos. Quando precisar exibir, apenas divida por 100. string local_estoque{}; id_prod identificador_produto{}; long quantidade_estoque{}; }; /// <summary> /// Recebe uma referencia a um double como parametro. Espera o usuario digitar uma linha no console. /// Se o que o usuario digitou puder ser convertido para um double, a funcao armazena o valor convertido na referencia e retorna /// true. Se o que o usuario digitou não puder ser convertido em um double, a funcao retorna false. /// </summary> /// <param name="out">O parametro de saida, onde sera armazenado o valor que o usuario digitar</param> /// <returns>true, se o usuario digitar um valor valido, false caso contrario</returns> bool readDouble (double& out) { static string rawInput; std::getline (cin, rawInput); bool success{}; try { out = std::stod (rawInput, nullptr); success = true; } catch (std::exception e) { success = false; } return success; } /// <summary> /// Recebe uma referencia a um id_prod como parametro. Espera o usuario digitar uma linha no console. /// Se o que o usuario digitou puder ser convertido para um id_prod (ou seja, apenas letras e numeros), /// a funcao armazena o id_prod na referencia e retorna true. /// Se o que o usuario digitou caracteres invalidos, a funcao retorna false /// </summary> /// <param name="out">O parametro de saida, onde sera armazenado o valor que o usuario digitar</param> /// <returns>true, se o usuario digitar um valor valido, false caso contrario</returns> bool readCode (id_prod& out) { id_prod result{}; cin.get (result.data (), result.size ()); for (char c : result) { //aqui eu assumo que letras maiusculas, minusculas e digitos sao validos no codigo, outros caracteres não. if (!std::isalnum (c)) { return false; } } return true; } void criar_produto (produto& out) { cout << "NOME DO PRODUTO:" << endl; cin >> out.nome; cout << "TIPO DE PRODUTO:" << endl; cin >> out.tipo; //permanece em loop enquanto o usuario falhar em digitar um valor valido while (!readDouble (out.valor)) { cout << "O valor digitado não pode ser convertido a um numero!" << endl; } cout << "LOCAL DISPONIVEL NO ESTOQUE:" << endl; cin >> out.local_estoque; cout << "CODIGO DO PRODUTO:" << endl; //permanece em loop enquanto o usuario falhar em digitar um valor valido while (!readCode (out.identificador_produto)) { cout << "O codigo de produto deve conter apenas letras e numeros" << endl; } } //Mesmo sem necessidade de alterar o argumento, essa funcao aceita uma referencia (declarada como const, ja que não sera modificada //Isso evita a copia da estrutura inteira, passando apenas uma referencia da estrutura void mostrar_produto (const produto& prod) { cout << "Nome: " << prod.nome << endl << "Tipo: " << prod.tipo << endl << "Valor: " << prod.valor << endl << "Local: " << prod.local_estoque << "ID: " << prod.identificador_produto.data () << "Em estoque: " << prod.quantidade_estoque << endl; } size_t cadastrar_produtos (vector<produto>& catalogo) { char reply{}; size_t counter{}; do { produto novo_produto; cout << "-> Adicao de Produtos ao Estoque\n" << endl; criar_produto (novo_produto); cout << "Produto criado:\n" << endl; mostrar_produto (novo_produto); cout << "Deseja adicionar o produto ao cadastro (s para cadastrar)?"; cin >> reply; if (reply == 's') { catalogo.push_back (novo_produto); counter++; } cout << "Deseja cadastrar outro produto? (s para continuar, outro caractere para sair." << endl; cin >> reply; } while (std::tolower (reply) == 's'); return counter; } /// <summary> /// Precisamos dessa funcao pra usar sort. Essa funcao determina quando um produto e "menor" que outro. /// Em ordem alfabetica por nome, isso e decidido pelo campo nome. Essa funcao leva em consideracao maiusculas e minusculas /// (todas as maiusculas sao menores que todas as minusculas). /// a funcao std::tolower que eu usei acima troca um caractere pra minuscula (se ja for minuscula, não faz nada). /// Uma boa primeira mexida seria se livrar desse defeitinho no codigo. /// </summary> /// <param name="p1"></param> /// <param name="p2"></param> /// <returns></returns> bool order_alfa (const produto& p1, const produto& p2) { return p1.nome < p2.nome; } void ordenar_catalogo (vector<produto>& catalogo) { //o nome dessa variavel e predic. A declaracao dela e bem bizarra! Mas não precisamos dela. //bool (*predic)(const produto&, const produto&)(order_alfa); //a funcao std::sort, definida no header algorithm ordena coisas que tem um iterador de acesso aleatorio. //Os containers da STL tem iteradores, mas nem todos tem acesso aleatorio. vector, o que estamos usando, tem. //begin e end sao funcoes que retornam "iteradores" do inicio e fim de um container. //std::sort tem uma versão pra tipos que tem o operador < definido, por ex., strings, ints, etc. Nessa versão, não precisa //passar uma outra funcao pra ela saber como ordenar std::sort (catalogo.begin (), catalogo.end (), order_alfa);//veja que basta o nome da funcao pra passa-la a outra } //Como acima, recebe uma referencia. Se na funcao anterior evitamos copiar uma estrutura produto, aqui evitamos copiar um vetor //inteiro delas. size_t listar_catalogo (const vector<produto>& catalogo) { size_t counter{}; for (const produto& prod : catalogo) { cout << "\nProduto n" << counter++ << " no catalogo" << endl;//uma ilustracao do operador pos-incremento mostrar_produto (prod); } return catalogo.size (); return counter;//deve ser igual a catalogo.size() } //void do_tests (); int main () { vector<produto> catalogo; //do_tests (); //creio que usando as poucas funcoes que eu usei, voce possa construir o resto das funcoes que faltam e //fazer seu programa inteiro funcionar. Qualquer duvida, pode perguntar. Talvez tenha um erro logico em algum lugar. //não tive tempo de testar. //Um problema que prevejo e o enter ficando "empacado" no stream de entrada (o std::cin) e isso dando problema nos getlines. //Se isso acontecer, coloque cin.ignore (); antes da linha que ele estiver pulando, pra "dar descarga" no enter return 0; } Pra não dizer que so reclamo , aqui vai um exemplo dum codigo um pouco mais moderno. Ainda não se encaixa bem no seu exemplo especifico, e não resolve o problema todo, mas da pra ter uma ideia do que falta você estudar Uma pena que o tamanho do post (pelo menos aqui em casa) ficou estreito demais, e não da pra ver as linhas inteiras. Acho que no seu IDE deve ficar melhor, copie e cole la.

Eu to tentando achar um com boa refrigeracao que caiba esse cooler, e que seja na Kabum.

@Gabriel Rinaldi Perdao, placa-mãe! Eu disse placa-de-vídeo. Era placa-mãe. Isso e so uma abertura normal que tem nos gabinetes pras placas-mae exporem suas entradas, etc, certo?

Esse monte de portas USB e etc mencionadas na placa de vídeo, o gabinete não tem nada a ver com isso, tem?

@Gabriel Rinaldi Essa parte de cima que tem que ser compativel ne?

@Gabriel Rinaldi Pior que não entendo nada de gabinetes (hardware em geral). Estou tentando conseguir ajuda do povo esperto daqui.

Você tem que usar esses tipos (char [ ] por exemplo), ou você pode usar vectors e strings? Bjarne Stroustrup ia ficar triste de ver você usando coisas obsoletas assim, a não ser que você esteja estudando C++ antigo de propóposito.

Gostaria de comprar um gabinete compatível com este WC EVGA. Minhas outras peças são as seguintes (caso seja relevante): Placa-mãe: ASUS - TUF Gaming Z490-Plus CPU: Core i7 10700K Fonte: XPG Core Reactor 850 Gold Memória: (1 pente) 32GB Kingston Fury DDR4 3200MHz (KF432C16BB/32) SSD: SSD WD Blue, 1TB, M.2 (WDS100T2B0B) Também preciso saber se preciso comprar fans extras, ou se o gabinete vem com todas necessários (nota: no verão, o local onde este computador vai ficar pode esquentar demais).

Perdão. A formatação ficou o horrível, e eu troquei do português pro inglês na última linha de comentário (deixei o tempo máximo de edição passar). Eu disse que está faltando um monte de coisa, mas essa é a classe básica. Qualquer dúvida, pergunte.

Um árvore binária tem sentido quando os dados podem ser considerados "maiores", "menores" e iguais entre si. A ideia é a seguinte: se um elemento for menor do que o elemento atual, ele tem que ir parar em algum lugar à esquerda do elemento atual. Se o elemento for menor do que o elemento atual, ele tem que ir parar à direita do elemento atual (como é de praxe, 1, 2, 3, 4, ... os números menores da sequência estão à esquerda dos maiores, e vice-versa). Cada parte da estrutura é um "nó". Um nó contem o dado, a dois ponteiros, um pro nó a esquerda (onde estão todos os nós cujos dados menores que o do dado atual) e um nó a direita (onde estão todos os nós cujos dados são maiores que o atual). #include <string_view> #include <string> using std::string_view; using std::string; class TreeNode { private: string _datum; TreeNode* _left; TreeNode* _right; public: TreeNode(string_view datum) : _datum{ datum }, _left{ nullptr }, _right { nullptr } { } ~TreeNode() { delete _left; delete _right; } /* note que o metodo abaixo retorna uma cópia de _datum, invocando implicitamente o copy constructor std::string. Isso enforça * o princíptio do encapsulamento, não deixando o código chamador mudar o que não devia. Se _datum é mudado, a árvore inteira * pode ter seu estado interno comprometido, caso o chamador mude _datum pra um elemento que viole o axioma de que "todos os * dados menores que este aqui estão à esquerda, enquanto todos os maiores estão à direita. */ std::string getDatum() const { return _datum; } //missing a lot of stuff, but that's the basic class. If you run into any problem tell me. };

Gostaria de comprar um gabinete compatível com este WC EVGA. Minhas outras peças são as seguintes (caso seja relevante): Placa-mãe: ASUS - TUF Gaming Z490-Plus CPU: Core i7 10700K Fonte: XPG Core Reactor 850 Gold Memória: (1 pente) 32GB Kingston Fury DDR4 3200MHz (KF432C16BB/32) Também preciso saber se preciso comprar fans extras, ou se o gabinete vem com todas necessários (nota: no verão, o local onde este computador vai ficar pode esquentar demais). Quase esqueci. Essa pasta térmica é boa? Corsair XTM50

@Gustavo Vieira2910. Algumas coisas. Essa linha printf("Figura: Triangulo,e seu perimetro eh:%iperimetro"); você colocou o nome da variável perimetro dentro da string de formato. É bom também inserir uma quebra de linha com o caractere de escape '\n', senão o próximo print vai aparecer agarrado a esse. printf("Figura: Triangulo,e seu perimetro eh: %i\n", perimetro); Nessa próxima linha, você usa o operador & que obtem o endereço da variável área, quando na verdade você quer seu valor printf("Figura: Quadrado,e sua area eh:%i",&area); A linha corrigida (com quebra de linha): printf("Figura: Quadrado,e sua area eh: %i\n", area); Por último, vou ler em português as últimas linhas: if(numlado==5){ printf("Figura: Pentagono"); } else if(numlado!=3||numlado!=4||numlado!=5){ printf("Poligono não identificado"); } SE numlado igual a 5 ENTAO print "Figura: Pentagono" SENÃO SE numlado diferente de 3 OU numlado diferente de 4 OU numlado diferente de 5 ENTAO print "Poligono não identificado" A cláusula do último if está errada, mas mais do que isso, todos os ifs deveriam ser if-else, ao menos pra evitar o teste da variável numlado mais de uma vez, mesmo quando o resultado já foi encontrado. Ou seja: if(/*cláusula aqui*/) { //instruções aqui } else if(/*próxima cláusula*/) { //instruções. } //quantos outros else if forem necessários, terminando em else. else { //instruções quando nenhuma das expressões avaliadas nas cláusulas dos ifs resultarem em VERDADEIRO. }

@Giovanna Costa De nada. Estou sempre sendo ajudado nesse fórum. Ainda bem que tem uma parte de programação, onde eu posso ajudar de volta. Qualquer dúvida que surja, pode perguntar.

Eu faria um array onde os indices correspondem ao digito (ou seja, um int array[10]). Inicializaria tudo com zero e incrementaria em 1 o elemento cada vez que eu encontrasse um digito com seu indice. Separar um numero em digitos não eh difícil. O resto da divisao entre o numero e 10 da o ultimo digito do numero. Dividindo o numero por 10, o resultado eh o restante do numero sem esse ultimo digito: long long num = 995793LL;//um numero qualquer //dentro dum loop, pra voce contar todos os digitos long long digito = num % 10LL; num /= 10LL; Isso no entanto só funciona pra numeros que caibam num long long. Se o numero estiver em formato de string, melhor ainda, basta ler cada um dos caracteres da string (cada um deles vai corresponder a um digito), converter pra int (funcao stoi, acho) e incrementar o array do mesmo jeito. //não sei exatamente as regras de inicializacao de arrays em C puro, entao vou ser explicito int arr[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; long long digito = 0; //obtemos digito de uma das formas mencionadas acima. Resto 10 se o numero for realmente um inteiro. Indice por indice se for string. arr[digito]++; //no final, procuro o maior valor no array. Existem otimizacoes que podem ser feitas, mas pra efeito de resposta formal, creio que ta bom

(Estou sem acentos. No meu computador de programacao, perdoe a falta destes) Eu acho que a gente deve fazer as structs todas primeiro. A gente imagina que esse programa vai se conectar a um arquivo ou banco de dados. Isso não e pedido no exercicio, mas seria assim na vida real. Vamos fazer pensando que seria assim na vida real. Ve se voce entende (ja estudou tudo que eu uso) essa parte. Ja deve dar uma ideia do resto dos tipos que voce precisa criar. //struct Cliente #include <iostream> #include <string>//pra usar o tipo std::string. Espero que voce o conhece typedef struct Cliente //essa linha comeca a definicao da struct, um tipo. A keyword typedef vai criar um apelido pro tipo { private: std::string _telefone; std::string _nome; std::string _endereco; std::string _complemento; std::string _cep; public: //vou criar um construtor. voce sabe o que sao construtores? //os parametros do construtor sao referencias. Evita que os dados sejam copiados (eh como se fossem ponteiros, nesse sentido). //não vamos validar nada. Vou inicializar os campos diretamente a partir dos parametros Cliente(const std::string& telefone, const std::string& nome, const std::string& endereco, const std::string& complemento, const std::string& cep) : _telefone{telefone}, _nome{nome}, _endereco{endereco}, _complemento{complemento}, _cep{cep} { /* não resta nada a fazer, ja que não vamos validar e ja inicializamos todos os campos*/ } //os getters abaixo retornam copias dos objetos std::string getTelefone() const { return _telefone; } std::string getNome() const { return _nome; } std::string getEdereco() const { return _endereco; } std::string getComplemento const { return _complemento; } std::string getCEP() const { return _cep; } //Esse exercicio não exige setters em Cliente. Vamos considerar que dados de clientes sao alterados de outro modo. } Cliente;//aqui o apelido e definido. Ao invés de digitar struct Cliente o tempo todo, podemos digitar Cliente como tipo.