Prenons cette formule : {=EQUIV(0;CHERCHE(4;A1:A7);1)}
A ) Sélectionne la plage B1:B7 B ) Appuie sur la touche F2, tu devrais te retrouver dans la cellule B1 C ) Saisis dans la barre des formules =Cherche(4;A1:A7) et valide en appuyant sur les touches Maj + Ctrl + Enter (validation matricielle) D ) Ce que tu observes en colonne B, tu as sois des 1 où tu as la valeur 4 en colonne A ou soit des #Valeur! E ) Imagine maintenant que la fonction "Equiv()" a comme second argument, ce tableau "B1:B7"), car l'ensemble de la fonction de la cellule est matriciel.
Maintenant, la fonction Equiv(). Le dernier paramètre est 1. Cela signifie d'après d'Excel sur la fonction :
'----------------- La fonction EQUIV recherche la valeur la plus élevée qui est inférieure ou égale à celle de l’argument valeur_cherchée. Les valeurs de l’argument matrice_recherche doivent être placées en ordre croissant, par exemple : ...-2, -1, 0, 1, 2, ..., A-Z, FAUX, VRAI. '-----------------
On stipule que la plage doit être triée en ordre croissant. Si tu regardes dans la colonne B, tu as seulement des 1 comme valeur numérique, donc en ordre croissant ou décroissant, c'est la même chose...
Par conséquent, la fonction Equiv() recherche la valeur 2 dans le tableau et pour ce faire, elle doit parcourir toute la plage jusqu'à la dernière valeur affichée, car la plage est en ordre croissant et elle doit se rendre à la valeur 2 à la première valeur plus grande que 2. Comme il n'y a pas de valeur plus grande que 1 dans le tableau, elle se rend à la dernière valeur affichée dans le tableau qui est un 1 et retourne la position de cette valeur.
Tu peux utiliser une fonction plus simple et plus courte :
Validation matricielle : Maj + Ctrl + Enter =MAX(SI(A1:A7=4;LIGNE(A1:A7)))
Bonjour,
Une petite démonstration :
Prenons cette formule : {=EQUIV(0;CHERCHE(4;A1:A7);1)}
A ) Sélectionne la plage B1:B7
B ) Appuie sur la touche F2, tu devrais te retrouver dans la cellule B1
C ) Saisis dans la barre des formules =Cherche(4;A1:A7) et valide en
appuyant sur les touches Maj + Ctrl + Enter (validation matricielle)
D ) Ce que tu observes en colonne B, tu as sois des 1 où tu as la valeur 4
en colonne A ou soit des #Valeur!
E ) Imagine maintenant que la fonction "Equiv()" a comme second argument, ce
tableau "B1:B7"), car l'ensemble de la fonction de la cellule est matriciel.
Maintenant, la fonction Equiv(). Le dernier paramètre est 1. Cela signifie
d'après d'Excel sur la fonction :
'-----------------
La fonction EQUIV recherche la valeur la plus élevée qui est inférieure ou
égale à celle de l’argument valeur_cherchée. Les valeurs de l’argument
matrice_recherche doivent être placées en ordre croissant, par exemple :
...-2, -1, 0, 1, 2, ..., A-Z, FAUX, VRAI.
'-----------------
On stipule que la plage doit être triée en ordre croissant. Si tu regardes
dans la colonne B, tu as seulement des 1 comme valeur numérique, donc en
ordre croissant ou décroissant, c'est la même chose...
Par conséquent, la fonction Equiv() recherche la valeur 2 dans le tableau et
pour ce faire, elle doit parcourir toute la plage jusqu'à la dernière valeur
affichée, car la plage est en ordre croissant et elle doit se rendre à la
valeur 2 à la première valeur plus grande que 2. Comme il n'y a pas de
valeur plus grande que 1 dans le tableau, elle se rend à la dernière valeur
affichée dans le tableau qui est un 1 et retourne la position de cette
valeur.
Tu peux utiliser une fonction plus simple et plus courte :
Validation matricielle : Maj + Ctrl + Enter
=MAX(SI(A1:A7=4;LIGNE(A1:A7)))
Prenons cette formule : {=EQUIV(0;CHERCHE(4;A1:A7);1)}
A ) Sélectionne la plage B1:B7 B ) Appuie sur la touche F2, tu devrais te retrouver dans la cellule B1 C ) Saisis dans la barre des formules =Cherche(4;A1:A7) et valide en appuyant sur les touches Maj + Ctrl + Enter (validation matricielle) D ) Ce que tu observes en colonne B, tu as sois des 1 où tu as la valeur 4 en colonne A ou soit des #Valeur! E ) Imagine maintenant que la fonction "Equiv()" a comme second argument, ce tableau "B1:B7"), car l'ensemble de la fonction de la cellule est matriciel.
Maintenant, la fonction Equiv(). Le dernier paramètre est 1. Cela signifie d'après d'Excel sur la fonction :
'----------------- La fonction EQUIV recherche la valeur la plus élevée qui est inférieure ou égale à celle de l’argument valeur_cherchée. Les valeurs de l’argument matrice_recherche doivent être placées en ordre croissant, par exemple : ...-2, -1, 0, 1, 2, ..., A-Z, FAUX, VRAI. '-----------------
On stipule que la plage doit être triée en ordre croissant. Si tu regardes dans la colonne B, tu as seulement des 1 comme valeur numérique, donc en ordre croissant ou décroissant, c'est la même chose...
Par conséquent, la fonction Equiv() recherche la valeur 2 dans le tableau et pour ce faire, elle doit parcourir toute la plage jusqu'à la dernière valeur affichée, car la plage est en ordre croissant et elle doit se rendre à la valeur 2 à la première valeur plus grande que 2. Comme il n'y a pas de valeur plus grande que 1 dans le tableau, elle se rend à la dernière valeur affichée dans le tableau qui est un 1 et retourne la position de cette valeur.
Tu peux utiliser une fonction plus simple et plus courte :
Validation matricielle : Maj + Ctrl + Enter =MAX(SI(A1:A7=4;LIGNE(A1:A7)))
GL
Le 06/11/2014 14:12, MichD a écrit :
Bonjour,
Une petite démonstration :
Prenons cette formule : {=EQUIV(0;CHERCHE(4;A1:A7);1)}
A ) Sélectionne la plage B1:B7 B ) Appuie sur la touche F2, tu devrais te retrouver dans la cellule B1 C ) Saisis dans la barre des formules =Cherche(4;A1:A7) et valide en appuyant sur les touches Maj + Ctrl + Enter (validation matricielle)
Oui tout est là : je ne savais pas que Cherche renvoyait toutes les valeurs trouvées (en mode matriciel).
Autre chose : on peut sélectionner une formule ou même seulement une partie de formule dans la barre de formule et taper :
F9 (Êlculer maintenant)
La formule, ou partie de formule est alors remplacée temporairement par sa valeur : il suffit de taper "échappe" pour retrouver la formule.
Cela permet de voir que Cherche renvoie bien un vecteur-résultat.
Tu peux utiliser une fonction plus simple et plus courte :
Validation matricielle : Maj + Ctrl + Enter =MAX(SI(A1:A7=4;LIGNE(A1:A7)))
La formule n'est pas identique : égale seulement si on est sur la ligne 1. Sinon il faudrait LIGNE(<Plage>) - Ligne(<1ère cellule de Plage>) + 1 un peut lourdingue !
Par contre on peut utiliser : { =EQUIV(2;SI(A2:A7=4;1);1) } qui est plus logique que CHERCHE pour des valeur numériques, et sans doute beaucoup plus rapide aussi !
J'ai trouvé mes astuces ici : https://www.youtube.com/watch?v=dQH2rR1lLpM
Bonne soirée.
Le 06/11/2014 14:12, MichD a écrit :
Bonjour,
Une petite démonstration :
Prenons cette formule : {=EQUIV(0;CHERCHE(4;A1:A7);1)}
A ) Sélectionne la plage B1:B7
B ) Appuie sur la touche F2, tu devrais te retrouver dans la cellule B1
C ) Saisis dans la barre des formules =Cherche(4;A1:A7) et valide en
appuyant sur les touches Maj + Ctrl + Enter (validation matricielle)
Oui tout est là : je ne savais pas que Cherche renvoyait toutes les
valeurs trouvées (en mode matriciel).
Autre chose : on peut sélectionner une formule ou même seulement une
partie de formule dans la barre de formule et taper :
F9 (Êlculer maintenant)
La formule, ou partie de formule est alors remplacée temporairement par
sa valeur : il suffit de taper "échappe" pour retrouver la formule.
Cela permet de voir que Cherche renvoie bien un vecteur-résultat.
Tu peux utiliser une fonction plus simple et plus courte :
Validation matricielle : Maj + Ctrl + Enter
=MAX(SI(A1:A7=4;LIGNE(A1:A7)))
La formule n'est pas identique : égale seulement si on est sur la
ligne 1. Sinon il faudrait
LIGNE(<Plage>) - Ligne(<1ère cellule de Plage>) + 1
un peut lourdingue !
Par contre on peut utiliser :
{ =EQUIV(2;SI(A2:A7=4;1);1) }
qui est plus logique que CHERCHE pour des valeur numériques, et
sans doute beaucoup plus rapide aussi !
J'ai trouvé mes astuces ici :
https://www.youtube.com/watch?v=dQH2rR1lLpM
Prenons cette formule : {=EQUIV(0;CHERCHE(4;A1:A7);1)}
A ) Sélectionne la plage B1:B7 B ) Appuie sur la touche F2, tu devrais te retrouver dans la cellule B1 C ) Saisis dans la barre des formules =Cherche(4;A1:A7) et valide en appuyant sur les touches Maj + Ctrl + Enter (validation matricielle)
Oui tout est là : je ne savais pas que Cherche renvoyait toutes les valeurs trouvées (en mode matriciel).
Autre chose : on peut sélectionner une formule ou même seulement une partie de formule dans la barre de formule et taper :
F9 (Êlculer maintenant)
La formule, ou partie de formule est alors remplacée temporairement par sa valeur : il suffit de taper "échappe" pour retrouver la formule.
Cela permet de voir que Cherche renvoie bien un vecteur-résultat.
Tu peux utiliser une fonction plus simple et plus courte :
Validation matricielle : Maj + Ctrl + Enter =MAX(SI(A1:A7=4;LIGNE(A1:A7)))
La formule n'est pas identique : égale seulement si on est sur la ligne 1. Sinon il faudrait LIGNE(<Plage>) - Ligne(<1ère cellule de Plage>) + 1 un peut lourdingue !
Par contre on peut utiliser : { =EQUIV(2;SI(A2:A7=4;1);1) } qui est plus logique que CHERCHE pour des valeur numériques, et sans doute beaucoup plus rapide aussi !
J'ai trouvé mes astuces ici : https://www.youtube.com/watch?v=dQH2rR1lLpM
Bonne soirée.
MichD
| on peut utiliser : { =EQUIV(2;SI(A2:A7=4;1);1) }
Aussi, en variantes, des formules matricielles!
=EQUIV(1;N(A2:A7=4);1) ou =EQUIV(1;1*(A2:A7=4);1)
OU
{=EQUIV(1;CHERCHE(4;A2:A7);1)}
| on peut utiliser : { =EQUIV(2;SI(A2:A7=4;1);1) }
| on peut utiliser : { =EQUIV(2;SI(A2:A7=4;1);1) }
Aussi, en variantes, des formules matricielles!
=EQUIV(1;N(A2:A7=4);1) ou =EQUIV(1;1*(A2:A7=4);1)
OU
{=EQUIV(1;CHERCHE(4;A2:A7);1)}
GL
Le 07/11/2014 12:08, MichD a écrit :
| on peut utiliser : { =EQUIV(2;SI(A2:A7=4;1);1) }
Aussi, en variantes, des formules matricielles!
=EQUIV(1;N(A2:A7=4);1) ou =EQUIV(1;1*(A2:A7=4);1)
Oui merci : je ne connaissais pas N(...) qui convertit en nombre les booléens et les dates.
OU {=EQUIV(1;CHERCHE(4;A2:A7);1)}
C'était la première formule, avec CHERCHE : il s'avère qu'elle est largement plus lente qu'un test avec '=' (par contre CHERCHE permet les caractères génériques...)
Cordialement.
Le 07/11/2014 12:08, MichD a écrit :
| on peut utiliser : { =EQUIV(2;SI(A2:A7=4;1);1) }
Aussi, en variantes, des formules matricielles!
=EQUIV(1;N(A2:A7=4);1) ou =EQUIV(1;1*(A2:A7=4);1)
Oui merci : je ne connaissais pas N(...) qui convertit en nombre
les booléens et les dates.
OU
{=EQUIV(1;CHERCHE(4;A2:A7);1)}
C'était la première formule, avec CHERCHE : il s'avère qu'elle est
largement plus lente qu'un test avec '=' (par contre CHERCHE permet les
caractères génériques...)
| on peut utiliser : { =EQUIV(2;SI(A2:A7=4;1);1) }
Aussi, en variantes, des formules matricielles!
=EQUIV(1;N(A2:A7=4);1) ou =EQUIV(1;1*(A2:A7=4);1)
Oui merci : je ne connaissais pas N(...) qui convertit en nombre les booléens et les dates.
OU {=EQUIV(1;CHERCHE(4;A2:A7);1)}
C'était la première formule, avec CHERCHE : il s'avère qu'elle est largement plus lente qu'un test avec '=' (par contre CHERCHE permet les caractères génériques...)
Cordialement.
MichD
| > {=EQUIV(1;CHERCHE(4;A2:A7);1)}
| C'était la première formule, avec CHERCHE
**** Très exactement la première formule était : {=EQUIV(2;CHERCHE(4;A2:A7);1)}
| > {=EQUIV(1;CHERCHE(4;A2:A7);1)}
| C'était la première formule, avec CHERCHE
**** Très exactement la première formule était :
{=EQUIV(2;CHERCHE(4;A2:A7);1)}
J'adore celle-ci ! Cryptique à souhait, et super courte !
MichD
| J'adore celle-ci ! Cryptique à souhait, et super courte !
Désolé de te décevoir, mais la seule formule qui fonctionne dans tous les cas de présentation de la disposition des valeurs numériques dans une colonne est celle-ci : =EQUIV(2;CHERCHE(5;C5:C15);1) =>> validation matricielle.
Toutes les autres formules présentées ne fonctionnent pas dans cet exemple :
Exemple dans une colonne : 1 3 4 2 4 6
Toutes ces formules =EQUIV(1;N(A2:A7=4);1) ou =EQUIV(1;1*(A2:A7=4);1) ou =EQUIV(1;--(A2:A7=4);1)
Elles génèrent un tableau intermédiaire (A2:A7) comme ceci : {0;0;1;0;1;0} Ce tableau contient seulement des valeurs numériques et le 3e argument de la fonction "Equiv() étant 1, on doit avoir dans ce tableau des valeurs en ordre croissant. Comme ce n'est pas le cas, le résultat obtenu dans ce cas est 3, la fonction arrête de chercher puisque la valeur suivante est 0.
Ces fonctions pourraient être utilisées seulement si la position de la valeur recherchée était consécutive dans une série de chiffres comme :
1 3 4 4 4 6
Avec la fonction "Cherche", lorsque la valeur n'est pas trouvée, au lieu d'avoir des 0 et des 1, on a des "#VALEUR!" et des 1.
Je vois qu'il y en a plusieurs qui suivent... mais arrêtez-moi quelqu'un! ;-))
| J'adore celle-ci ! Cryptique à souhait, et super courte !
Désolé de te décevoir, mais la seule formule qui fonctionne dans tous les
cas
de présentation de la disposition des valeurs numériques dans une colonne
est
celle-ci : =EQUIV(2;CHERCHE(5;C5:C15);1) =>> validation matricielle.
Toutes les autres formules présentées ne fonctionnent pas dans cet exemple :
Exemple dans une colonne :
1
3
4
2
4
6
Toutes ces formules
=EQUIV(1;N(A2:A7=4);1) ou =EQUIV(1;1*(A2:A7=4);1) ou
=EQUIV(1;--(A2:A7=4);1)
Elles génèrent un tableau intermédiaire (A2:A7) comme ceci : {0;0;1;0;1;0}
Ce tableau contient seulement des valeurs numériques et le 3e argument de la
fonction "Equiv() étant 1, on doit avoir dans ce tableau des valeurs en
ordre croissant. Comme ce n'est pas le cas, le résultat obtenu dans ce cas
est 3, la fonction arrête de chercher puisque la valeur suivante est 0.
Ces fonctions pourraient être utilisées seulement si la position de la
valeur recherchée était consécutive dans une série de chiffres comme :
1
3
4
4
4
6
Avec la fonction "Cherche", lorsque la valeur n'est pas trouvée, au lieu
d'avoir des 0 et des 1, on a des "#VALEUR!" et des 1.
Je vois qu'il y en a plusieurs qui suivent... mais arrêtez-moi quelqu'un!
;-))
| J'adore celle-ci ! Cryptique à souhait, et super courte !
Désolé de te décevoir, mais la seule formule qui fonctionne dans tous les cas de présentation de la disposition des valeurs numériques dans une colonne est celle-ci : =EQUIV(2;CHERCHE(5;C5:C15);1) =>> validation matricielle.
Toutes les autres formules présentées ne fonctionnent pas dans cet exemple :
Exemple dans une colonne : 1 3 4 2 4 6
Toutes ces formules =EQUIV(1;N(A2:A7=4);1) ou =EQUIV(1;1*(A2:A7=4);1) ou =EQUIV(1;--(A2:A7=4);1)
Elles génèrent un tableau intermédiaire (A2:A7) comme ceci : {0;0;1;0;1;0} Ce tableau contient seulement des valeurs numériques et le 3e argument de la fonction "Equiv() étant 1, on doit avoir dans ce tableau des valeurs en ordre croissant. Comme ce n'est pas le cas, le résultat obtenu dans ce cas est 3, la fonction arrête de chercher puisque la valeur suivante est 0.
Ces fonctions pourraient être utilisées seulement si la position de la valeur recherchée était consécutive dans une série de chiffres comme :
1 3 4 4 4 6
Avec la fonction "Cherche", lorsque la valeur n'est pas trouvée, au lieu d'avoir des 0 et des 1, on a des "#VALEUR!" et des 1.
Je vois qu'il y en a plusieurs qui suivent... mais arrêtez-moi quelqu'un! ;-))
Jacquouille
Mon Bon Denis La politique actuelle étant le laxisme, on n'arrête plus les gens. -)) Voici une autre solution qui a dépoussiéré mon neurone ---------------- Sub Le_dernier() derL = [A65536].End(3).Row For zz = derL To 1 Step -1 If Range("a" & zz).Value = 4 Then MsgBox zz: Exit Sub End If Next End Sub --------------------- Jacquouille
" Le vin est au repas ce que le parfum est à la femme." "MichD" a écrit dans le message de groupe de discussion : m3l4kg$647$
| J'adore celle-ci ! Cryptique à souhait, et super courte !
Désolé de te décevoir, mais la seule formule qui fonctionne dans tous les cas de présentation de la disposition des valeurs numériques dans une colonne est celle-ci : =EQUIV(2;CHERCHE(5;C5:C15);1) =>> validation matricielle.
Toutes les autres formules présentées ne fonctionnent pas dans cet exemple :
Exemple dans une colonne : 1 3 4 2 4 6
Toutes ces formules =EQUIV(1;N(A2:A7=4);1) ou =EQUIV(1;1*(A2:A7=4);1) ou =EQUIV(1;--(A2:A7=4);1)
Elles génèrent un tableau intermédiaire (A2:A7) comme ceci : {0;0;1;0;1;0} Ce tableau contient seulement des valeurs numériques et le 3e argument de la fonction "Equiv() étant 1, on doit avoir dans ce tableau des valeurs en ordre croissant. Comme ce n'est pas le cas, le résultat obtenu dans ce cas est 3, la fonction arrête de chercher puisque la valeur suivante est 0.
Ces fonctions pourraient être utilisées seulement si la position de la valeur recherchée était consécutive dans une série de chiffres comme :
1 3 4 4 4 6
Avec la fonction "Cherche", lorsque la valeur n'est pas trouvée, au lieu d'avoir des 0 et des 1, on a des "#VALEUR!" et des 1.
Je vois qu'il y en a plusieurs qui suivent... mais arrêtez-moi quelqu'un! ;-))
Mon Bon Denis
La politique actuelle étant le laxisme, on n'arrête plus les gens. -))
Voici une autre solution qui a dépoussiéré mon neurone
----------------
Sub Le_dernier()
derL = [A65536].End(3).Row
For zz = derL To 1 Step -1
If Range("a" & zz).Value = 4 Then
MsgBox zz: Exit Sub
End If
Next
End Sub
---------------------
Jacquouille
" Le vin est au repas ce que le parfum est à la femme."
"MichD" a écrit dans le message de groupe de discussion :
m3l4kg$647$1@speranza.aioe.org...
| J'adore celle-ci ! Cryptique à souhait, et super courte !
Désolé de te décevoir, mais la seule formule qui fonctionne dans tous les
cas
de présentation de la disposition des valeurs numériques dans une colonne
est
celle-ci : =EQUIV(2;CHERCHE(5;C5:C15);1) =>> validation matricielle.
Toutes les autres formules présentées ne fonctionnent pas dans cet exemple :
Exemple dans une colonne :
1
3
4
2
4
6
Toutes ces formules
=EQUIV(1;N(A2:A7=4);1) ou =EQUIV(1;1*(A2:A7=4);1) ou
=EQUIV(1;--(A2:A7=4);1)
Elles génèrent un tableau intermédiaire (A2:A7) comme ceci : {0;0;1;0;1;0}
Ce tableau contient seulement des valeurs numériques et le 3e argument de la
fonction "Equiv() étant 1, on doit avoir dans ce tableau des valeurs en
ordre croissant. Comme ce n'est pas le cas, le résultat obtenu dans ce cas
est 3, la fonction arrête de chercher puisque la valeur suivante est 0.
Ces fonctions pourraient être utilisées seulement si la position de la
valeur recherchée était consécutive dans une série de chiffres comme :
1
3
4
4
4
6
Avec la fonction "Cherche", lorsque la valeur n'est pas trouvée, au lieu
d'avoir des 0 et des 1, on a des "#VALEUR!" et des 1.
Je vois qu'il y en a plusieurs qui suivent... mais arrêtez-moi quelqu'un!
;-))
Mon Bon Denis La politique actuelle étant le laxisme, on n'arrête plus les gens. -)) Voici une autre solution qui a dépoussiéré mon neurone ---------------- Sub Le_dernier() derL = [A65536].End(3).Row For zz = derL To 1 Step -1 If Range("a" & zz).Value = 4 Then MsgBox zz: Exit Sub End If Next End Sub --------------------- Jacquouille
" Le vin est au repas ce que le parfum est à la femme." "MichD" a écrit dans le message de groupe de discussion : m3l4kg$647$
| J'adore celle-ci ! Cryptique à souhait, et super courte !
Désolé de te décevoir, mais la seule formule qui fonctionne dans tous les cas de présentation de la disposition des valeurs numériques dans une colonne est celle-ci : =EQUIV(2;CHERCHE(5;C5:C15);1) =>> validation matricielle.
Toutes les autres formules présentées ne fonctionnent pas dans cet exemple :
Exemple dans une colonne : 1 3 4 2 4 6
Toutes ces formules =EQUIV(1;N(A2:A7=4);1) ou =EQUIV(1;1*(A2:A7=4);1) ou =EQUIV(1;--(A2:A7=4);1)
Elles génèrent un tableau intermédiaire (A2:A7) comme ceci : {0;0;1;0;1;0} Ce tableau contient seulement des valeurs numériques et le 3e argument de la fonction "Equiv() étant 1, on doit avoir dans ce tableau des valeurs en ordre croissant. Comme ce n'est pas le cas, le résultat obtenu dans ce cas est 3, la fonction arrête de chercher puisque la valeur suivante est 0.
Ces fonctions pourraient être utilisées seulement si la position de la valeur recherchée était consécutive dans une série de chiffres comme :
1 3 4 4 4 6
Avec la fonction "Cherche", lorsque la valeur n'est pas trouvée, au lieu d'avoir des 0 et des 1, on a des "#VALEUR!" et des 1.
Je vois qu'il y en a plusieurs qui suivent... mais arrêtez-moi quelqu'un! ;-))
GL
Le 08/11/2014 14:08, MichD a écrit :
| J'adore celle-ci ! Cryptique à souhait, et super courte !
Désolé de te décevoir, mais la seule formule qui fonctionne dans tous les cas celle-ci : =EQUIV(2;CHERCHE(5;C5:C15);1) =>> validation matricielle.
Toutes les autres formules présentées ne fonctionnent pas dans cet exemple : Toutes ces formules =EQUIV(1;N(A2:A7=4);1) ou =EQUIV(1;1*(A2:A7=4);1) ou =EQUIV(1;--(A2:A7=4);1)
Non : {=EQUIV(2; SI(4¢:A7;1); 1)}
fonctionne, car les valeurs 4 sont remplacées par 1 dans la liste, toutes les autres étant remplacées par FAUX : EQUIV(2, ... fonctionne donc bien dans ce cas.
C'est la formule que j'ai utilisée. Elle est *BEAUCOUP* plus *RAPIDE* que CHERCHE
Pour la petite histoire, je voulais construire un arbre à partir du log (retraité) de gcc -E -dI pour avoir l'arborescence de tous les fichiers inclus. J'ai donc un listing automatique et assez long !
Au départ, j'ai :
source <l> inclus => "inclus" est inclus par source en sa ligne l source <l> inclus source <l> inclus source <l> inclus
Il y a env. 700 lignes comme ça.
Si 'source' = 'inclus' -> j'augmente la profondeur de l'arbre de 1 Sinon -> je cherche au-dessus de 'source' la dernière occurrence de 'source' (c'est là que j'ai besoin d'EQUIV(2 ...)) ce qui me donne la profondeur déjà calculée auparavant, en utilisant INDEX
A la fin j'ai :
source <l> inclus <profondeur dans l'arborescence> source <l> inclus <profondeur dans l'arborescence> source <l> inclus <profondeur dans l'arborescence> source <l> inclus <profondeur dans l'arborescence>
Quand je recalcule avec CHERCHE sur mon Intel i7 x86-64 à 1,9 GHz ça met bien 5 secondes (honte à Excel...)
Quand j'utilise {=EQUIV(2; SI(A12=$A$2:A11; 1); 1)} ça met 1 seconde.
Je vois qu'il y en a plusieurs qui suivent... mais arrêtez-moi quelqu'un! ;-))
Non j'ai bien suivi, merci ! C'est vrai que les formules avec N(...) 1*(booléen) etc. ne vont pas fonctionner correctement !
Bon weekend.
Le 08/11/2014 14:08, MichD a écrit :
| J'adore celle-ci ! Cryptique à souhait, et super courte !
Désolé de te décevoir, mais la seule formule qui fonctionne dans tous
les cas
celle-ci : =EQUIV(2;CHERCHE(5;C5:C15);1) =>> validation matricielle.
Toutes les autres formules présentées ne fonctionnent pas dans cet
exemple :
Toutes ces formules
=EQUIV(1;N(A2:A7=4);1) ou =EQUIV(1;1*(A2:A7=4);1) ou
=EQUIV(1;--(A2:A7=4);1)
Non : {=EQUIV(2; SI(4¢:A7;1); 1)}
fonctionne, car les valeurs 4 sont remplacées par 1 dans la liste,
toutes les autres étant remplacées par FAUX : EQUIV(2, ... fonctionne
donc bien dans ce cas.
C'est la formule que j'ai utilisée.
Elle est *BEAUCOUP* plus *RAPIDE* que CHERCHE
Pour la petite histoire, je voulais construire un arbre à partir du log
(retraité) de gcc -E -dI pour avoir l'arborescence de tous les
fichiers inclus. J'ai donc un listing automatique et assez long !
Au départ, j'ai :
source <l> inclus => "inclus" est inclus par source en sa ligne l
source <l> inclus
source <l> inclus
source <l> inclus
Il y a env. 700 lignes comme ça.
Si 'source' = 'inclus'
-> j'augmente la profondeur de l'arbre de 1
Sinon
-> je cherche au-dessus de 'source' la dernière occurrence de
'source' (c'est là que j'ai besoin d'EQUIV(2 ...)) ce qui me
donne la profondeur déjà calculée auparavant, en utilisant
INDEX
A la fin j'ai :
source <l> inclus <profondeur dans l'arborescence>
source <l> inclus <profondeur dans l'arborescence>
source <l> inclus <profondeur dans l'arborescence>
source <l> inclus <profondeur dans l'arborescence>
Quand je recalcule avec CHERCHE sur mon Intel i7 x86-64 à 1,9 GHz
ça met bien 5 secondes (honte à Excel...)
Quand j'utilise {=EQUIV(2; SI(A12=$A$2:A11; 1); 1)} ça met 1 seconde.
Je vois qu'il y en a plusieurs qui suivent... mais arrêtez-moi quelqu'un!
;-))
Non j'ai bien suivi, merci ! C'est vrai que les formules avec
N(...) 1*(booléen) etc. ne vont pas fonctionner correctement !
| J'adore celle-ci ! Cryptique à souhait, et super courte !
Désolé de te décevoir, mais la seule formule qui fonctionne dans tous les cas celle-ci : =EQUIV(2;CHERCHE(5;C5:C15);1) =>> validation matricielle.
Toutes les autres formules présentées ne fonctionnent pas dans cet exemple : Toutes ces formules =EQUIV(1;N(A2:A7=4);1) ou =EQUIV(1;1*(A2:A7=4);1) ou =EQUIV(1;--(A2:A7=4);1)
Non : {=EQUIV(2; SI(4¢:A7;1); 1)}
fonctionne, car les valeurs 4 sont remplacées par 1 dans la liste, toutes les autres étant remplacées par FAUX : EQUIV(2, ... fonctionne donc bien dans ce cas.
C'est la formule que j'ai utilisée. Elle est *BEAUCOUP* plus *RAPIDE* que CHERCHE
Pour la petite histoire, je voulais construire un arbre à partir du log (retraité) de gcc -E -dI pour avoir l'arborescence de tous les fichiers inclus. J'ai donc un listing automatique et assez long !
Au départ, j'ai :
source <l> inclus => "inclus" est inclus par source en sa ligne l source <l> inclus source <l> inclus source <l> inclus
Il y a env. 700 lignes comme ça.
Si 'source' = 'inclus' -> j'augmente la profondeur de l'arbre de 1 Sinon -> je cherche au-dessus de 'source' la dernière occurrence de 'source' (c'est là que j'ai besoin d'EQUIV(2 ...)) ce qui me donne la profondeur déjà calculée auparavant, en utilisant INDEX
A la fin j'ai :
source <l> inclus <profondeur dans l'arborescence> source <l> inclus <profondeur dans l'arborescence> source <l> inclus <profondeur dans l'arborescence> source <l> inclus <profondeur dans l'arborescence>
Quand je recalcule avec CHERCHE sur mon Intel i7 x86-64 à 1,9 GHz ça met bien 5 secondes (honte à Excel...)
Quand j'utilise {=EQUIV(2; SI(A12=$A$2:A11; 1); 1)} ça met 1 seconde.
Je vois qu'il y en a plusieurs qui suivent... mais arrêtez-moi quelqu'un! ;-))
Non j'ai bien suivi, merci ! C'est vrai que les formules avec N(...) 1*(booléen) etc. ne vont pas fonctionner correctement !
