Ir ao conteúdo
  • Cadastre-se

codigo rapido

Membro Pleno
  • Posts

    275
  • Cadastrado em

  • Última visita

posts postados por codigo rapido

  1. Em 10/10/2021 às 23:02, Fn1X disse:

    No caso, daria para interceptar as informações contidas no seu programa pelos pacotes de redes manipulados e enviados pelo seu programa, seria muito mais fácil e nem precisaria fazer nenhuma tentativa de eng. reversa no arquivo compilado, então sim o risco existe . 

    Esse problema pode mesmo existir. Com você faz pra evitar tal problema?

    Deve ter alguma lib pra criptografia na qual é experiente.

    Eu uso RSA pra primeira troca de chaves. Como uso mais javaScript para cliente, a muito tempo encontrei um codigo chamado odave com RSA e AES. RSA é uma criptografia forte assimetrica Depois do RSA, uso AES, que é forte, mas é simétrica. Mas como a chave do AES foi transmitida usando o RSA, não precisa ter muita preocupação com o AES depois.

    • Curtir 2
  2. você já programa em alguma outra linguagem? É que algumas linguagens, como java por exemplo, os parametros só servem de entrada. E a saida é usando return dentro da função.

    o senhor está com a ideia errada da coisa para o C. Em C, os parametros da função não quer dizer que só é entrada. Pode ser saida também, quando for ponteiro. Quer dizer que o ponteiro é um endereço (ou conjunto de entedeços) de memoria.

    E a função, se você quiser mudar o conteudo desse endereço, vai permitir que esse valor alterado fique visivel de qualquer parte do programa, pois esse endereço pode ser obtido se a variavel onde você guardou esse endereço for acessivel.

    Como no exemplo mostrado quando lhe fiz o exemplo fatorial3 do exercicio de recursividade que o senhor passou da ultima vez.

    void calc_hexa(float la, float *a, float *p)
    {
    	*a = (3 * la * la * sqrt(3))/2;
    	*p = 6 * la;
    }

    Não etstei, mas acredito que funcione e seja só isso...

    • Curtir 3
  3. Citação

    E tem a chamada a srand() dentro da função que gera os números é uma bobagem. E time(NULL) como semente num teste também não ajuda nada.

    Mas, novamente, as perguntas que não querem calar: por que? qual o contexto? e onde está a fonte?

     

    professor da usp fazendo bobagem?
    https://www.ime.usp.br/~pf/algoritmos/aulas/random.html


    Mais:
    https://www.cplusplus.com/reference/cstdlib/srand/

    https://man7.org/linux/man-pages/man3/tsearch.3.html

    https://classes.mst.edu/compsci1570/randomnumbergeneration.htm

    http://linguagemc.com.br/valores-aleatorios-em-c-com-a-funcao-rand/

    • Curtir 1
  4. Citação

    O parâmetro adicional foi incluído em 2020. votado como tudo que entrou de novo na linguagem nessa versão. O mesmo caso de 2017 quando esse conceito foi introduzido, ainda sem o parâmetro.

    Pode ser... meu ubunto é de 2016. Mas isso não importa.

     

    Citação

    Muito bom... porque não fez isso antes?

    Ou simplesmente... você deve estar usando uma versão antiga do compilador que a iso ja descartou...

    Programar não é isso ai que você tá achando que é. vai muito além de conhecer profunda mente a linguagem. Quem programa, programa até em eletronica, até com caixas daguas dá pra programar...

  5. 
    #include <stdio.h>
    
    int main()
    {
    	float frente, esquerda, direita; 
    	//, tras; atras talvez nem precise porque 
    	// não entrando nessas condição, automaticamente 
    	// irá imprimir atras... 
    
    	// se tem 3 sensores, então obrigatoriamente você deve ter 3 scanfs pra similar
    	printf("Entre com o valor a: ");
    	scanf("%f", &frente);
    	printf("Entre com o valor b: ");
    	scanf("%f", &esquerda);
    	printf("Entre com o valor c: ");
    	scanf("%f", &direita);
    
    	// acho que deveria ser assim, porque a condição prioritaria é pra frente
    	if(a>50.0);
    		printf("frente");
    	// se não testa a segunda condicao
    	else if(b>50.0);
    		printf("direita");
    	// se não testa a terceira
    	else if(c>50.0);
    		printf("esquerda");
    	else
    		printf("atras");
    	return 0;
    }
    
    /*
    	// agora olha só... existe diferenças... 
    	// seu robo, se decidir ir pra frente ou ir pra tras, ele vai sair do lugar. 
    	// mas se decidir ir pra direita ou esquerda, ele só vai girar, depois que 
    	// ele vai decidir ir pra frente ou pra tras
    
    	// você pode simular o labirinto assim:
    	int array[10][10] = {	{1,1,1,1,1,1,1,1,1,1},
    				{1,0,0,0,0,0,0,0,0,1},
    				{1,0,0,0,0,0,0,0,0,1},
    				{1,0,0,0,0,0,0,0,0,1},
    				{1,0,0,0,0,0,0,0,0,1},
    				{1,0,0,0,0,0,0,0,0,1},
    				{1,0,0,0,0,0,0,0,0,1},
    				{1,0,0,0,0,0,0,0,0,1},
    				{1,0,0,0,0,0,0,0,0,1},
    				{1,1,1,1,1,1,1,1,1,1}
    	};
    
    	// ai, você coloca seu robo em algum ponto qualquer no lugar de 0. Pode usar random pra isso.
    	// cada quadrado como 50 cm, cada 1 como parede, e cada 0 com espaço vazio
    	// é melhor que digitar no seu scanf toda hora alem de deixar mais bonitinho... 
    
    	// aqui você encontra um exemplo legal de codigo como deixar mais bonitinho e até como 
    	// fazer aparecer o seu robo e as paredes:
    
    	// https://en.wikipedia.org/wiki/ANSI_escape_code
    	// ate postei o exemplo do codigo aqui:
    	// https://www.clubedohardware.com.br/forums/topic/1562726-ubuntu-gcc-e-interfaces-gr%C3%A1ficas/
    
    	// se usar gotoxy, vai mover seu robo
    */


     

    • Obrigado 2
  6. 11 horas atrás, arfneto disse:

    Muitas vezes a função retorna algo e o tal desenvolvedor despreza o valor POR ERRO. Engano. Simples assim. E muitas o desenvolvedor original, O CARA QUE ESCREVEU A FUNÇÃO, sabe que o resultado dela não deveria ser desprezado.

    Quando a gente sabe o que faz e o compilador dá permissão, quem manda é o desenvolvedor. Como eu lhe disse, se a linguagem fosse perfeita, não necessitava de abertura para descer ao nivel do assembly.

     

    Observe como eu fiz ai acima, quando você falou de que função recursiva só tem sentido quando retorna valor. Eu fiz usando ponteiro só pra mostrar que isso não é necessário nem obrigatorio. Nem te citei pra mostrar isso.

  7. 10 horas atrás, arfneto disse:

    E também te expliquei a razão da preocupação de avisar de um possível erro ao descartar um valor de retorno.


    tem como mostrar a fonte? eu não concordo com tudo o que vejo, mas apresento minha forma de fazer sem nem citar quem não concordo. E sempre apresento fontes.

  8. 6 horas atrás, Mario3210 disse:

    O problema é que não estou compreendendo essa função, se alguém tiver uma dica sobre.

    mas o que você não entendeu disso? comente o que entendeu seguido das linhas que entendeu e escreva não entendi isso seguido do que não entendeu... Basicamente, se você sabe que os numeros que entrar como parametro vão seguir a ordem, nem precisava desses testes dessas condicionais.

    o usuário arfneto deu uma excelente solução para o que quer:
    https://www.clubedohardware.com.br/forums/topic/1563959-gerar-valores-aleatórios-sem-repetição-em-uma-matriz/

     


    Mas se achar complicado, ou considerar ilegivel, logo abaixo eu o mostro seu equivalente sem usar ponteiros.

    • Curtir 1
  9. 46 minutos atrás, Gabi_gabis disse:

    Oi boa noite alguém pode me ajudar com esse exercício,  eu comecei a fazer dando só a definição de esquerda, direita,  frente e trás depois eu me perdi não sei o que fazer se alguém puder me ajudar ,no que eu devo fazer, me dar uma luz pfv :' desde já deixo meu obrigada.

     

    Você foi convidado para a oficina de robótica e terá de implementar
    um algoritmo para decidir o movimento de um carro automático. Ele tem 3 sensores 
    que medem distância a obstáculos: um na frente, um à esquerda e outro à direita 
    (aqui na questão você simulará a leitura dos sensores usando 3 comandos scanf). 
    Os comandos que você pode dar aos motores do carro são “frente”, “esquerda”, 
    “direita” e “trás (ré)” (aqui na questão você simulará os comandos para os 
    motores através de printfs apenas). Implemente um programa em C que simule 
    a seguinte lógica: o carro anda para frente caso o sensor da frente 
    indique obstáculo a mais de 50 cm; caso contrário, o sensor da direita é
    examinado: o carro vira à direita caso o sensor da direita indique obstáculo 
    a mais de 50 cm; caso contrário, o sensor da esquerda é examinado: o carro vira
    à esquerda caso o sensor da esquerda indique obstáculo a mais de 50 cm; caso 
    contrário,o carro andará para trás (marcha à ré), nesta situação em que todos 
    os sensores indicam obstáculos próximos (<= 50 cm).

    você fez o que já? pelo menos já fez o labirinto de testes? mostre o que já tem pronto.
     

    • Curtir 2
  10. ja... já li, já trabalhei, já escrevi sobre tudo isso. Só que pilha e recursividade, não são a mesma coisa. O estouro de pilha acontece simplesmente por tentar colocar valores além do acordado na pilha. Entendeu?
     

    Citação

    Eu estou certo. E te mostrei o exemplo de C++. 

    Não é assim que se programa. Até porque se a linguagem não tivesse limites, não teria nem necessidade pra descer ao nivel do assembly. E isso, como estou tentando lhe ensinar, é escolha do desenvolvedor. O compilador permite e dá ideias.... Assim como é o uso de goto. Eu não uso. Mas tem que goste de usa-lo.

  11. Citação

    Que diferença faz declarar multiplica() retornando um int se despreza o valor de retorno? Viu o exemplo que te mostrei, em C? [quase off-topic] Em C++ até tem um atributo, [[nodiscard]] que evita que o programador possa fazer isso com o resultado de uma função  

    O senhor equivocado. Devia rever o que entende por programação. Não é assim com esse pensamento que se desenvolve programas.
    Uma forma comum de se fazer alteração, ou "receber um valor", pode ser passando um parametro na forma de ponteiro.
    Quem decide se vai usar ou não o valor de retorno não é a linguagem. É o desenvolvedor. Até porque muitas funções retornam valor apenas para testes (aguns ainda programam assim e funciona) e podem ser ignoradas quando não for necessidade testa-las.

     

    Citação

    x^0 = 1 para qualquer x... e x^1 = x para qualquer x. Do modo como escreveu vai retornar o mesmo resultado para potências 0 e 1. 4^0 = 1, 4^1 = 4 por exemplo.

    verdade. Obrigado. Eu não tinha visto isso. O senhor tem razão.
     

    Citação

    um pouco off-topic, mas C tem a função pow(), de power, lembrando que potência na matemática em inglês é power, ou potency no coloquial. Em francês puissance, em espanhol potencia, para citar idiomas mais próximos, se pretendia usar uma grafia dessas linguagens.


    não é o que está sendo discutido. Não vem ao caso. O assunto é recursividade. ele poderia chegar aos mesmos resultados apenas usando axiomas de peano. mas também não é o caso.
     

    Citação

    Recursão e pilha tem tudo a ver e a recursão acontece mesmo na pilha. Um erro simples num programa recursivo e vem de imediato um... stack overflow, no popular "estouro da pilha" .


    Está equivocado quanto a isso também. ter a ver é uma coisa... a gora, ser, é outra. Por isso eu fui especifico quando eu disse que fazemos isso numa divisão. Mesmo no papel. Agora pilha é outra coisa. Pode olhar isso na diciplina de linguagens formais e sistemas automatos.

     

    Citação

    E o caso trivial de expoente zero, que retorna 1 para qualquer base.


    É sim. Já falou disso, mas novamente agradeço, pois tem razão.

  12. 1 hora atrás, kampa896 disse:

    @codigo rápido agora sim eu entendi. Quando eu comentei a chamada da função, funcionou da mesma forma. Então era o 'while' que estava calculando. Pelo que eu percebi, as funções recursivas colocam as variáveis tipo em pilha, é isso? Pra chegar no resultado final. Estou tendo essa dificuldade de entender o processo da recursividade.

    pilha é outra coisa... pesquise o que é uma pilha em linguagens formais e automatos. Maquina de turing. Mas é como se fosse isso, se observar a ordem de execução dos processos.

    um processo (função) só termina quando todos os processos dentro dela terminarem. Isso quer dizer o return da primeira função só será dado depois que concluir todas as funções antes desse return. Então, na verdade, é que a ultima função chamada é que é a primeira a terminar.
     

    • Curtir 1
    • Amei 1
  13. 1 hora atrás, Midori disse:

    Acho o teste da matrícula mais simples fazendo entre 100 mil (inclusive) e 1 milhão, p.ex,

     

    do{
        printf("Matricula: ");
        scanf("%d", &matricula);
        valida = matricula >= 1e5 && matricula < 1e6;
        if(!valida){
            puts("Matricula invalida");
        }
    }while(!valida);

     

     

    porque você está dizendo isso? não entendi... no primeiro momento que peguei esse exercicio a primeira coisa que fiz foi tirar essa condicional só pra não ter que digitar qualquer caractere.

    • Curtir 1
  14. 1 hora atrás, .if disse:

    Detalhe curioso que me permito opinar é que tais adaptadores são úteis apenas na fase de protótipo onde há indecisões técnicas e testes necessários. Não no produto final ok?

    Assim como faço com capacitores, indutores e resistores. Pra mim tem que ser tudo variavel. Só em projetos definidos que uso solda de componentes que não são variaveis.

    A verdade é que eu costumo usar assim pro resto da vida... Hehehe... casa de ferreito espeto de pau.
     

    • Haha 1
  15. 1 hora atrás, .if disse:

    comecei a entender e explicar o adaptador... De fato ele converte de ampop duplo pra simples com eu havia profetizado. O curioso mesmo é este...

    DIP8-to-SOP8-Converter-for-op-amp-Patch-

    Me lembro de certa feita quando enxergava bem e não tremia, soldei um dip em ilhas smd .. mó trâmpo

    +

    https://imall.com/product/Dual-Single-DIP8-to-OP-Amp-Opamp-Adaptor-Converter-for-NE5534-AD797-OPA627-Amplifier/Security-Protection-Consumer-Electronics-Accessories-Parts/aliexpress.com/1000007162103/144-69708341/en


    Mas esse ai parece que é usado porque o oamp é muito maior que o espaço permitido pra soldar na placa.

  16. 33 minutos atrás, nagatonie disse:

    Meu compilador está com algum problema que não consigo resolver, esses erros simples não aparecem pra mim na hora de compilar o que acaba gerando mais duvida, mas entendi sim!

    tem algo errado no seu compilador... que compilador está usando? por padrão eles mostram mensagens. mesmo em linha de comando, que é o que uso aqui.

    gcc nomeFile.c -o NomeFinalQueQuero.exe
     

    • Curtir 1
  17. 1 hora atrás, kampa896 disse:
    while(cont <= exp){
    		if(cont == 2){
                valor = base * base;
                cont++;
                multiplica(valor, base, cont, exp);
            }
            else{
                valor = valor * base;
                cont++;
                multiplica(valor, base, cont, exp);
            }

    Parece que não entendeu...
    só pode chamar essa função de recursiva por ter chamada dela mesma. Mas não tem utilidade da sua recursividade. Chama mas não usa os resultados dela. Só chegou no resultado por causa do while fazer suas contas... tenta só comentar essas chamadas multiplica dentro desse while só pra você entender que não está tendo utilidade nenhuma essas duas recursividades. O codigo pode ficar mais simples quando entender de verdade.
     

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    int potence(int base, int potencia)
    {
    	int result; 
    	if(potencia>1)
    	{
    		result = base*potence(base, potencia-1);
    	}
    	else 
    	{
    		result = base;
    	}
    
    	// faça tabelas pra mostrar o que está acontecendo a cada passo...
    	printf("base=%i, potencia atual=%i, resutadoAtual=%i\n", base, potencia, result);
    	// exercicio: entenda porque na tabela a primeira potencia que aparece tem valor 1
    
    	return result;
    }
    
    int main()
    {
    	int base = 3;
    	int potencia = 4;
    	int resutado = potence( base,  potencia);
    	printf("resutado de %i^%i = %i\n", base, potencia, resutado);
    	return 0;
    }
    
    // sem usar tabela ficaria assim:
    int potence2(int base, int potencia)
    {
    	if(potencia>1)
    	{
    		return base*potence2(base, potencia-1);
    	}
    	else 
    	{
    		return base;
    	}
    }

     

    • Curtir 1
    • Amei 1
  18. 11 horas atrás, devair1010 disse:

    e não está funcionando , por que você criou a variáveL  i  duas vezes

    desculpa... culpa minha. Não vi isso. Mas isso ai o compilador mostra e é simples de resolver. Sr. nagatone, já deve entender quando acontecer isso.

    Agora olhe o que encontrei nesse fonte do senhor:

    tem que ser delcarado char *nome. E não char nome. E como você combinou isso como ponteiro de char, então não é necessário passar o endereço da variavel, e sim o ponteiro. veja como funcionou aqui pra mim:
     

    
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    int main()
    {
    	int i, n, k, turmaA, turmaB, matricula;
    	char *nome; // isso deveria ser assim?
    
    	printf("Insira a quatidade de alunos na turma A: ");
    	scanf("%i", &n);
    
    	for(int j=0; j<n; j++)
    	{
    		printf("Digite o nome do aluno: ");
    		scanf("%s", nome); // e aqui muda, ja que declarou como char*
    		// o que aconteceu é que você fez sua variavel nome receber um valor maior
    		// do que o combinado na sua antiga declaração... ai, isso tava sobrescrevendo 
    		// o conteudo da variavel n. 
    		// se voltar ao que era antes, isso aqui vai mostrar porque sua 
    		// condicional do for não para:
    		// printf("= %i %i ", j, n);
    
    		printf("Digite a matricula do aluno: ");
    		scanf("%d", &matricula);
    		//mudei aqui só pra facilitar, mas use sua logica... 
    		while(matricula<0)
    		{
    			printf("Matricula invalida! Insira novamente sua matricula: ");
    			scanf("%d", &matricula);
    		}
    	}
    	return 0;
    }

     

    • Amei 2
  19. 2 main no mesmo corpo?

    recursividade nada mais é do que uma função em que dentro dela tem uma chamada pra ela mesma.
    a recursividade a gente usa a todo momento. Quando a gente faz por exemplo uma divisão, enquanto o resto não for zero, a gente continua fazendo a divisão... Ou, se preferir, usa um mecanismo de poda para parar a divisão, como por exemplo nas dizimas periódicas. O mecanismo de poda pode ser um valor que você passa por parametro mas é reduzido em 1 a cada vez que a função é chamada. Ai, quando esse valor é zero, a condicional, dentro dessa função que é recursiva  vai testar se é zero. Se for, ela para de chamar a função.

    Eu usei recursividade na impressão dos nós que existem nesse codigo:
    https://tivideotutoriais.blogspot.com/2021/09/linguagem-c-trabalhando-com-nos-lista.html

     

    outros exemplos, mas em javaScript:

    http://tivideotutoriais.blogspot.com/2020/09/recursividade-e-vida.html

    http://tivideotutoriais.blogspot.com/2020/09/recursividade.html

    Olhe que a função galho, responsavel por fazer novas linhas, tem outra chamada para galho. Note também que foi usado um mecanismo de poda, para impediro o crescimento infinito de novos galhos.
    você poderá ver isso em arvores, listas encadeadas, nós... é bem usado na computação, mas é um mecanismo que deve ser evitado se não for usado com sabedoria e responsabilidade. Normalmente só usamos isso quando existirão dois caminhos... um que poda em algum momento e você está certo de que isso acontecera... e quando quer que continue crescendo.

    Esse seu fonte pode ser feito de varias formas. Usando laço for, ou recursividade. vou lhe mostrar alguns exemplos.
     

    
    #include<stdio.h>
    #include<stdlib.h>
    
    // isso não é recursividade...
    // porque? porque dentro da funão não existe
    // chamada pra ela mesma
    int fatorial1(int n)
    {
    	int resp=1;
    	while(n>1)
    	{
    		resp*=n;
    		n--;
    	}
    	return resp;
    }
    
    // essa é recursividade...
    // porque? porque? porque? adivinha...
    int fatorial2(int n)
    {
    	int resp=n;	
    	if(n>1) // mecanismo de poda
    	{
    		resp*=fatorial2(n-1); // olha aqui!
    	}
    	else
    	{
    		return 1;
    	}
    	return resp;
    }
    
    // as vezes você vai querer usar alguma
    // struct (objeto) na recursividade e ai, 
    // só com ponteiro pra atualizar seus valores
    void fatorial3(int *n)
    {
    	int temp=*n-1;
    	if(*n>1) // mecanismo de poda
    	{
    		fatorial3(&temp); // olha aqui!
    		*n*=temp;
    	}
    }
    
    int main()
    {
    	int resp1 = fatorial1(5);
    	printf("resp1: %i\n", resp1);
    
    	int resp2 = fatorial2(5);
    	printf("resp2: %i\n", resp2);
    
    	int resp3 = 5;
    	fatorial3(&resp3);
    	printf("resp3: %i\n", resp3);
    
    	// o mesmo pode ser feito com sua potenciação
    }
    

     

    • Obrigado 2
  20. tá... mas e ai... qual a dificuldade disso?
    você não sabe por onde começar? O que é uma função?
    Olha o exemplo:

     

    
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    void faz1(int a)
    {
    	a=4321;
    }
    
    void faz2(int *a)
    {
    	*a = 1234;
    }
    
    int main()
    {
    	int a=777;
    
    	// envia apenas uma copia
    	faz1(a);
    	printf("não mudou: %i\n", a);
    
    	// envia o endereço que receberá a resposta
    	faz2(&a);
    	printf("mudou: %i\n", a);
    	return 0;
    }

     

    Pra compilar é assim no gcc:

    gcc nomeArquivo.c -o nomeQueQuer

  21. você pode usar um laço for... assim:

     

    printf("Insira a quatidade de alunos na turma A: ");
    scanf("%d", &n);
    
    //a partir do n fornecido, repetir n vezes
    for(int i=0; i<n; i++)
    {
                        printf("Digite o nome do aluno: ");
                        scanf("%s",&nome);
                        getchar();
    
                        printf("Digite a matricula do aluno: ");
                        scanf("%d", &matricula);
                        // não entendi porque essa condição assim, mas pode usar como o devair mostrou também... 
                        while(matricula < 999999 && matricula > 111111)
                        {
                            printf("Matricula invalida! Insira novamente sua matricula: ");
                            scanf("%d", &matricula);
                        }
    }

     

    • Obrigado 1

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades 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

×
×
  • Criar novo...

 

GRÁTIS: ebook Redes Wi-Fi – 2ª Edição

EBOOK GRÁTIS!

CLIQUE AQUI E BAIXE AGORA MESMO!