Ai-je besoin d'une seule boucle ou d'une boucle imbriquée pour cela?

Question

Disons que j'ai un tableau et une méthode booléenne. Cette méthode booléenne retournera vrai si tous les nombres positifs apparaissent avant tous les nombres non-positifs (0 inclus). Sinon, il retournera une valeur fausse. Le premier tableau newArrayTrue retournera une valeur vraie car tous les nombres positifs apparaissent avant tous les nombres non-positifs et 0. Alors que dans newArrayFalse, il retournera une valeur fausse car 0 apparaît avant 5, et 5 est un nombre positif.

int[] newArrayTrue = {3,1,-4,0,-5}; 
int[] newArrayFalse = {3,1,-4,0,5}; 

public static boolean isPositiveFirst(int[] numbers) { 

for (int i=0; i<numbers.length; i++) { 
    for (int j=i+1; i<numbers.length; i++) { 
    if (numbers[i] > 0 && (numbers[i+1] < 0 || numbers[i+1] == 0)) { 
     return true; 
    } 
    } 
} 
return false; 
} 
} 

Ai-je besoin d'avoir une boucle imbriquée dans la méthode booléenne ou il peut être fait en une seule boucle? Et j'ai besoin d'aide avec mes conditions car je ne comprends pas vraiment le problème. Appréciez toute aide.

Answer 1

Cela devrait suffire:

public static boolean isPositiveFirst(int[] numbers) { 
    for(int i = 1; i < numbers.length; i++) { 
     if(numbers[i] > 0 && numbers[i-1] <= 0) { 
      return false; 
     } 
    } 
    return true; 
} 

également un certain crédit à @Ryan, depuis qu'il a supprimé sa réponse sur laquelle je me suis basé code.

Answer 2

Vous pouvez simplement utiliser une variable booléenne issueNegative et la définir sur true si vous rencontrez un 0 ou un nombre négatif. Puis continuez l'itération et si un nombre positif est trouvé, la méthode devrait renvoyer false. Si la boucle se termine, la méthode renvoie true.

Quelque chose comme ceci:

public static boolean isPositiveFirst(int[] numbers) { 

    boolean encounteredNegative = false; 
    for (int i = 0; i < numbers.length; i++) { 
     if (numbers[i] <= 0) { 
      encounteredNegative = true; 
     } else { 
      if (encounteredNegative) { 
       return false; 
      } 
     } 
    } 
    return true; 
} 

Answer 3

Que diriez-vous de ceci.

private static boolean areAllPositiveFirst(int[] a) 
    { 
     boolean f=false,ans=true; 
     for (int i = 0; i < a.length; i++) 
     { 
      if(f && a[i]>0) 
      { 
       ans=false; 
       break; 
      } 
      if(a[i]<=0) 
       f=true; 
     } 
     return ans; 
    } 

Answer 4

Comme alternative aux réponses données, en utilisant IntStream vous pouvez faire quelque chose comme:

public static boolean isPositiveFirst(int[] numbers) { 
    int k = IntStream.range(0, numbers.length).filter(i -> numbers[i]<1).findFirst().orElse(-1); 
    if(k < 0) 
     return true;   
    else 
     return IntStream.of(Arrays.copyOfRange(numbers, k, numbers.length)).filter(i-> i>0).count() <1; 
} 

Answer 5

Je vois que Lubomir Papazov déjà venu avec cet algorithme. Ma mise en œuvre est juste un peu plus laconique:

public static boolean isPositiveFirst(int[] numbers) { 
    boolean seenNonPositive = false; 
    for(int i : numbers) { 
     if(i < 1) seenNonPositive = true; 
     else if(seenNonPositive) return false; 
    } 
    return true; 
}