Comment créer max méthode qui obtient 4 nombres et retourne le nombre maximal?

Je suis en train de construire une méthode qui permettrait d'obtenir 4 nombres et retourne le nombre maximum d'entre eux.

J'ai essayé d'écrire ce code à 4 chiffres, mais cela ne fonctionne pas:

D'entrée et de sortie:

double a = Math.max(10, 5, 4, 3);
    System.out.println(a);

public static int max(int a, int b, int c, int d) {
    if (a > b && a > c && a > d)
        return a;
    if (b > a && b > c && b > d)
        return b;
    if (c > a && c > b && c > d)
        return c;
    if (d > b && d > c && d > a)
        return d;
}

utilisation Math.max(Math.max(Math.max(a,b),Math.max(c,d)))
vous pouvez utiliser un int[] au lieu de 4 ints aussi
Que faire si deux éléments sont à la fois plus grand? Je suppose que max(2, 3, 4, 4) devrait être de 4, mais de quelle façon votre code est censé arriver à ce résultat?
S'il vous plaît (avez-vous dit cela avant?) être plus précis. “Pas de travail” n'est pas une description du problème. Vous devez nous dire exactement ce que votre code ne diffère de la désirée. Vous avez également besoin de citer tous les messages d'erreur exactement.

InformationsquelleAutor YoAv | 2014-12-04

14

Je voudrais simplifier cela en introduisant une variable max:
```
public static int max(int a, int b, int c, int d) {

    int max = a;

    if (b > max)
        max = b;
    if (c > max)
        max = c;
    if (d > max)
        max = d;

     return max;
}
```
Vous pouvez également utiliser Math.max, comme suggéré par rapide escargot, mais depuis ce qui semble être des devoirs, je préfère la solution algorithmique.
```
Math.max(Math.max(a,b),Math.max(c,d))
```
- Patrick, j'avais prévu de vous à être trop connu sur Stackoverflow pour résoudre des gens de devoirs à la maison pour eux. 🙂
InformationsquelleAutor Patrick Hofman
4

Essayer Math.max comme ci-dessous:
```
return Math.max(Math.max(a, b), Math.max(c, d));
```
InformationsquelleAutor SMA
1

Vous pouvez toujours utiliser une méthode comme ce qui va fonctionner comme vous le souhaitez pour n'importe quel nombre d'entiers:
```
public static Integer max(Integer... vals) {
    return new TreeSet<>(Arrays.asList(vals)).last();
}
```
Appel, par exemple, que:
```
System.out.println(max(10, 5, 17, 4, 3));
```
InformationsquelleAutor BarrySW19
0
```
if (c > a && c > b && c > d)
    return d;
```
ici, vous êtes de retour d au lieu de c.
- Ajouter plus de description afin que les autres puissent comprendre
InformationsquelleAutor PARITOSH THAPLIYAL

Un moyen de plus pour le faire...

public static int max(int a, int b, int c, int d) {
    if (a > b && a > c && a > d)
        return a;
    if (b > c && b > d)
        return b;
    if (c > d)
        return c;
    return d;
}

InformationsquelleAutor Erich Kitzmueller

0
```
public static Integer max(Integer... values)
{
     Integer maxValue = null
     for(Integer value : values)
         if(maxValue == null || maxValue < value)
              maxValue = value;
     return maxValue;
}
```
- Cet emporte sur les autres suggestions pour (a) la manipulation d'un nombre quelconque de valeurs et (b) l'acceptation d'un tableau de valeurs d'entrée trop, rend ce beaucoup plus souple qu'une méthode acceptant exactement quatre entiers.
- Quid des performances de la mémoire? Inutile varargs la création de la matrice et inutile de boxe. Ni ce que l'OP a demandé.
InformationsquelleAutor maimArt

public static int max(int a, int b, int c, int d){
        return (a>b && a>c && a>d? a: b>c && b>d? b: c>d? c:d);
    }

InformationsquelleAutor Ar maj

public static int max(int a, int b, int c, int d) {

   int tmp1 = a > b ? a : b;
   int tmp2 = c > d ? c : d;

   return tmp1 > tmp2 ? tmp1 : tmp2;
}

InformationsquelleAutor coja

public static int max(Integer... vals) {
    return Collections.max(Arrays.asList(vals));
}

InformationsquelleAutor shifu

private int max(int... p)
{
    int max = 0;
    for (int i : p) {
        max = i > max ? i : max; 
    }
    return max;

}

InformationsquelleAutor Karthik Bose

Vous devez vous connecter pour publier un commentaire.