Ga naar inhoud
  • 0

Berekenen aantal dozen


Maatwerk

Vraag

Hoi mensen,

 

Ik heb een probleem met het berekenen van het aantal dozen.

 

Ik heb nl een klant die bepaalde producten verstuurd in diverse oplagen.

Hij verstuurd deze in dozen van verschillende formaten.

 

t.w.

kleine doos van 0 tot 500

middel doos van 500 tot 1250

en een grote doos van 1250 tot 2500

 

Bedoeling is dat wanneer de klant een oplage besteld van bv 3000 dus ie dus neemt...

 

Een groote doos van 2500 vel en een kleine van 500 vel

 

Heeft ie een oplage van bv 2600 ook een groote doos van 2500 vel en de rest in de kleine doos.

 

Dus hij moet dus gebruik maken van de maximale doosinhoud en het restant een de kleinst beschikbare doos...

 

Ik zit nu al uren bezig om dit te berekenen in een formule echter ik zit vast. Heeft iemand een idee?

Link naar reactie

Aanbevolen berichten

  • 0

Ik heb een probleem met het berekenen van het aantal dozen.

 

Kijk eens of bijgesloten attachment aan je wensen voldoet.

Scripts zijn m.i. overbodig en recursieve functie niet bruikbaar omdat de laatste stap anders is. Dozen met een meer regelmatige inhoud (500, 1000, 2000) zou makkelijker zijn geweest, maar ja die dozenfabrikant... :-)

 

Groet,

René

Dozen demo.fp7

Link naar reactie
  • 0

Inderdaad een leuke oefening. Ik zat in dezelfde richting te zoeken.

Wiskundig gezien zit je juist maar bij je laatste voorbeeld is het wellicht economischer om:

 

12345

Groot: 4

Middel: 2

Klein: 0

 

hebben, ipv hetgeen de formule voorstelt:

12345

Groot: 4

Middel: 1

Klein: 3

.

Bij het gebruik van 2 middelgrote dozen heb, je ruimte voor 155 exemplaren over in de 2e doos.

 

Bij het gebruik van 1 middelgrote doos en 3 kleine dozen heb je plaats voor 405 exemplaren voor de derde doos. De derde doos bevat slechts 95 exemplaren.

 

Ik ben nog niet uit hoe je dit kan opvangen in een formule.

 

Koen

Link naar reactie
  • 0

Ik kwam tot volgende formule:

 

Let
(
[
oplage =  12345
;
floordoos1 = Floor(Oplage / 2500)
;
ceilingdoos1 = Ceiling(Oplage / 2500)
;
restdoos1 = (ceilingdoos1 * 2500) - Oplage
;
floordoos2 = Floor((Oplage -(floordoos1 * 2500) ) / 1250)
;
ceilingdoos2 = Ceiling((Oplage -(floordoos1 * 2500) ) / 1250)
;
restdoos2 = (floordoos1 * 2500) + (ceilingdoos2 * 1250) - Oplage
;
ceilingdoos3 =  Ceiling((Oplage -(floordoos1 * 2500)  -(floordoos2 * 1250) ) / 500)
;
restdoos3 = (floordoos1 * 2500) + (floordoos2 * 1250) + (ceilingdoos3 * 500) - Oplage
;
minrest =  Min(restdoos1; restdoos2; restdoos3)
;
doos1 = Case (restdoos1 = minrest ; ceilingdoos1 ;  floordoos1)
;
doos2 = Case (restdoos1 = minrest ; floordoos2 ;restdoos2 = minrest ; ceilingdoos2 ;  floordoos2)
;
doos3 = Case (restdoos1 = minrest ; 0 ;restdoos2 = minrest ; 0 ;  ceilingdoos3)
;
result = "Groot: " & doos1 & "¶" & "Middel: " & doos2 & "¶" & "Klein: " & doos3 & "¶"
]
;
result

)

 

Ik probeer hier een configuratie te berekenen met zo min mogelijk plaats in de dozen. (Restwaarde)

 

Koen

Link naar reactie
  • 0

Het is geen recursieve functie. We roepen onszelf niet telkens herop. Voor de enveloppes dupliceer je de functie en voeg je nog een extra doos toe.

 

Let
(
[
oplage =  12345
;
maxdoos1 = 1000
;
maxdoos2 = 500
;
maxdoos3 = 250
;
maxdoos4= 125
;
floordoos1 = Floor(Oplage / maxdoos1)
;
ceilingdoos1 = Ceiling(Oplage /maxdoos1)
;
restdoos1 = (ceilingdoos1 * maxdoos1) - Oplage
;
floordoos2 = Floor((Oplage -(floordoos1 * maxdoos1) ) / maxdoos2)
;
ceilingdoos2 = Ceiling((Oplage -(floordoos1 * maxdoos1) ) / maxdoos2)
;
restdoos2 = (floordoos1 * maxdoos1) + (ceilingdoos2 * maxdoos2) - Oplage
;
floordoos3 =  Floor((Oplage -(floordoos1 * maxdoos1)  -(floordoos2 * maxdoos2) ) / maxdoos3)
;
ceilingdoos3 =  Ceiling((Oplage -(floordoos1 * maxdoos1)  -(floordoos2 * maxdoos2) ) / maxdoos3)
;
restdoos3 = (floordoos1 * maxdoos1) + (floordoos2 * maxdoos2) + (ceilingdoos3 * maxdoos3) - Oplage
;
ceilingdoos4 =  Ceiling((Oplage -(floordoos1 * maxdoos1)  -(floordoos2 * maxdoos2) -(floordoos3 * maxdoos3) ) / maxdoos4)
;
restdoos4 = (floordoos1 * maxdoos1) + (floordoos2 * maxdoos2) + (floordoos3 * maxdoos3) + (ceilingdoos4 * maxdoos4)- Oplage
;
minrest =  Min(restdoos1; restdoos2; restdoos3; restdoos4)
;
doos1 = Case (restdoos1 = minrest ; ceilingdoos1 ;  floordoos1)
;
doos2 = Case (restdoos1 = minrest ; floordoos2 ;restdoos2 = minrest ; ceilingdoos2 ;  floordoos2)
;
doos3 = Case (restdoos1 = minrest ; floordoos3 ;restdoos2 = minrest ; floordoos3  ;restdoos3 = minrest; ceilingdoos3   ; floordoos3)
;
doos4 = Case (restdoos1 = minrest ; 0 ;restdoos2 = minrest ; 0  ;restdoos3 = minrest; 0   ; ceilingdoos4)
;
result = "Doos " & maxdoos1 & ": " & doos1 & "¶" &  "Doos " & maxdoos2 & ": " &doos2 & "¶" &  "Doos " & maxdoos3 & ": "  & doos3 & "¶" &  "Doos " & maxdoos4 & ": "  & doos4 & "¶"
]
;
result

)

 

Wellicht kan het een en andere generieker...

 

Koen

Link naar reactie
  • 0

Volgens mij moet het ook nog simpeler kunnen:

 

grote doos = Int ( oplage / 2500 )

middel doos = Ceiling ( (oplage - grote doos * 2500 - 500) / 1250 )

kleine doos = If ( Sign (oplage - grote doos * 2500 - middel doos * 1250 ) = 1 ; 1; 0)

 

Misschien dat iemand nog iets weet voor "kleine doos" zonder if-constructie.

 

PJ

Link naar reactie
  • 0

kleine doos = If ( Sign (oplage - grote doos * 2500 - middel doos * 1250 ) = 1 ; 1; 0)

 

Yep, uit een test komt al 0 of 1 waaruit volgt:

kleine doos = Sign (oplage - grote doos * 2500 - middel doos * 1250 ) = 1

 

Maar er kan maximaal 1 kleine doos berekend kan worden.

 

Groet,

René

Link naar reactie
  • 0

Ik probeer hier een configuratie te berekenen met zo min mogelijk plaats in de dozen. (Restwaarde)

 

Ik geef toe dat ik aanvankelijk meer in de richting van het berekenen van wisselgeld zat te denken, en dat is in dit voorbeeld niet helemaal bruikbaar. Maar er moet toch een 'mooie' formule voor zijn! :-)

 

Geef eens een oplage waarmee mijn aangepaste versie de fout in gaat, want ik ben nog niet helemaal overtuigd dat je formule echt nodig is.

 

Groet,

René

Link naar reactie
  • 0
Ja lost inderdaad dit probleem op. Bij de meeste oplages is de uitkomst dezelfde. Toch zijn de uitkomsten hier en daar verschillend.

 

Hallo Koen,

 

Inderdaad gezien, heb nu 1,5 avond lopen rekenen en proberen. Cirkelredenering is een probleem. En bij het meer generiek maken in herhaalde velden gaat e.e.a. technisch niet goed.

 

Kom er echter achter dat jouw berekening hier en daar ook niet klopt.

Neem b.v. 4981 stuks waar uit komt: 2x2500 en 1x1250 = totaal 6250

of 7453 stuks met 3x2500 en 1x1250 = totaal 8750

Dat is dus veel meer restruimte dan je berekening laat zien, want de dozen van 2500 stuks zijn voldoende...

 

Ik werk nog aan een oplossing.

 

Groet,

René

Link naar reactie
  • 0

Er zat inderdaad nog een bugje in. Allemaal in de conditie wanneer er alleen dozen zouden moeten zijn. In volgende formule is dit gecorrigeerd:

 

Let 
( 
[ 
oplage =  Aantal Oplage
; 
floordoos1 = Floor(Oplage / 2500) 
; 
ceilingdoos1 = Ceiling(Oplage / 2500) 
; 
restdoos1 = (ceilingdoos1 * 2500) - Oplage 
; 
floordoos2 = Floor((Oplage -(floordoos1 * 2500) ) / 1250) 
; 
ceilingdoos2 = Ceiling((Oplage -(floordoos1 * 2500) ) / 1250) 
; 
restdoos2 = (floordoos1 * 2500) + (ceilingdoos2 * 1250) - Oplage 
; 
ceilingdoos3 =  Ceiling((Oplage -(floordoos1 * 2500)  -(floordoos2 * 1250) ) / 500) 
; 
restdoos3 = (floordoos1 * 2500) + (floordoos2 * 1250) + (ceilingdoos3 * 500) - Oplage 
; 
minrest =  Min(restdoos1; restdoos2; restdoos3) 
; 
doos1 = Case (restdoos1 = minrest ; ceilingdoos1 ;  floordoos1) 
; 
doos2 = Case (restdoos1 = minrest ; 0 ;restdoos2 = minrest ; ceilingdoos2 ;  floordoos2) 
; 
doos3 = Case (restdoos1 = minrest ; 0 ;restdoos2 = minrest ; 0 ;  ceilingdoos3) 
; 
result = "Groot: " & doos1 & "¶" & "Middel: " & doos2 & "¶" & "Klein: " & doos3 & "¶" 
] 
; 
result 

)

 

Ik kijk uit naar je alternatief René.

 

 

Koen

Link naar reactie
  • 0

Ik kijk uit naar je alternatief René.

 

Ik was nog bezig maar dat is geen belofte dat er een beter alternatief uit komt! :-)

 

Op bijna 10 verschillende manieren heb ik getracht tot de uitkomst te komen. Overigens, mijn oorspronkelijke berekening is in 80% van de gevallen optimaal. (En 100% als het om geldmiddelen gaat.)

 

Maar bij elke poging blijkt dat je alle mogelijkheden moet berekenen om de beste uit te kiezen. Met drie formaten dozen is dat nog wel redelijk te doen. Zie hier overigens nog wel iets leuks met het in tekst berekenen van de berekening en met Evaluate() uitvoeren! Maar ga daar even geen onbetaalde tijd instoppen.

Schrijf maar eens uit hoe je zo'n opdracht handmatig zou doen, op een bepaald moment schat je of nog een doos genomen moet worden of (meerdere) kleine geschikt zijn. En schatten, dat kan een computer niet...

 

Het enige punt van verbetering in de formule is dat de drie waarden los te benaderen moeten zijn. Dan kan je drie berekeningvelden nemen met vrijwel dezelfde formule (met Eigen Functie), maar dat kost ook 3x zoveel tijd. Zie toegevoegd bestandje voor meer generieke berekening en twee mogelijkheden van uitlezen (een alleen-FM8 functie gebruikt).

 

Groet,

René

 

P.S. Mogen we hier overigens aannemen dat iedereen FM Developer/Advanced heeft en Eigen Functies enzo in de voorbeelden gebruikt kunnen worden?

Dozen demo v2.zip

Link naar reactie
  • 0

Voor het gemak van de mensen die geen Advanced versie hebben, hier de custom functie van René. Inderdaad een mooi ding.

Let (
 [floordoos1 = Floor(Oplage / Inhoud_1);
 ceilingdoos1 = Ceiling(Oplage / Inhoud_1);
 restdoos1 = (ceilingdoos1 * Inhoud_1) - Oplage;

 floordoos2 = Floor((Oplage -(floordoos1 * Inhoud_1) ) / Inhoud_2);
 ceilingdoos2 = Ceiling((Oplage -(floordoos1 * Inhoud_1) ) / Inhoud_2);
 restdoos2 = (floordoos1 * Inhoud_1) + (ceilingdoos2 * Inhoud_2) - Oplage;

 ceilingdoos3 =  Ceiling((Oplage -(floordoos1 * Inhoud_1)  -(floordoos2 * Inhoud_2) ) / Inhoud_3);
 restdoos3 = (floordoos1 * Inhoud_1) + (floordoos2 * Inhoud_2) + (ceilingdoos3 * Inhoud_3) - Oplage;

 minrest =  Min(restdoos1; restdoos2; restdoos3);

 doos1 = Case (restdoos1 = minrest ; ceilingdoos1 ;  floordoos1);
 doos2 = Case (restdoos1 = minrest ; 0 ;restdoos2 = minrest ; ceilingdoos2 ;  floordoos2);
 doos3 = Case (restdoos1 = minrest ; 0 ;restdoos2 = minrest ; 0 ;  ceilingdoos3)
];

Choose ( Doosnr ; doos1 & "¶" & doos2 & "¶" & doos3; doos1 ; doos2; doos3)

)

Link naar reactie

Doe mee aan dit gesprek

Je kunt dit nu plaatsen en later registreren. Indien je reeds een account hebt, log dan nu in om het bericht te plaatsen met je account.

Gast
Beantwoord deze vraag...

×   Geplakt als verrijkte tekst.   Plak in plaats daarvan als platte tekst

  Er zijn maximaal 75 emoji toegestaan.

×   Je link werd automatisch ingevoegd.   Tonen als normale link

×   Je vorige inhoud werd hersteld.   Leeg de tekstverwerker

×   Je kunt afbeeldingen niet direct plakken. Upload of voeg afbeeldingen vanaf een URL in

×
×
  • Nieuwe aanmaken...