[PHP] Afronden op tientallen, deelbaar door 5

[Reveller]

Ik probeer een functie te schrijven die een getal als input heeft en dit getal naar boven afrondt, naar een tiental (of hondertal, of duizendtal...) dat deelbaar is door 5. Dat laatste is een voorwaarde om "mooie" y-labels te krijgen in een grafiek.

Enkele voorbeelden:

input	afronding	y-labels
7	10	2, 4, 6, 8, 10
12	20	4, 8, 12, 16, 20
23	30	6, 12, 18, 24, 30
80	100	20, 40, 60, 80, 100
177	200	40, 80, 120, 160, 200
4511	5000	1000, 2000, 3000, 4000, 5000

Na het lezen van php.net leerde ik dat ik met ceil() omhoog kan afronden, maar niet naar een tiental. Om te kijken of een getal deelbaar is door 5 denk ik dat ik de modulo (?) operator nodig heb: getal % 5 moet nul zijn.

Ik heb alleen moeite om dit in een functie te vervatten. Wie kan mij op weg helpen?

[Anoniem: 12795]

Ceil() rondt af naar boven http://nl3.php.net/ceil/ vervolgens kijk je of de mod 5 daarvan 0 is (deelbaar door 5) als dat niet het geval is 1 bij de uitkomst van ceil() optellen en weer de mod controleren totdat je een mod 5 = 0 terug krijgt.

[urk_forever]

if (getal % 5 = 0) then
return getal;
else
getal = getal + 1;
end if

Zoiets zou toch moeten werken?

[Voutloos]

ceil($getal / 5) * 5 ?
Klaar.

[mithras]

PHP:

$number = ceil($number/5)*5;
values = array($number/5, 2*$number/5, 3*$number/5, 4*$number/5, $number);

Niet zo heel moeilijk volgens mij toch?

edit:
pmeems oplossing dus

edit:
#2: Voutloos manier is sneller, nu aangepast

[ Voor 28% gewijzigd door mithras op 04-05-2007 15:13 ]

[Vaan Banaan]

Het lijkt erop alsof je iets met log10 wilt doen, maar ik snap niet waarom je 80 naar 100 wilt afronden.
Dit is toch al deelbaar door 5? 16 32 48 64 80
En als je iets afrondt op 10 100 1000 enz is dat ook altijd deelbaar door 5 natuurlijk

[Janoz]

Probeer eerst eens voor jezelf de specs duidelijker uitlegbaar te hebben. Wat je zegt is niet hetzelfde als wat er in de tabel staat. Bij 4511 voldoet 4520 namelijk ook keurig aan 'tiental' en aan 'deelbaar door vijf'.

Zorg gewoon dat je eerst voor jezelf geheel duidelijk kunt omschrijven wat je wilt. moet 4300 bijvoorbeeld 4500 opleveren omdat je dan mooi 900 1800 2700 3600 4500 kunt doen, of echt 5000 zodat je 1000,2000,3000,4000,5000 kunt doen.

De functie ceil gaat je iig compleet niet verder helpen. Dat is enkel afronden naar boven. Je hebt hier veel meer logica nodig.

[Anoniem: 185786]

zoiets?

Afronding = 5
if getal > 50 then
afronding = 10
if getal > 500 then
afronding = 100
if getal > 5000 then
afronding = 1000
result = (ceil(getal div afronding))*afronding

[BasieP]

ik snap je verhaal niet helemaal maar volgens mij bedoel je dat je een input getal hebt
en dat je dit getal wilt afronden naar iets wat deelbaar moet zijn door 5

echter, in je tabel bij bijvoorbeeld je laatste voorbeeld (4511) is het al zo dat 4515 al deelbaar is door 5.

dus met alleen zoeken naar een afronding die deelbaar is door 5 kom je er niet.
je wilt het ook zo hebben dat het een 10tal, honderdtal of duizendtal is.

dus dan zou ik zeggen,

neem je input (501293) en deel die door de lengte van het getal-1 als getal (hoe zeg je dat) 10^(<lengte getal>-1)

dus 501293 wordt dan 5,01293 dan rond je hem af met ceil() (wordt dan dus 6)
en vervolgens ga je bij dat getal telkens 1 optellen tot dat getal % 5 = 0

dus
6 % 5 = 1
7 % 5 =2
8 % 5 = 3
9 & 5 = 4
10 % 5 = 0 (heey!) dus heb je 10.

Dat getal doe je weer vermenigvuldingen met 10^(lengte van originele nummer - 1) en dan kom je op 1000000 uit.


edit:
ik doe wel heel moeilijk zie ik

edit2:
maar doe wel iets fundamenteels anders dan de rest hierboven

[ Voor 5% gewijzigd door BasieP op 04-05-2007 15:26 ]

[Dido]

Even voor de duidelijkheid: elk tiental is deelbaar door vijf, dus heb ik het idee dat ik een belangrijk deel van de vraagstelling mis.

[curry684]

Je zult eerst je gewenste algoritme enigszins moeten specificeren, want het lijstje van voorbeelden dat je geeft is al zo inconsequent als wat: waarom gaat 80 naar 100, als 23 naar 30 gaat? Zowel 80 als 25 zijn perfect door 5 deelbaar, dus geen idee waarom je die niet zou gebruiken.

Ceil ga je wel degelijk nodig hebben, maar pas zodra je de basiseisen duidelijk hebt. Een lijstje van voorbeelden is nutteloos, da's leuk voor je testing naderhand, maar eerst zul je zoals Janoz zegt moeten uitwerken welke regels je exact wil gaan volgen.

[Anoniem: 13701]

Zoiets ?

PHP:

$m = 10;
while (($input / $m) > 10)
{
    $m *= 10;
}
$result = ($input / $m + 1) * $m;

[P.O. Box]

volgens mij wil je , als ik het goed begrijp, dat het getal met de 0-en eraf gekapt deelbaar is door vijf...

dan krijg je zoiets (mag je zelf efficienter maken):

PHP:

function afronden($getal) {
    $rekengetal = intval(ereg_replace(/0+$/, '0', $getal));
    if ($rekengetal % 5 == 0 && $rekengetal % 10 == 0) {
         return $getal;
    }
    return afronden($getal + 1);
}

ofzo

edit... dit klopt eingelijk nog niet echt lekker, maar misschien iets in deze richting? alhoewel onderstaand voorbeeld natuurlijk veel simpeler is...

[ Voor 16% gewijzigd door P.O. Box op 04-05-2007 15:48 ]

[curry684]

Anoniem: 185786 schreef op vrijdag 04 mei 2007 @ 15:14:
zoiets?

Afronding = 5
if getal > 50 then
afronding = 10
if getal > 500 then
afronding = 100
if getal > 5000 then
afronding = 1000
result = (ceil(getal div afronding))*afronding

Met PHP's weak typing kan dit natuurlijk lekker flexibel:

PHP:

$rounder = '1'.str_repeat('0', strlen(floor($getal / 50)));
$max = ceil($getal / $rounder)*$rounder;

[Gods Lonely Man]

PHP:

$getal = ceil($getal * 0.1) / 0.1;

Zo kan het toch ook?

[ Voor 3% gewijzigd door Gods Lonely Man op 04-05-2007 15:48 ]

[Janoz]

Edwardvb schreef op vrijdag 04 mei 2007 @ 15:38:
volgens mij wil je , als ik het goed begrijp, dat het getal met de 0-en eraf gekapt deelbaar is door vijf...

Nee dat wil hij niet. Als je naar zijn voorbeeld lijstje kijkt zie je dat op 1 na geen enkel voorbeeld aan die voorwaarde voldoet.

Het lijkt me dan ook handiger dat we stoppen met gokken en maar gewoon eens wachten tot de TS daadwerkelijk eens heeft nagedacht over wat hij nu eigenlijk wil bereiken.

[Reveller]

Janoz schreef op vrijdag 04 mei 2007 @ 15:51:
[...]
Het lijkt me dan ook handiger dat we stoppen met gokken en maar gewoon eens wachten tot de TS daadwerkelijk eens heeft nagedacht over wat hij nu eigenlijk wil bereiken.

Graag! Ik probeerde snel uit te schrijven wat ik wilde wat had niet zoveel reakties verwacht. Ik doe mijn best om een duidelijke beschrijving te geven

[Mischa_NL]

dit moet je doen:

je zoekt het aantal cijfers waaruit je getal bestaat: 21 = 2, 634 = 3
dan pak je je eerste cijfer: 2, 6
nu doe je je eerste zijfer + 1: 3, 7
als laatste zet je het aantal getallen -1 achter je cijfer: 30, 700;

TADA!

[ Voor 73% gewijzigd door Mischa_NL op 04-05-2007 16:00 ]

[.oisyn]

Van wat ik ervan begrijp is dat de orde van grootte idd belangrijk is, de naam "tiental" is dan ook onjuist. Het moet gewoon een getal met slechst 1 significante cijfer zijn, oftewel, een getal in de vorm a * 10^e met a in { 1, 2, ..., 9 } en e in N. Maar zolang hij op een 0 eindigt is hij altijd deelbaar door 5, aangezien 10 nou eenmaal deelbaar is door 5 (en dus ook automatisch alle veelvouden van 10)

Mischa_NL's implementatie klopt aardig, behalve als het af te ronden getal al aan de juiste specificatie voldoet

[ Voor 15% gewijzigd door .oisyn op 04-05-2007 16:06 ]

[Mischa_NL]

.oisyn schreef op vrijdag 04 mei 2007 @ 16:04:
Van wat ik ervan begrijp is dat de orde van grootte idd belangrijk is, de naam "tiental" is dan ook onjuist. Het moet gewoon een getal met slechst 1 significante cijfer zijn. Maar zolang hij op een 0 eindigt is hij altijd deelbaar door 5, aangezien 10 nou eenmaal deelbaar is door 5 (en dus ook automatisch alle veelvouden van 10)

Mischa_NL's implementatie klopt aardig, behalve als het af te ronden getal al aan de juiste specificatie voldoet

op jou zijn tabel kloppen ze allemaal. en volgens mij moet dit altijd kloppen met je geen komma's hebt. anders ff naar een int casten he .

[ Voor 8% gewijzigd door Mischa_NL op 04-05-2007 16:06 ]

[Janoz]

Bij 80 geeft dat 90 als uitkomst en niet de gewenste 100. Daarnaast zou dat bij een input van 20 uiteindelijk 30 opleveren terwijl ik het idee heb dat TS dan toch echt liever 20 gebruikt.

@hieronder: Jou implementatie komt in de verste verte niet in de buurt bij die van Mischa.

[ Voor 20% gewijzigd door Janoz op 04-05-2007 16:08 ]

[BasieP]

check mijn implementatie, volgens mij komt die aardig bij die van micha's in de buurt

[.oisyn]

Mischa_NL schreef op vrijdag 04 mei 2007 @ 16:05:
[...]

op jou zijn tabel kloppen ze allemaal. en volgens mij moet dit altijd kloppen met je geen komma's hebt. anders ff naar een int casten he .

100 zou 100 moeten geven, jouw implementatie geeft dan 200

Janoz schreef op vrijdag 04 mei 2007 @ 16:06:
Bij 80 geeft dat 90 als uitkomst en niet de gewenste 100. Daarnaast zou dat bij een input van 20 uiteindelijk 30 opleveren terwijl ik het idee heb dat TS dan toch echt liever 20 gebruikt.

Ik gok dat die tabel fout is want 80 voldoet weldegelijk aan z'n eisen zoals ik ze begrijp (16, 32, 48, 64, 80). En anders is het loos dat 30 ook voldoet.

[Anoniem: 182184]

Dit is heel makkelijk, alleen je moet het even weten.
round en dan niet zoveel achter de komma maar zoveel voor de komma

$afronden = round($getal+5, -1); // Dit is op tientallen afronden
$afronden = round($getal+50, -2); // Dit is op honderdtallen afronden
enz...

Succes

[Mischa_NL]

.oisyn schreef op vrijdag 04 mei 2007 @ 16:08:
[...]

100 zou 100 moeten geven, jouw implementatie geeft dan 200


[...]

Ik gok dat die tabel fout is want 80 voldoet weldegelijk aan z'n eisen zoals ik ze begrijp (16, 32, 48, 64, 80). En anders is het loos dat 30 ook voldoet.

klopt idd...

maar ik snap niet waarom je zo een algoritme zou willen gebruiken? een grafiek met variabel verschil kwa afstand / grootte eenheid (hoe leg ik dit uit )?

40 moet dus 50 worden? maar 50 100? dat is natuurlijk raar

[.oisyn]

Anoniem: 182184 schreef op vrijdag 04 mei 2007 @ 16:10:
Dit is heel makkelijk, alleen je moet het even weten.
round en dan niet zoveel achter de komma maar zoveel voor de komma

$afronden = round($getal+5, -1); // Dit is op tientallen afronden
$afronden = round($getal+50, -2); // Dit is op honderdtallen afronden
enz...

Succes

Het lezen van de draad is ook heel makkelijk, alleen moet je het even doen.

[ Voor 77% gewijzigd door .oisyn op 04-05-2007 16:12 ]

[Janoz]

Welke eisen . TS heeft geen idee wat nu eigenlijk zijn eisen zijn. Hij heeft een 'gut feeling' lijstje gedumpt met een idee wat daarvoor de regels zouden kunnen zijn zonder dat hij er wat langer over nagedacht heeft en denkt dat er vervolgens tussen de vele php-functies wel ergens een apply_gut_feeling() methode is die exact dat doet en is teleurgesteld dat die functionaliteit helaas niet in ceil() zit.

[.oisyn]

PHP:

function apply_gut_feeling($x)
{
    // special cases
    if ($x <= 5)
        return 5;
    if ($x <= 10)
        return 10;

    $numdigits = (int)log10($x);
    $factor = pow(10, $numdigits);

    return ceil($x / $factor) * $factor;
}

$a = array(7, 12, 23, 80, 177, 4511);
foreach($a as $i)
{
    echo apply_gut_feeling($i), "<br>";
}

[ Voor 4% gewijzigd door .oisyn op 04-05-2007 16:26 ]

[Vaan Banaan]

Mijn feeling was ongeveer net als die van .oisyn Vaan Banaan in "[PHP] Afronden op tientallen, deelbaar d...", dus dat zal het wel ongeveer precies net niet om en de nabij helemaal exact zijn wat de TS denkt te bedoelen

[Reveller]

.oisyn schreef op vrijdag 04 mei 2007 @ 16:23:

PHP:

function apply_gut_feeling($x)
{
  // ...
}

De boodschap is duidelijk ....

De specs waren inderdaad ondoordacht. Wat ik wil is een grafiek met makkelijk leesbare y-assen. Daarom wil het het aantal mogelijke y-labels beperken, zodat grafieken onderling te vergelijken zijn. Ik ga uit van de volgende ranges:

• getal <= 10: stapjes van 1 of 2
• 10 < getal <= 100: stapjes van 5 of 10 of 20
• 100 < getal <= 1000: stapjes van 25, 50, 100 of 200
• 1000 < getal <= 10.000: stapjes van 250, 500, 1000 of 2000
• 10.000 < getal <= 100.000: stapjes van 2.500, 5.000, 10.000 of 20.000
• 100.000 < getal <= 1.000.000: stapjes van 25.000, 50.000, 100.000 of 200.000
• etc...

De volgende tabel is m.i. consistent met deze voorwaarden:

grootste getal	stapjes van	y-labels
3	1	1, 2, 3, 4, 5
7	2	2, 4, 6, 8, 10
12	5	5, 10, 15, 20, 25
24	5	5, 10, 15, 20, 25
32	10	10, 20, 30, 40, 50
76	20	20, 40, 60, 80, 100
117	25	25, 50, 75, 100, 125
236	50	50, 100, 150, 200, 250
411	100	100, 200, 300, 400, 500
875	200	200, 400, 600, 800, 1000
2.534	1.000	1.000, 2.000, 3.000, 4.000, 5.000

Ik hoop dat ik in dit geval duidelijk ben. Dit zijn overigens andere specs dan in de startpost; door jullie reakties kwam ik erachter dat dat algoritme, voor zover het al klopte, weinig duidelijkheid in de grafieken zou brengen

Mijn vraag is nu hoe ik een functie moet schrijven die in een array de 5 y-labels retourneert. Zoals ik het zie

• kijk in welke range het getal zit
• rond het getal naar boven af naar een veelvoud van 5
• kijk welk interval voldoet

Klopt dit en hoe vervat ik dat in code? Er is o.a. wat onenigheid over het feit of je wel of niet ceil nodig hebt

[ Voor 5% gewijzigd door Reveller op 04-05-2007 16:49 ]

[BasieP]

nou als ik dit zo zie valt er niet een rekensom van te maken...
de restricties die je stelt (de stapgrote afhankelijk van de grote van het getal) zijn volgens mij niet in een formule te omvatten.

je komt dan uit op een grote tabel met stapgrotes.
dus dit in code:

# getal <= 10: stapjes van 1 of 2
# 10 < getal <= 100: stapjes van 5 of 10 of 20
# 100 < getal <= 1000: stapjes van 25, 50, 100 of 200
# 1000 < getal <= 10.000: stapjes van 250, 500, 1000 of 2000
# 10.000 < getal <= 100.000: stapjes van 2.500, 5.000, 10.000 of 20.000
# 100.000 < getal <= 1.000.000: stapjes van 25.000, 50.000, 100.000 of 200.000

[Vaan Banaan]

Dus de kleine stappen 1, 2, 5 en de grotere 1, 2, 2.5, 5 * 10^n (n > 0)
^{Dus 10 20 25 50, 100 200 250 500, 1000 2000 2500 5000 enz}

[Reveller]

Vaan Banaan schreef op vrijdag 04 mei 2007 @ 16:56:
Dus de kleine stappen 1, 2, 5 en de grotere 1, 2, 2.5, 5 * 10^n (n > 0)
^{Dus 10 20 25 50, 100 200 250 500, 1000 2000 2500 5000 enz}

Klopt, factor 2,5 pas bij n > 100 (dus: 25, 250, 2.500, niet 2,5 of 0,25)

[P.O. Box]

dus dit patroon herhaalt op de getallen kleiner dan 10 na:

code:

1
2 
5

10
20 
25
50

100
200 
250
500

1000
2000
2.500
5.000

10.000
20.000 
25.000
50.000

100.000
200.000 
250.000
500.000

het tweede blok wordt steeds een 0 achter gezet en een nieuw blok gemaakt...

dus misschien zoiets:

PHP:

function newarray($val) {
    return $val * 10;
}

function afronding($getal, $arraycheck) {
    for ($i = 0; $i < count($arraycheck); $i++) {
        if (5 * $arraycheck[$i] > $getal) {
            return $arraycheck[$i];
        }
    }
    return afronding($getal, array_map("newarray", $arraycheck));
}

$arraytocheck = "1,2,2.5,5";
$stapje = afronding($getal, $arraytocheck);
if ($stapje == 2.5) {
    $stapje = 5;
}

[.oisyn]

BasieP schreef op vrijdag 04 mei 2007 @ 16:49:
nou als ik dit zo zie valt er niet een rekensom van te maken...
de restricties die je stelt (de stapgrote afhankelijk van de grote van het getal) zijn volgens mij niet in een formule te omvatten.

Het getal x naar boven afronden naar de eerstvolgende z = 10ⁿ. Vervolgens is de stapgrootte y gelijk aan z/40, z/20, z/10 of z/5, waarbij y een zo'n klein mogelijk geheel getal is en grotergelijk x.

[ Voor 5% gewijzigd door .oisyn op 04-05-2007 17:07 ]

[Anoniem: 217480]

Reveller schreef op vrijdag 04 mei 2007 @ 15:05:
leerde ik dat ik met ceil() omhoog kan afronden, maar niet naar een tiental.

probeer eens:

PHP:

round($nummer, 1);

deze rond af op 1 cijfer na de komma.

[P.O. Box]

Anoniem: 217480 schreef op vrijdag 04 mei 2007 @ 17:15:
[...]


probeer eens:

PHP:

round($nummer, 1);

deze rond af op 1 cijfer na de komma.

offtopic:
wauw... nuttige functie... heb je daar ook documentatie van ?

[Anoniem: 217480]

www.php.net/round

-- zag ff niet dat er een 2de pagina was

[.oisyn]

PHP:

function apply_gut_feeling2($x)
{
    $z = pow(10, ceil(log10($x)));
    $v = array($z/40, $z/20, $z/10, $z/5);
    foreach($v as $i)
        if ($i*5 >= $x && floor($i) == $i)
            return $i;

    return $z;
}

$a = array(1, 2, 3, 7, 12, 24, 32, 76, 117, 236, 411, 875, 2534);
foreach($a as $i) 
{
    $stap = apply_gut_feeling2($i);
    echo $i, ": ";
    for($s = 1; $s <= 5; $s++)
        echo $s * $stap, ", "; 
    echo "<br>";
}

Text output:

1: 1, 2, 3, 4, 5, 
2: 1, 2, 3, 4, 5, 
3: 1, 2, 3, 4, 5, 
7: 2, 4, 6, 8, 10, 
12: 5, 10, 15, 20, 25, 
24: 5, 10, 15, 20, 25, 
32: 10, 20, 30, 40, 50, 
76: 20, 40, 60, 80, 100, 
117: 25, 50, 75, 100, 125, 
236: 50, 100, 150, 200, 250, 
411: 100, 200, 300, 400, 500, 
875: 200, 400, 600, 800, 1000, 
2534: 1000, 2000, 3000, 4000, 5000, 

[ Voor 234% gewijzigd door .oisyn op 04-05-2007 18:02 ]