ayuda con programa...
 

hola amigos!
ya no se que hacer, la verdad, estoy tratando de resolver un programa que me encargaron en la universidad...

se trata de un programa que al ingresar una cierta cantidad (por ej. 2580), me indique cuantos billetes y/o monedas se necesitan para completar tal cantidad... de acuerdo al ejemplo:

cantidad = 2580

billetes cantidad

1000...............2

500.................1

200

100

50..................1

20..................1

10..................1

5

estaba pensando en utilizar la estructura case-of, pero no tengo idea de como estructurarlo.

Necesito de su ayuda por favor...
espero y me puedan ayudar,

GRACIAS!!!

no te entiendo muy bien será que he tenido mucho trabajo jejej, pero lo que entiendo es que tienes por ej 2580 botellas y quieres saber el precio total de esta en billetes, si es asi ttendras que hacer un calculo matematico, lo intentaré hacer un ejemplo

Aqui hay un ejemplo en la cual colocas cuanto vale 1 elemento y la cantidad de elemntos, entonces lo multiplica y lo pasa a caracter como el resultado..

Si no es eso lo que querias hacer te dejo la estructura del Case:

CASE Variable OF

constante1: begin instrucción(es); end;

const2: begin instrucción(es); end;

const3: begin instrucción(es); end;

else begin instrucción(es); end

END;

FUENTE: Aqui


54LU2

uppsss se me olvido poner la descarga para el ejemplo http://rapidshare.com/files/21230459...adbilletes.rar:D:D:D:D:D:D

esta hecho en delphi 2009

se trata de un programa que al ingresar una cierta cantidad (por ej. 2580), me indique cuantos billetes y/o monedas se necesitan para completar tal cantidad... de acuerdo al ejemplo:

cantidad = 2580

billetes cantidad

1000...............2

500.................1

200

100

50..................1

20..................1

10..................1

5

Mira a ver si esto te vale:

En un form he puesto un boton, un edit y un memo para los resutlados

y en el onclick del boton, esto:

procedure TForm1.Button1Click(Sender: TObject);
var a:longint;
b:longint;
const billetes:array[0..7] of longint=(1000,500,200,100,50,20,10,5);
function completar(valor:longint; hasta:longint):string;
begin
result:=inttostr(valor);
while length(result)<hasta do
result:=result+'.'
end;
begin
a:=strtointdef(edit1.text,-1);
b:=0;
while (a>billetes[7]) do
begin
if (a div (billetes[b]))>0 then
begin
memo1.lines.add(completar(billetes[b],20)+inttostr(a div billetes[b]));
a:=a-((a div billetes[b])*billetes[b]);
end
else
memo1.lines.add(completar(billetes[b],20)+'0');
b:=b+1;
end;
if a>0 then
memo1.lines.add('En monedas: '+inttostr(a));
end;

No se que quieres hacer complicandote con una estructura de case, ...

Espero te sirva.

Saludos.
Nove:o

Tienes una cantidad inicial R (2580 en tu ejemplo). Si divides esa cantidad entre el valor del billete de mayor denominación (1000 en tu ejemplo) obtienes cierta cantidad (2 en tu ejemplo) y te sobra algo (580 en tu ejemplo). Este sobrante o residuo es lo que ya no puedes pagar con billetes de 1000.

Veamos qué llevamos hasta el momento:

Código Delphi [-]
M = R div 1000; // M será la división R/1000 (el 2 del ejemplo)
R = R mod 1000; // R será ahora el residuo de la división R/1000 (el sobrante de 580)

Ok. Ahora que ya cubrimos los billetes de 1000, procedamos con los de 500. Los pasos son similares. Dividimos la cantidad R (580) entre el valor del billete de más alta denominación (omitiendo el de 1000 que ya usamos). Eso nos dará el número de biletes de 500 que necesitamos. El sobrante (80) es lo que ya no podemos pagar con billetes de quinientos.

Así vamos:

Código Delphi [-]
Q := R div 500; // Q será la división R/500
R := R mod 500; // R será ahora el residuo de la división R/500

Hacemos lo mismo con las siguientes denominaciones (200 y 100):

Código Delphi [-]
D := R div 200; // Q será la división R/200
R := R mod 200; // R será ahora el residuo de la división R/200

C := R div 100; // C será la división R/100
R := R mod 100; // R será ahora el residuo de la división R/100

Claro que, en el ejemplo, el sobrante en este paso es 80 por lo que D y C serán 0, pero en el caso general podrán ser distintos.

Espero que ya te vayas haciendo la idea. Seguimos con las denominaciones (50, 20, 10, 5)

Código Delphi [-]
Cq := R div 50;
R := R mod 50;

V := R div 20;
R := R mod 20;

Dz := R div 10;
R := R mod 10;

Cn := R div 5;
R := R mod 5;

Al final de esto, lo que tenemos son las variables (enteras) M, Q, D, C, Cq, V, Dz, Cn con el número de billetes y/o monedas de cada denominación, necesarios para pagar el importe original. El residuo que queda (en R) es el número de pesos (0 en tu ejemplo).

// Saludos

Tal y como yo lo veo, la cosa sería ver cuántos billetes de 1000 entran en esa cantidad dada, y luego trabajar con el resto de la misma manera: cuántos billetes de 500 entran en el resto, luego cuántos billetes de 200 entran, luego de 100, luego de 50, ... hasta llegar a la cantidad final.

Puedes usar las instrucciones div y mod para ello.

Un saludo.

Edito: justamente lo que te ha explicado roman encima de mi mensaje :D.

pues , nada que ver con lo que yo habia dicho :D :D :D :D, es que en ese ratito estaba medio mariado con otro programa XD :D :D :D