Les presento mi calculadora de ncr!!!(ahora si que si!!!)

[flacc]

ok, ok pero para que ese tono...
yo solo quería hacerla un poco mejor...y pense que getch() era lo mismo que getchar(),
ademas no tenía idea de que era parte de conio2.h, yo solo la puse para usar gotoxy(), ademas eso lo saque de un ejemplo en la red, por que no me daba pausa con getchar(), o no la se usar..
en fin... seguiré trabajando haber si queda mejor...
saludoss

[leogtz]

Si el getchar() no hace su trabajo quiere decir que el buffer no está limpio.

[flacc]

Si el getchar() no hace su trabajo quiere decir que el buffer no está limpio.

entonces como limpio el buffer...

[h0oke]

Puedes utilizar:

Código (c) [Seleccionar] Expandir

fflush(stdin); // Limpia el buffer de entrada

EDIT: Si utilizas los pauses a través de system("Pause"), getchar(), etc, únicamente para ver los resultados, es preferible que para ahorrarte ese tipo de cosas, ejecutes tu programa a través de una consola.

[Gallu]

Puedes utilizar:

Código (c) [Seleccionar] Expandir

fflush(stdin); // Limpia el buffer de entrada

EDIT: Si utilizas los pauses a través de system("Pause"), getchar(), etc, únicamente para ver los resultados, es preferible que para ahorrarte ese tipo de cosas, ejecutes tu programa a través de una consola.

Se ha comentado ya acerca del uso del fflush(stdin), mirate lo siguiente

http://foro.elhacker.net/programacion_cc/lo_que_no_hay_que_hacer_en_cc_nivel_basico-t277729.0.html

para limpiar el buffer de entrada es mejor usar

Código (c) [Seleccionar] Expandir


while(getchar() !='\n');


[nicolas_cof]

Antes que nada mini_nauta felicitaciones por emprenderte a codear!

Aca te dejo tu codigo con algunas mejoras y mas portable, cualquier duda pegue el grito nomas

Código [Seleccionar] Expandir

#include <stdio.h>

int
main( void )
{
signed long n, k, nf, kf, resta, restaf, x, y;
char opcion;
int ch;

do
{
printf( "\nIngrese n y k: " );
fflush( stdout);
scanf( "%ld %ld", &n, &k );
while ( (ch = fgetc( stdin )) != EOF && ch != '\n' );

nf = 1;
kf = 1;
resta = n - k;
restaf = 1;

while ( n > 1 ) /* factorial de n */
{
nf *= n--;
}

while ( k > 1 ) /* factorial de k */
{
kf *= k--;
}

while ( resta > 1 ) /* factorial de (n - k) */
{
restaf *= resta--;
}

x = kf * restaf; /* k! * (n - k)! */
y = nf / x; /* n! / (k! * (n - k)!) */

/* resultados */
printf( "\nn! = %ld\n"
"k! = %ld\n"
"(n - k)! = %ld\n"
"k! * (n - k)! = %ld\n"
"n! / [k! (n - k)!] = %ld\n"
"--------------------------\n"
"Resultado final (ncr): %ld\n", nf, kf, restaf, x, y, y );

printf( "\nContinuar? S/n: " );
fflush( stdout );
scanf( "%c", &opcion );
while ( (ch = fgetc( stdin )) != EOF && ch != '\n' );
}
while ( opcion == 's' || opcion == 'S' );

return 0;
}

Salu10.

[Horricreu]

¡Exacto! A esto me refería... a ver si puedo ver el código multiplataforma

Saludos

PD: perdona si te ha parecido un tono agresivo, sólo quería ayudarte a "mejorar"

Advertencia - mientras estabas escribiendo, una nueva respuesta fue publicada. Probablemente desees revisar tu mensaje

[flacc]

gracias... justamente buscaba poner esa opción de si continuar o no... ....

[leosansan]

[Recopilatorio] Sources interesantes

hola, se preguntarán alguno que diablos es ncr, bueno mas especificamente es una parte del Teorema del binomio.

Mas especificamente es:

Entonces como en mis ratos libres y de oseo aprendo C, y dado que no tengo para comprarme una calculadora de esas Casio y que solo tengo una de esas chinas o japonesas, en fin, me hice mi propia calculadora para eso que entrega detalladamente los resultados para comprobarlos(si quieren a mano)...

..................................................

El uso de los factoriales para el cálculo de los números combinatorios tiene el inconveniente de su tamaño, desbordan las posibilidades de C/C++ desde 14 o 15. Una muestra de la salida de tu código:

Código (cpp) [Seleccionar] Expandir



Ingrese n y k: 16
14

n! = 2004189184
k! = 1278945280
(n - k)! = 2
k! * (n - k)! = -1737076736
n! / [k! (n - k)!] = -1
--------------------------
Resultado final (ncr): -1


Decepcionante, ¿verdad?.

Para evitarlo existe otra forma de calcular los números combinatorios que técnicamente consiste en dividir las variaciones de n tomados de p en p entre las permutaciones de p. Vamos que con un ejemplo se ve que es más fácil de lo que parece:

Combinaciones(15,4)= 15/4 * 14/3 * 13/2 * 12/1.

Y aún así se puede mejorar la eficiencia del cálculo. Por ejemplo:

Combinaciones(15,12)=15/12*14/11*13/10*12/9*11/8*10/7*.....

Muy largo, ¿verdad?. Pero eso se puede remediar aprovechado una propiedad de los números combinatorios que establece que :

Combinaciones(n,p)=Combinaciones(n,n-p)

Y aplicada al caso último daría:

Combinaciones(15,12)=Combinaciones(15,3)=15/3 *14/2 *13/1

Mucho más breve que el anterior método.

Así, aprovechando estas dos propiedades, la primera para cuando es inferior a la mitad de n y la segunda para cuando es superior surge el código mágico que te permitirá "meter" de exponente 20 y más sin problemas de que el C/C++ "cruja" soltando números "raros" porque se salen de sus capacidades:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>

int comb(int n,int p)
{
   int i;
   if (n < 0 || p < 0 || p > n) return 0;
   float c = 1;
   if (p>n/2)
       p=n-p;
   for ( p; p>=1; p--,n--)
       c*= (float)n/p;
   return (int)c;
}
int main()
{
   int n, p, num , y;
   while (1){
       printf("\n\nIngrese n (0 para SALIR): " );
   if (n==0)
       break;
   fflush( stdout);
   scanf(" %d", &n);
   printf("\nIngrese p : " );
   fflush( stdout);
   scanf(" %d", &p);
   printf("\ncombinaciones(%d,%d)= %d",n,p,comb(n,p));
   fflush( stdout);
   }
   return 0;
}


Y ahora puedo meter números más grandes:

Código (cpp) [Seleccionar] Expandir


Ingrese n (0 para SALIR): 40

Ingrese p : 35

combinaciones(40,35)= 658008

Ingrese n (0 para SALIR): 35

Ingrese p : 12

combinaciones(35,12)= 834451776


Saluditos!. ...  

P.D: Más en http://foro.elhacker.net/programacion_cc/teorema_binomial-t388312.0.html