Price fraction: Difference between revisions

From Rosetta Code
Content added Content deleted
(Defined Price Fraction task and gave Clipper example)
 
(Modified to extend table over the complete 0.00 to 1.00 includsive range.)
Line 23: Line 23:
>= 0.86 < 0.91 := 0.94<br>
>= 0.86 < 0.91 := 0.94<br>
>= 0.91 < 0.96 := 0.98<br>
>= 0.91 < 0.96 := 0.98<br>
>= 0.96 < 1.01 := 1.00<br>

=={{header|Clipper}}==
=={{header|Clipper}}==
<lang dbase>FUNCTION PriceFraction( npQuantDispensed )
<lang dbase>FUNCTION PriceFraction( npQuantDispensed )

Revision as of 10:29, 15 March 2010

Task
Price fraction
You are encouraged to solve this task according to the task description, using any language you may know.

A friend of mine runs a Pharmacy. He has a specialised rounding function in his Dispensary application which receives a decimal value of currency and forces it to a standard value, This value is regulated by a government department.

Task: Given a floating point value between 0.00 and 1.00, rescale according to the following table:

>= 0 < 0.06 := 0.1
>= 0.06 < 0.11 := 0.18
>= 0.11 < 0.16 := 0.26
>= 0.16 < 0.21 := 0.32
>= 0.21 < 0.26 := 0.38
>= 0.26 < 0.31 := 0.44
>= 0.31 < 0.36 := 0.5
>= 0.36 < 0.41 := 0.54
>= 0.41 < 0.46 := 0.58
>= 0.46 < 0.51 := 0.62
>= 0.51 < 0.56 := 0.66
>= 0.56 < 0.61 := 0.7
>= 0.61 < 0.66 := 0.74
>= 0.66 < 0.71 := 0.78
>= 0.71 < 0.76 := 0.82
>= 0.76 < 0.81 := 0.86
>= 0.81 < 0.86 := 0.9
>= 0.86 < 0.91 := 0.94
>= 0.91 < 0.96 := 0.98
>= 0.96 < 1.01 := 1.00

Clipper

<lang dbase>FUNCTION PriceFraction( npQuantDispensed )

   LOCAL aPriceFraction := { {0,.06,.1},;
                           {.06,.11,.18}, ;
                           {.11,.16,.26}, ;
                           {.16,.21,.32}, ;
                           {.21,.26,.38}, ;
                           {.26,.31,.44}, ;
                           {.31,.36,.5}, ;
                           {.36,.41,.54}, ;
                           {.41,.46,.58}, ;
                           {.46,.51,.62}, ;
                           {.51,.56,.66}, ;
                           {.56,.61,.7}, ;
                           {.61,.66,.74}, ;
                           {.66,.71,.78}, ;
                           {.71,.76,.82}, ;
                           {.76,.81,.86}, ;
                           {.81,.86,.9}, ;
                           {.86,.91,.94}, ;
                           {.91,.96,.98} }
   LOCAL nResult
   LOCAL nScan
   IF npQuantDispensed = 0
           nResult = 0
   ELSEIF npQuantDispensed >= .96
           nResult = 1
   ELSE
           nScan := ASCAN( aPriceFraction, ;
                  { |aItem| npQuantDispensed >= aItem[ 1 ] .AND.;
                            npQuantDispensed <  aItem[ 2 ] } )
           nResult := aPriceFraction[ nScan ][ 3 ]
   END IF
   RETURN nResult</lang>