isrnick

Não costumo usar então não sei te indicar o que é melhor, mas buscando no google é fácil achar editor free (tem até um editor online).

@Nachtwolf Nesse caso não tem mesmo opção, os dados nesses arquivos foram definidos pelo responsável por criar o programa, você poderia tentar abrir num programa visualizador e editor de hexadecimal e tentar decifrar o que cada bloco de dados contém, mas provavelmente não vai ser nada trivial.

Esses programas e funções das extensões são muitos distintos entre si, praticamente não tem relação nenhuma um com o outro. Mas imagino que os arquivos que você possui com essas extensões vieram juntos e supostamente estão relacionados entre si, então nesse caso é provável que eles não pertençam a nenhum dessas 3 funções conhecidas para essas extensões.

Nenhum dos 2 códigos usam Insertion Sort (ordenação por inserção). O primeiro código usa Selection Sort (ordenação por seleção), enquanto o segundo trata-se de Bubble Sort (ordenação por flutuação). Vou explicar o conceito de cada um desse 3 métodos de ordenação assumindo em todos os casos que deseja-se ordenar uma lista em ordem crescente (o respectivo nome do algoritmo já é uma boa dica de como eles se comportam): Selection Sort (ordenação por seleção): A partir da primeira posição da lista, para cada posição procura entre todos os itens restantes ainda não ordenados da lista qual é o de menor valor, este item encontrado com o menor valor é selecionado para ser movido para a posição atual, para isso o algoritmo faz a troca de posições do item da posição atual com o item de menor valor, assim conforme o algoritmo avança os itens de menor valor vão sendo movidos para cada posição da lista em sequência ficando em ordem crescente, e no fim a lista fica ordenada. Insertion Sort (ordenação por inserção): Percorre a lista, e a cada novo item da lista move o item para a posição tal que mantém todos os itens já analisados da lista ordenados em ordem crescente, para isso conforme necessário move todos os itens analisados anteriormente com valor maior que o item atual uma posição para a frente na lista, abrindo espaço para inserir o item atual na posição correta tal que mantém todos os itens já processados ordenados, quando o último item for inserido a lista estará ordenada. Bubble Sort (ordenação por flutuação): Percorre a lista várias vezes, comparando cada 2 itens consecutivos da lista, e trocando as posições dos itens se o primeiro item tiver valor maior que o segundo, então os números maiores são movidos para o fim da lista, e a cada vez que termina de percorrer a lista inteira o maior número da lista "flutua" para o fim da lista, e os números maiores vão sendo ordenados do fim da lista para o começo. Se percorrer a lista inteira e nenhuma troca for feita pode parar de percorre-la pois ela já está ordenada, ou então pode parar após percorrer N vezes uma lista com N itens pois essa é a quantidade máxima de vezes que precisa para ordenar todos os itens.

Expliquei o que precisa corrigir nos comentários. (Código foi indentando usando https://www.tutorialspoint.com/online_c_formatter.htm ) #include <stdio.h> #include <stdlib.h> #include <math.h> int main() { int x[100],aux,i,j,qdeelementos; i=0; printf("Leitura da lista:\n"); do { printf(" \n [%d] :",i); scanf("%d",&x[i]); i++; } while ((x[i-1]) !=-99 && i<=100); // deveria ser i<100 pois o vetor x não tem índice 100 if (i>100) { // deveria ser i==100 ou i>=100 pela mesma razão qdeelementos=i; } else { qdeelementos= i-1; } printf("%d", qdeelementos); printf("\n============ lista inserida========= \n"); for(i=0; i<qdeelementos;) { printf("-%d",x[i]); i++; } for(i=0; i<qdeelementos; i++) { for(j=0; j<qdeelementos-1; j++) { if( x[j] > x[j+1]) { aux = x[j]; x[j] = x[j+1]; x[i+1] = aux; //O problema está aqui, deveria ser x[j+1] = aux; } } } for(i=0; i<=qdeelementos-1;) { printf("\n -%d",x[i]); i++; } getch(); return 0; }

Como você ainda está começando a aprender C é melhor que sempre use { e } após comandos de controle de fluxo do programa, como for, if, while, etc, mesmo que dentro das chaves só exista 1 comando... E nunca vai ; no final da linha desses comandos (existem alguns poucos casos em que colocar ; nessas linhas é uma opção, e você ainda não chegou no ponto de usar isso, e não será o caso em lugar algum nesse exercício). (Mais pra frente quando já tiver mais prática poderá omitir as chaves quando houver apenas 1 comando, mas primeiro tem que aprender a fazer sempre com chaves. Alguns programadores até preferem sempre usar chaves para manter a consistência do código.) Ok, segue seu código com modificações, fiz apenas essas correções de sintaxe da linguagem C, colocando { e } nos devidos lugares (e removendo os ; onde não deveriam existir), mas não alterei o restante da lógica do seu programa: #include <stdio.h> #include <stdlib.h> int main () { int vet1[5]; int vet2[5], maior, menor, i,j, matriz; for (i=0; i<=4;i++){ printf ("Diga o valor do vetor %d -> ", i+1); scanf ("%d", &vet1[i]); // lê os dados } maior=0; // assume que o maior valor está na primeira posição for (i=1; i<=4;i++){ if (vet1[i] > vet1[maior]){ maior= i; // acha a posição do maior } } for (j=0;j<=4;j++){ menor=0; for (i=1;i<=4;i++){ if (vet1[i] < vet1[menor]){ menor= i; } } vet2[j] = vet1[menor]; vet1[menor] = vet1[maior]; } for (i=0; i<=4; i++){ printf ("%d \n", vet2[i]); // imprime os dados } return 0; } É importante você entender essa parte, note também que fica fácil entender o fluxo dos comandos com todas as chaves { } e com o código bem indentado.

@Flávio Pedroza Em C bool, true e false são definidos da biblioteca stdbool.h, logo se vai usá-los deve incluí-la. (E não está usando as bibliotecas stdlib.h e string.h então não precisa incluí-las.) E aqui está o código do @Flávio Pedroza com apenas algumas modificações para apenas imprimir (escrever) os números não repetidos (não precisando do vetor auxiliar): #include <stdio.h> #include <stdbool.h> /* Leia um vetor com 20 numeros inteiros. Escreva os elementos do vetor eliminando ele- mentos repetidos. */ #define TAM 20 int main() { int vet[TAM], i,j; bool rept; //variavel auxiliar para indicar se existe numero repetido for (i=0; i<TAM; i++) { printf("Digite o %do valor: ", i+1); scanf("%d", &vet[i]); } for (i=0; i<TAM; i++) { rept = false; for (j = 0; j < i; j++) { if (vet[i] == vet[j]) { rept = true; //indica que o numero esta repetido break; } } if (!rept) { //apenas imprime os numeros nao repetidos printf("%d ", vet[i]); } } return 0; }

Mas 0 também é um número inteiro... Ele diz que deve eliminar os repetidos na escrita, ou seja não precisa alterar o vetor, apenas não imprime o número novamente se já tiver impresso, pra isso poderia apenas fazer checar todos os números anteriores do vetor e ver se algum deles é igual ao número atual, se não encontrar nenhum igual então imprime o número atual.

Tentou sem usar start? Colocando só o caminho do arquivo? Normalmente você abre o jogo através de um link? Tem algum parâmetro/configuração extra na linha de comando desse link? Se abrir o Speed.exe clicando nele no Explorer o jogo abre normalmente? Fora isso só consigo pensar em usar runas, que é pra rodar um programa com um usuário específico... Mas não deveria ser necessário.

Seria algo assim: @ECHO OFF :ESPERA TASKLIST /FI "IMAGENAME eq notepad.exe" /FI "STATUS eq running" | FIND /I "notepad.exe" > NUL IF "%errorlevel%"=="1" GOTO ESPERA GOTO INICIO :INICIO TASKLIST /FI "IMAGENAME eq notepad.exe" /FI "STATUS eq running" | FIND /I "notepad.exe" > NUL IF "%errorlevel%"=="1" ( ECHO copiar pasta c:\pasta para d:\pasta aqui GOTO ESPERA ) GOTO INICIO Assumo que o script batch vai ficar sempre rodando, mas quer que ele faça apenas 1 backup quando o aplicativo (no meu exemplo "notepad.exe") está fechado, não infinitos backups, então fiz ele sempre esperar até a próxima vez que o programa abrir novamente após fazer uma cópia/backup.

Não, a ideia é diferente, não fica fazendo divisões pra ver se os números são primos. No crivo de Eratóstenes inicialmente assume-se que todos os números no intervalo são primos (um vetor indica todos inicialmente como true), aí começando do primeiro primo conhecido, o 2, acha todos os múltiplos dele e elimina marcando como não-primos (muda a posição no vetor para false), aí segue até o próximo número após 2 que ainda consta como primo, que é 3, e marca todos os todos os múltiplos de 3 como não-primos, e segue para o próximo número que ainda consta como primo, que é 5, e assim por diante, continuando até chegar na raiz quadrada de 2 milhões que é o intervalo de números que desejamos identificar como primos ou não no nosso caso. Ele usa a característica de que um número só pode ser múltiplo de números primos que vieram antes dele, então conforme vai eliminando os múltiplos dos primos já encontrados, todos os números não-primos no intervalo até o próximo número primo já terão sido eliminados e identificados como tal, sobrando só o próprio próximo número primo corretamente identificado na seqüência. Dê uma lida no artigo da Wikipedia que dá mais detalhes de como o crivo de Eratóstenes funciona. adicionado 32 minutos depois Mas posso fazer uma modificação no algoritmo para eliminar os múltiplos de 2 primeiro separadamente, aí o incremento para encontrar os múltiplos dos outros números primos pode ser 2x o primo: #include <stdio.h> #include <stdbool.h> #include <math.h> int main() { bool primo[2000001] = {false}; int i, j, n, raizQuad; long long somaPrim; n = 2000000; for (i = 2; i <= n; i++){ primo[i] = true; } for (j = 2*2; j <= n; j += 2){ primo[j] = false; } raizQuad = (int) sqrt(n); for (i = 3; i <= raizQuad; i++){ if(primo[i]){ for (j = i*i; j <= n; j += 2*i){ primo[j] = false; } } } somaPrim = 0; for (i = 2; i <= n; i++){ if (primo[i]){ somaPrim += i; } } printf("%lld\n", somaPrim); return 0; }

Segue outra solução que fiz, ainda mais eficiente, usando o crivo de Eratóstenes: https://pt.wikipedia.org/wiki/Crivo_de_Eratóstenes #include <stdio.h> #include <stdbool.h> #include <math.h> int main() { bool primo[2000001] = {false}; int i, j, n, raizQuad; long long somaPrim; n = 2000000; for (i = 2; i <= n; i++){ primo[i] = true; } raizQuad = (int) sqrt(n); for (i = 2; i <= raizQuad; i++){ if(primo[i]){ for (j = i*i; j <= n; j += i){ primo[j] = false; } } } somaPrim = 0; for (i = 2; i <= n; i++){ if (primo[i]){ somaPrim += i; } } printf("%lld\n", somaPrim); return 0; } O tempo de execução desse programa foi de 0.01s, o programa anterior que postei demora de 0.21s a 0.35s, mais de 20 vezes mais lento.

Tenta aumentar o tamanho do buff para 4. setbuf() não serve para o que você pretende fazer aí, o que faz quando usa NULL é desligar o buffer. https://en.cppreference.com/w/c/io/setbuf

Está funcionando corretamente: https://onlinegdb.com/SykbmxWSV #include <stdio.h> #include <stdlib.h> #include <math.h> int main() { double k,pi,numtermos; printf("Digite a quantidade de termos: \n"); scanf("%lf",&numtermos); pi=0; k=0; do { pi = pi + 2 * pow(-1,k) * pow(3,0.5-k) / (2 * k + 1); k=k+1; } while (k < numtermos); printf("Valor de pi:\n"); printf("%lf",pi); getchar(); return 0; } Digite a quantidade de termos: 5 Valor de pi: 3.142605 ...Program finished with exit code 0 Press ENTER to exit console.

Falta inicializar k e pi, fazendo que comecem com valor 0, e a condição do do while também está errada, deve continuar enquanto k for menor que a quantidade de termos.

Poste a sua tentativa para vermos onde está tendo dificuldades ou poste suas dúvidas. Não podemos resolver problemas pelos usuários.

A condição do while está errada, o ciclo do while deve continuar enquanto o erro for maior ou igual a precisão (não menor ou igual). E como postei na primeira resposta a função abs() é para o tipo int, para double a função para obter o valor absoluto é fabs(), e para float a função é fabsf(). https://en.cppreference.com/w/c/numeric/math/fabs -> valor absoluto dos tipos de ponto flutuante https://en.cppreference.com/w/c/numeric/math/abs -> valor absoluto do tipos inteiros

Você precisa postar o código como está atualmente pra vermos qual é o problema e podermos te ajudar. (Leia minha assinatura abaixo para ver como postar códigos no fórum.)

Está tentando usar essa fórmula? Fonte: http://mathworld.wolfram.com/PiFormulas.html Então tem algumas coisas erradas, deveria ser assim: pi = pi + 2 * pow(-1, k) * pow(3, 0.5-k) / (2 * k + 1);

^ não é um operador de potência em C. Em C ^ é um operador binário OU EXCLUSIVO, e realmente não vai funcionar com float. Para calcular potência precisa usar a função pow() da biblioteca math.h (onde xn é calculado fazendo pow(x, n)).

Pi é um número irracional, e sua aproximação não pode ser armazenada como inteiro, precisa guardar como número de ponto flutuante logo o tipo das variáveis deve ser double (ou float). (E para double a função para obter o valor absoluto é fabs().)

O programa não conta quantos primos tem, mas sim faz a soma de todos os números primos abaixo de 2 milhões. Em C o valor 0 (zero) é igual a falso, e qualquer valor diferente de 0 (zero) é igual a verdadeiro. (Isso é válido em muitas linguagens de programação.) (Na prática a biblioteca stdbool.h apenas define macros em que false expande para 0, e true expande para 1. https://en.cppreference.com/w/c/types/boolean ) E quem é Mr Scoth?

Pelo que entendi basta usar essa fórmula para calcular o n-ésimo número da sequência de Fibonacci, e imprimir o resultado. #include <stdio.h> #include <math.h> int main() { int n, fn; printf("Deseja calcular qual numero Fibonnaci? "); scanf(" %d", &n); fn = (int) 1.0/sqrt(5.0) * (pow((1.0 + sqrt(5.0))/2.0, n) - pow((1.0 - sqrt(5.0))/2.0, n)); printf("F(%d) = %d\n", n, fn); return 0; }

.read() retorna uma string, mas pode checar fazendo print(type(mensagem)) . O mais provável é que a string esteja diferente da string comparada, logo não entra no if. Uma situação comum é a em que existe um caractere nova linha '\n' no fim da string do arquivo mas você não incluiu na string do if, logo não serão iguais.

Exatamente por isso, o double é mais preciso e consegue armazenar a resposta correta deste problema sem erros, mas o float não é tão preciso e se torna necessário fazer arredondamentos nas casas menos significativas do número quando o número fica muito grande, nesse caso o erro no resultado final é positivo e o número ficou maior.