dontpanic

Teu programa tá correto. É que a parte do divisor da função dá zero mesmo as vezes. Pra consertar isso você pode tentar separar a função em dividendo e divisor, e testar se o divisor é diferente de zero a cada iteração. Program funcao;VAR F: Real; G: Real; x,y: integer; t: integer; Begin For x:= 1 to 10 do begin t := x*x; for y:= 0 to 5 do begin F := (t*t) + (3*t) + (y*y); G := (t*y) - (5*y) - (3*t) + 15; if (G <> 0) then writeln(F/G); end; end; End.

Ué... é o somatório da função. Soma = 0; Soma = Soma + 1/1! --> 0 + 1/1! Soma = Soma + 1/2! --> 0 + 1/1! + 1/2! Soma = Soma + 1/3! --> 0 + 1/1! + 1/2! + 1/3! ...etc. O zero no começo é só pra inicializar a variável. Em algumas linguagens de programação, se você usar uma variável sem inicializar ela antes, pode dar alguns problemas pois o valor fica indefinido. Não lembro se no Java precisa fazer isso... mas não faz mal nenhum garantir.

public static double somaS(int num) { double soma = 0; while (num > 0) { soma = soma + (1 / fatorial(num)); --num; } return soma; }

A sintaxe do FOR é: for (<inicio>; <condição>; <incremento>) { ... } A parte do <inicio> é opcional, mas você ainda precisa colocar o ponto e vírgula pro compilador saber o que é <inicio> e o que é <condição>. Se quiser você pode substituir aquilo por um while pra ficar mais fácil de explicar. while (num > 0) { soma = soma + (1 / fatorial(num)); --num;} Quanto a segunda pergunta, aquele +1 da equação é o mesmo que (1 / fatorial(1)). Fatorial de 1 é 1... e (1 / 1) = 1 também. Então isso: 1/3! + 1/2! + 1 É o mesmo que isso: 1/3! + 1/2! + 1/1! Como o seu laço de repetição vai de (1 / NUM!) até (1 / 1!), então você já tá somando tudo.

No google tem um monte de códigos prontos de árvore trie em C e C++. Daí você se preocupa apenas com a lógica da tua struct e de percorrer o texto.

Cara, eu sei como funciona uma árvore trie... o que eu tô tentando dizer, é que por padrão a árvore começa vazia. O programador precisa adicionar esses valores. Por exemplo, você tem uma estrutura assim: struct No { struct No* elementos[255]; // vetor que vai guardar os ponteiros pras próximas folhas ...}Você cria a raiz da tua arvore:struct No* raiz; Começa a ler o texto: "teste testando" Adiciona (t). O algoritmo de inserção procura a posição de 't' da raiz. Se for NULL, adiciona a posição. raiz->elementos[(posição de t)] = malloc(blablabla); Depois você lê o "te", daí procura na raiz a posição do "t" e adiciona o "e": raiz->elementos['posição de t']->elementos['posiçao de e em t'] = malloc(blablabla); Depois adiciona o "tes". Procura a posição de 't', depois a posição de 'e' em t, e adiciona o 's' em 'e'. raiz->elementos['posição de t']->elementos['posição de e em t']->elementos['posição de s em e'] = malloc(...); E vai repetindo isso até ler o texto inteiro, de modo que no final você tenha uma árvore assim: [null, null, null, null, ... 't', null, null, ...] | [null, null, ... 'e', null, null, ...] | [... 's', ...] | [... 't', ...] | / \ / \ [... 'e'] ['a', ...] | [... 'n', ...]...etcOu seja, é você quem insere os valores na árvore. Eles não estão lá por padrão. Apenas as posições estão lá, mas elas começam vazias.

Pelo que você tá dizendo aí, deveria ter compilado sem problemas. No mingw-get você selecionou os pacotes certos pra ele? mingw32-base mingw32-binutils mingw32-gcc Na sua pasta bin você tá conseguindo ver todos os executáveis dele?

Eu não entendi. Pra percorrer a árvore e encontrar as combinações, aquelas combinações precisam ser adicionadas antes, né? Como a árvore vai saber que o elemento "u" da raiz tem uma folha "-ma" e outra folha "-niversal" se você não inserir elas?

Qual foi o método que você usou pra instalar, e qual o método que usou pra compilar? Ex: que pasta instalou? que comando usou? arrumou sua variável PATH?

@ Cara, ele tá iniciando... a ideia aqui não é fazer o algoritmo mais eficiente. Apenas um algoritmo legível, que seja próprio pra aprendizado.

Acho que não precisa daquela função de força bruta lá. Basicamente você só precisa mesmo percorrer o texto normalmente, fazendo as inserções. Exemplo: "uma função de transformação perfeita" Adiciona (u) Adiciona (um) (a função de inserir da árvore trie vai achar o nó "u" e inserir "um" como uma folha de "u") Adiciona (uma) (mesma coisa... a árvore procura "um" e adiciona "uma" como folha dele) (espaço) --> não faz nada Adiciona (f) Adiciona (fu) em f Adiciona (fun) em fu Adiciona (funç) em fun etc. Ou seja, é só separar o texto em palavras, e adicionar todas as substrings daquela palavra na árvore.

Passar um numero pra extenso: 1 - Divide o número em casas decimais 2 - Depois use alguma estrutura de repetição que recebe as casas decimais e imprime de acordo. Pra dividir o número em casas decimais: numero = 1234; ((numero % 10000) - (numero % 1000)) / 1000 = 1 ((numero % 1000) - (numero % 100)) / 100 = 2 ((numero % 100) - (numero % 10)) / 10 = 3 ((numero % 10) - (numero % 1)) / 1 = 4 Passar um numero de decimal pra binario: 1 - Divide ele por 2 sucessivamente até o resto ser 0 ou 1. 2 - A cada divisão, você adiciona o resto num array que vai representar o numero em binário (precisa adicionar no array da direita pra esquerda) numero = 1234; 1234 % 2 = [0] numero = 1234 / 2; 617 % 2 = [1] numero = 617 / 2; 308 % 2 = [0] numero = 308 / 2; 154 % 2 = [0] numero = 154 / 2; 77 % 2 = [1] numero = 77 / 2; 38 % 2 = [0] numero = 38 / 2; 19 % 2 = [1] numero = 19 / 2; 9 % 2 = [1] numero = 9 / 2; 4 % 2 = [0] numero = 4 / 2; 2 % 2 = [0] numero = 2 / 2; [1] [0100 1101 0010] Passar o número de decimal pra hexa e octal: 1 - Considerando que você já converteu eles pra binário, essa parte é a mais fácil. Pra hexadecimal, basta percorrer o teu array, dividir os bits em grupos de 4, e converter eles de volta pra decimal. numero = 1234; binario[] = { 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0 }; Usando os 4 ultimos números, da direita pra esquerda: 2^0 x binario[11] = 0 + 2^1 x binario[10] = 2 + 2^2 x binario[9] = 0 + 2^3 x binario[8] = 0 O resultado dá 2. Em hexa 2 é [2] mesmo. Os próximos 4 números: 2^0 x binario[7] = 1 + 2^1 x binario[6] = 0 + 2^2 x binario[5] = 4 + 2^3 x binario[4] = 8 O resultado dá 13. Em hexa é [D]. Os próximos 4 números: 2^0 x binario[3] = 0 + 2^1 x binario[2] = 0 + 2^2 x binario[1] = 4 + 2^3 x binario[0] = 0 O resultado é 4. Em hexa é [4] mesmo. Juntando tudo: [4D2], que é o mesmo que 1234 em hexa. Pra octal é a mesma lógica, mas em vez de separar os bits em grupos de 4, separa em grupos de 3.

public int TrocoMaior(int y) { reset(); int vlr = Convert.ToInt32(txtValor.Text); int valor1 = Convert.ToInt32(txtValor.Text); if ((vlr % 2) && (vlr > 4)) { cinco += 1; vlr -= 5; } if (!(vlr % 2) && (vlr > 10)) { cinco += 2; vlr -= 10; } while (vlr > 1) { if (vlr / 2) { vlr -= 2; dois++; } if (vlr / 10) { vlr -= 10; dez++; } if (vlr / 20) { vlr -= 20; vinte++; } if (vlr / 50) { vlr -= 50; cinquenta++; } if (vlr / 100) { vlr -= 100; cem++; } } if (vlr != 0) { MessageBox.Show("Notas indisponiveis para esse valor"); } else { ... } return (vlr); } @ Eu testei aqui num compilador online e deu certo, não tava sobrando valor nenhum no final. Mas testei apenas com alguns números. Quais os valores que estão dando apenas aproximação?

Acabei de pensar num jeito aqui pra facilitar tua vida na hora de lidar com valores ímpares no algoritmo de menor qtd de notas. A lógica é a seguinte: Qualquer valor que o usuário digitar, ou ele terá UMA nota de 5, ou terá NENHUMA nota de 5. Ele nunca terá duas ou mais pois nesse caso o algoritmo vai usar notas de 10. Então no começo do algoritmo você testa se o número é impar ou divisível por 5... caso isso seja verdadeiro, você retira uma nota de 5 do valor e faz o resto do algoritmo normalmente, mas sem usar mais notas de 5. 801 --> Impar 801 - 5 = 796. 7 x 100 1 x 50 2 x 20 3 x 2 [1 x 5] 103 --> Impar 103 - 5 = 98 1 x 50 2 x 20 4 x 2 [1 x 5] public int trocoMenor(int x) { reset(); //conversão e criação de variáveis int vlr = Convert.ToInt32(txtValor.Text); int valor1 = Convert.ToInt32(txtValor.Text); if ((vlr % 2) && (vlr > 4)) { vlr -= 5; cinco += 1; } cem = vlr / 100; vlr = vlr % 100; cinquenta = vlr / 50; vlr = vlr % 50; vinte = vlr / 20; vlr = vlr % 20; dez = vlr / 10; vlr = vlr % 10; dois = vlr / 2; vlr = vlr % 2; //Caso 'valor' seja diferente de 0, não existe saque. if (vlr != 0) { MessageBox.Show("o DontPanic falou besteira... esqueça tudo e use o algoritmo anterior mesmo"); } else { // ... } return (vlr); }

A = 97 Z = 122 Pelo que entendi, você quer que a tua função lide apenas com as 26 letras do alfabeto, certo? Tipo, se a letra for Z e a chave for 1, em vez de transformar o Z em "{" você quer transformar ele em "A", é isso? Considere A é igual a 1 e Z é igual a 26. Se a chave for igual a 1, em vez de transformar os caracteres em [C + 1], você pode transformar eles em [ (C+1) % 26 ]. Desse modo, quando a chave for igual a 1 e o caractere a ser transformado for igual a Z, em vez de transformar ele em 27 (26 + 1), você transforma ele em 1 ((26+1) % 26). E pra pegar o valor dele na tabela ASCII, é só adicionar depois 97, que é o valor do primeiro caractere na tabela ('a'). Então, isso: src[n] = src[n] + chave;Vira isso: src[n] = (src[n] - 97 + chave) % 26;src[n] = src[n] + 97;Na prática você não precisa transformar eles entre 1-26 pra depois somar 97.Você pode simplesmente pegar o modulo de 122. Dá no mesmo. src[n] = (src[n] + chave) % 122;Não testei o código aqui.

Existe um limite pros valores que o float consegue representar. Então se você usar um número muito alto, e o resultado dele for maior que a capacidade do float, ele vai dar erro. Pra resolver isso você pode usar "double" em vez de "float", que tem uma capacidade maior.

Não há diferença nenhuma quanto a posição do asterisco no momento da declaração da variável. O compilador vai analisar o teu código descartando todos os espaços em branco, comentários, trocas de linha, tabs, etc. Então: 1) int* x; 2) int *x; 3) int*x; 4) int * x ; 5) int* /* ola amiguinho */ x /* eu sou o dolinho! */; Todas as declarações acima são exatamente identicas pro compilador, pois ele enxerga essa expressão assim: <identificador chamado "x"> <tipo do identificador "x"> E o tipo de x será "int*". "int*" e "int" são coisas completamente diferentes pro compilador. Pra testar isso você pode rodar esse código no teu compilador: char x = 'a'; char* y; y = &x;printf("%d\n", sizeof(x));printf("%d\n", sizeof(y));Dependendo do teu compilador e sistema operacional, você vai ver que x vai ter um tamanho na memória diferente de y.Por isso, se a tua função tá retornando uma variável do tipo "int*", então na declaração dela é importante dizer pro compilador o tipo de retorno certo, pra ele poder alocar a memória suficiente. Quanto a posição do asterisco que você vai usar... depende só do programador. Eu sempre achei que fazia mais sentido colar o asterisco no tipo: int* teste(float* x, float* y); Porque quando meu cerebro olha pra essa expressão, é mais fácil pra mim entender que x e y são do tipo float*, e que a função retorna um int*. O pessoal que compila o kernel do linux as vezes usam algo assim: int * teste(float *x, float *y); Provavelmente pra eles a expressão faz mais sentido desse jeito. Fica mais fácil ver que x e y são ponteiros pro tipo float. Não existe um jeito mais correto que outro. A única coisa importante é que você crie o habito de ser consistente. Se escolher um estilo em particular, use ele durante o código inteiro... não fique misturando as coisas. Além disso, se estiver trabalhando no código de outra pessoa, prefira usar o estilo que ele(a) adotou pra aquele código, pra também não ficar misturando. É isso.

Google me disse que sim. Existe uma API do próprio firebird que você pode usar pra se comunicar através do seu código em C/C++, ou você pode fazer o teu programa se comunicar através do ODBC e aí usar algum driver odbc pro firebird (que o google também disse que existe). http://www.firebirdfaq.org/faq233/

Eu não entendi. Os valores estão indo pra A depois estão sendo passados pra B (+10%), na ordem que o problema especifica. Não vejo erro de lógica nem de interpretação do problema. Em nenhum ponto o problema diz que os valores devem ser passados DE a PARA b. O problema apenas diz que os mesmos valores devem ir também pra b. Mesmo que o problema dissesse explicitamente isso, (e não diz) ainda não acho que a solução está errada. Até onde eu lembro, computação é uma ciência exata. Você tem uma ou mais entradas, que resultam em uma ou mais saídas. Respeitosamente discordo da sua última frase, pois se as saídas estão corretas pra qualquer que sejam suas entradas, o algoritmo está correto. Não existe algoritmo funcional e incorreto ao mesmo tempo. Assim como não existe uma equação matemática que dê os resultados esperados em todos os casos mas que seja incorreta, ou "menos correta" que outra.

Pode deixar sem ele mesmo. É que eu tô sem compilador agora daí eu coloquei só pra ver a lógica mesmo...

Ah, foi mal... normalmente essa equação é 1/0! + 1/1! + 1/2!...etc. Notei que no teu primeiro post não tem o "1/0!". Basta retirar então aquele "soma = 1" do começo e deixar em zero mesmo. public static float somaS(int num) { float soma = 0; for (int x=num; x > 0; --x) soma = soma + (1/fatorial(x)); return soma; }

Ah, entendi... pensei que não estava conseguindo chamar o método somaS de outro arquivo. Então... o método soma nesse problema vai receber um valor N (que vai ser o tamanho da equação) e vai retornar a soma dos elementos da equação. Se N for igual a 3: soma = 1/fatorial(1) + 1/fatorial(2) + 1/fatorial(3) Se N for igual a 5: soma = 1/fatorial(1) + 1/fatorial(2) + 1/fatorial(3) + 1/fatorial(4) + 1/fatorial(5) É só fazer um loop simples contando de 1 até N: public float somaS(int num) { float soma = 1; // pra não precisar somar aquele "1" solitário na equação, a gente já inicializa soma em "1". for (int x=num; x > 0; --x) soma = soma + 1/fatorial(x); return soma; }

A função somaS tá em outra classe? Se sim, vai ter que fazer fatorial public.

public class Teste { public static void main(String[] args) { // cria o vetor aqui // somaS(numero); } public float fatorial(float x) { // ... } public float somaS(int x) { // ... // cria o laço for aqui percorrendo o vetor e chamando a função fatorial quando necessário // fat = fatorial(n); } }

Primeiro cria os dois vetores: Program teste;var matrizA : Array[1..10] of Real; matrizB : Array[1..10] of Real;Depois no teu programa você cria um laço de repetição do tipo FOR.Primeiro lê um número, adiciona ele na matrizA, em seguida adiciona o mesmo valor + 10% na matrizB. Readln(n); matrizA[x] := n; matrizB[x] := n + (n / 10);