[PHP] Quel nombre est le plus proche ?

[WizOut]

Bonjour / Bonsoir,

Aujourd'hui j'ai eu besoin de faire une fonction pour un de mes programmes permettant de savoir à partir d'un tableau composé de valeur numérique quel nombre est le plus proche de x où x est un réel.

je vous met le prototype qui est :

Code PHP :

    function compare($signe, $const, &$tab, $returnIndice); 


$signe : peut prendre deux valeurs : "<" si on veut la valeur inférieur à $const la plus proche ou ">" si on veut la valeur supérieur à $const la plus proche.
$const : le nombre auquel on veut se rapprocher
&$tab : c'est le tableau de valeur
$returnIndice : deux valeurs possibles "true" ou "false" ça nous retourne en plus de la valeur approchée de $const , son indice dans le tableau...

Un exemple est toujours mieux qu'un long discours donc c'est parti :

Code PHP :

<?php
$montableau = [5, 20, 8, 9, 125, 1000, -5, -125];

// Je veux la valeur supérieur la plus proche de 80
echo "Valeur superieur de 80 : " . compare(">", 80, $montableau, false) . "<br />";

// Je veux la valeur inférieur la plus proche de 80
echo "Valeur inferieur de 80 : " . compare("<", 80, $montableau, false) . "<br />";
?>

Resultat :

Code :

Valeur superieur de 80 : 125
Valeur inferieur de 80 : 20

Voilà le fonctionnement assez simple, mais imaginons que vous avez deux fois 125 dans votre tableau, comment le programme va réagir ? il va créer un tableau multidimensionnel si vous voulez les indices, ou bien unidimensionnel (ça peut servir pour compter le nombre de doublons) si vous ne voulez pas d'indice. Exemple :

Code PHP :

<?php
$montableau = [5, 20, 125, 8, 9, 125, 1000, -5, -125];

// Je veux la valeur supérieur la plus proche de 80 avec les indices 
echo print_r(compare(">", 80, $montableau, true));

// Je veux la valeur supérieur la plus proche de 80 sans indices
echo print_r(compare(">", 80, $montableau, false));

?>

Résultat :

Code :

Array ( [0] => Array ( [0] => 125 [1] => 5 )
        [1] => Array ( [0] => 125 [1] => 2 ) )

Array ( [0] => 125
        [1] => 125 )

Voila en gros, pour 125 on le retrouve à l'indice 5 et 2 de $montableau.
Cette fonction peut toujours servir, ne là sous-estimez pas
Ah j'allais oublier le code :

Code PHP :

    function compare($signe, $const, &$tab, $returnIndice) {
        $a = [max($tab), min($tab)];

        if ($const >= $a[0] && $signe == ">" || $const <= $a[1] && $signe == "<") {
            return NULL;
        } else {
            $double = false;
            $multiDouble = []; // Tableau contenant les doublons... Si par exemple il y a 2 fois une même valeur la plus proche possible par valeur supérieur de $x ou $y

            if ($signe == ">") {

                $val = 10000;
                $indice = 0;


                for ($i = 0; $i < count($tab); $i++) {

                    if ($tab[$i] > $const && $tab[$i] < $val) {
                        $val = $tab[$i];
                        $indice = $i;
                    } else if ($tab[$i] == $val && $returnIndice) {
                        $double = true;
                        array_push($multiDouble, [$val, $i]);
                    } else if ($tab[$i] == $val && !$returnIndice) {
                        $double = true;
                        array_push($multiDouble, $val);
                    }
                }

                if ($double && !$returnIndice) {
                    array_push($multiDouble, $val);
                } else if ($double && $returnIndice) {
                    array_push($multiDouble, [$val, $indice]);
                }

                if ($double) {
                    return $multiDouble;
                } else {

                    if ($returnIndice) {
                        return [$val, $indice];

                    } else {
                        return $val;
                    }
                }


            } else if ($signe == "<") {

                $plusPetiteValeurMultiArray = []; // Contient  valeur + indice [ [valeur, indice ], [valeur, indice], [valeur, indice] ] -> elements plus petit que $x
                $plusPetiteValeurArray = []; // Contient uniquement les plus petites valeurs (tableau unidimensionnel) 

                for ($i = 0; $i < count($tab); $i++) {
                    if ($tab[$i] < $const ) {
                        array_push($plusPetiteValeurMultiArray, [$tab[$i], $i]);
                        array_push($plusPetiteValeurArray, $tab[$i]);
                    }
                }

                $doublons = []; // Tableau qui contiendra les valeurs doublés dans le tableau

                $array_unique = array_unique($plusPetiteValeurArray); 

                   if (count($plusPetiteValeurArray) - count($array_unique)){ 
                    for ($i = 0; $i<count($plusPetiteValeurArray); $i++) {
                        if (!array_key_exists($i, $array_unique)) 
                            $doublons[] = $plusPetiteValeurArray[$i];
                    } 
                } 

                foreach ($doublons as $element) {
                    if ($element == max($plusPetiteValeurArray)) {
                        $double = true;
                    }
                }

                if ($double) {
                    for ($i = 0; $i < count($tab); $i++) {
                        if ($tab[$i] == max($plusPetiteValeurArray)) {
                            if ($returnIndice) {
                                array_push($multiDouble, [max($plusPetiteValeurArray), $i]);

                            } else {
                                array_push($multiDouble, max($plusPetiteValeurArray));
                            }
                        }
                    }
                    return $multiDouble;
                } else {


                    for ($i = 0; $i < count($tab); $i++) {

                            if ($tab[$i] == max($plusPetiteValeurArray)){
                                if ($returnIndice) {
                                    $result = [max($plusPetiteValeurArray), $i];
                                } else {
                                    $result = max($plusPetiteValeurArray);
                                }
                            } 
                    }
                    return $result;
                }

            }
        }
    } 


[cacaphonie]

Salut,
moi je viens de faire qu'en utilisant des if, j'aurais p-e pu utiliser switch mais je sais pas pourquoi j'ai fait, j'ai fait comme ça : (pas testé le code dsl juste pour te donner une idée de ce que j'ai fait):

Code PHP :

<?PHP

function compare($valeurA, $signe, $valeurB)
        {
                if($signe == ">")
                        {
                                if($valeurA > $valeurB)
                                        {
                                                echo "$valeurA est plus grand que $valeurB";
                                        }
                                else
                                        {
                                                echo "$valeurA est plus petit que $valeurB"; // pas forcément
                                        }
                        }

                if($signe == "!=" or "=!")
                        {
                                if($valeurA != $valeurB)
                                        {
                                                echo "$valeurA est différent de $valeurB";
                                        }
                                else
                                        {
                                                echo "$valeurA n'est pas différent de $valeurB";
                                        }
                        }
                if($signe == "<")
                        {
                                if($valeurA < $valeurB)
                                        {
                                                echo "$valeurA est inférieur a $valeurB";
                                        }
                                else
                                        {
                                                echo "$valeurA n'est pas inférieur à $valeurB";
                                        }
                        }
        }
?>

j'ai comparé que deux variables c'est plus simple mais bon moins avancé que ton script

[WizOut]

Ton code ne fait que questionner si une valeur est réellement plus grande, plus petite ou différente d'une autre, ce qui est inutile à mon gout il existe déjà la structure alternative if qui permet de faire ça directement, c'est rajouter une surcouche dans ton application pour rien, c'est comme lui mettre 2 kilos sur le dos, où bien c'est comme si que ovh utilisait du chauffage dans leur data-centre pour rendre la tâche plus difficile à leur serveur et provoquer un incendie, combattre le mal par le mal, ça n'a pas de sens.

[cacaphonie]

ENfaite je me focalisais plus sur les arguments de la fonction que le contenu d'elle, et je me suis perdu comme ça

[octarin]

Et il se passe quoi quand $const = 2000 dans ton exemple ?

Sinon voici ma solution en python:

Code PYTHON :


#!/usr/bin/env python3

def compare(signe, nb, tab, returnindice=False):
    try:
        if signe == '<':
            r = max(i for i in tab if i < nb)
        elif signe == '>':
            r = min(i for i in tab if i > nb)
    except ValueError:
        r = None        # If such value does'nt exists in tab

    if returnindice == True:
        return (r, [a for a, i in enumerate(tab) if i == r])
    else:
        return r

if __name__ == '__main__':
    tab = [5, 20, 125, 8, 9, 125, 1000, -5, -125]
    vtest = 80

    print(compare('<', vtest, tab, True))
    print(compare('>', vtest, tab, True))

 

[WizOut]

Oui tu as raison je n'ai pas géré cette exception, mais je ne l'ai pas faite car j'en avais pas forcement besoin en fait ^^ $const était une valeur sûre. J'ai rectifié le tir, ça renverra NULL désormais en cas d'erreur

PS : j'approuve le python c’est plus rapide
Par contre ton script ne retournera pas deux fois la même valeur (en cas de doublons, triplons, quadruplons etc...) si tu mets l'indice à False

[octarin]

Quel serait l'intérêt ?

[Junky]

Bonjour,

Voici comment j'ai fais en python. (a rajouter un try except pour éviter les 'out of range' si le vtest n'a pas de supérieur ou d'inférieur)

Code PYTHON :


#!/usr/bin/env python

if __name__=="__main__":
    tab = [5, 20, 125, 8, 9, 125, 1000, -5, -125]
    vtest = 80
    tab.append(vtest)
    tab.sort()
    print "Inferieur le plus proche => ", tab[tab.index(vtest)-1]
    print "Superieur le plus proche => ", tab[tab.index(vtest)+1]
 

Output:

Code :

0 ✓ silentd@G3nt00 ~ $ ./tri.py
Inferieur le plus proche =>  20
Superieur le plus proche =>  125

En faite le déroulement est simple. On a un tab, on rajoute la valeur désiré au tab, on le tri et ensuite on affiche tab[index.valeur-1] pour inférieur et +1 pour supérieur.

Junky