Pour chaque multiple de 10 dans le tableau donné, changez toutes les valeurs qui le suivent pour être ce multiple de 10, jusqu'à rencontrer un autre multiple de 10. Donc {2, 10, 3, 4, 20, 5} donne {2 , 10, 10, 10, 20, 20}.
Je ne comprends pas pourquoi cela fonctionne. Dans mon esprit, la sortie pour {1, 10, 2, 2} doit être {1, 10, 10, 2}, car la boucle for ne doit détecter% 10 == 0 qu'une seule fois, puis reboucler et ne pas le détecter. la prochaine fois. Pourquoi fait-il cela plus d'une fois?
public int[] tenRun(int[] nums) { for (int i = 0; i < nums.length-1; i++) { if (nums[i] % 10 == 0) { if (nums[i+1] % 10 != 0) { nums[i+1] = nums[i]; } } } return nums; }
4 Réponses :
La boucle for ne boucle que nums.length-1 fois, et elle regarde toutes les paires qui se chevauchent d'éléments dans le tableau: nums [i] (que j'appellerai a ) et nums [i + 1] (que j'appellerai b ). p >
La boucle for ne changera jamais que b , et jamais a . Il vérifie uniquement si a est un multiple de 10. Si tel est le cas, définissez b sur a . Regardez la dernière paire du tableau, b voici le dernier élément. Par conséquent, le dernier élément sera potentiellement modifié par la boucle.
La boucle examinera à un moment donné nums [1] et nums [2] , et après avoir défini nums [2] sur 10, il regarde maintenant la dernière paire, qui est nums [2] ( a ) et nums [3] ( b ). Remarquez comment nums [2] vient d'être défini sur 10, afin que , nums [3] puisse également être défini sur 10 .
D'un autre côté, la boucle ne positionnera jamais le premier élément, qui est le a de la première paire. C'est correct car ce ne sera pas après un multiple de 10.
Lorsque vous détectez un multiple de 10, suivi d'un non-multiple de 10, votre algorithme met à jour la valeur suivante. Lors de la prochaine itération de la boucle, vous rencontrez cette valeur mise à jour . Étant donné que cela doit être un multiple de 10 maintenant, la valeur suivante est alors mise à jour.
Si nous considérons l'état de i et nums au niveau de au début de chaque itération, on trouve:
0: 1, 10, 2, 2 1: 1, 10, 2, 2 2: 1, 10, 10, 2
Donc sur cette dernière itération (la boucle se termine quand i == 3 ), nums [2] == 10 , donc nums [3] est également défini sur 10.
À chaque itération, chaque fois que la condition, nums [i]% 10 == 0 prend la valeur true (c'est-à-dire nums [i] est un multiple de 10 ), il vérifie si l'élément suivant n'est pas un multiple de 10 ie nums [i + 1]% 10! = 0 et si c'est le cas, il définit l'élément suivant sur nums [i] qui est un multiple de 10 . J'espère que cela vous aide à comprendre comment cela fonctionne. N'hésitez pas à commenter en cas de doute supplémentaire.
[2, 10, 10, 10, 20, 20]
Résultat:
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
System.out.println(Arrays.toString(tenRun(new int[] { 2, 10, 3, 4, 20, 5 })));
}
public static int[] tenRun(int[] nums) {
for (int i = 0; i < nums.length - 1; i++) {
if (nums[i] % 10 == 0) {
if (nums[i + 1] % 10 != 0) {
nums[i + 1] = nums[i];
}
}
}
return nums;
}
}
OOOH maintenant je comprends, je ne me souviens pas que l'élément est mis à jour, merci!
Essayez ceci: -
public int[] tenRun(int[] nums) {
for(int i=0;i<nums.length;i++){
if(nums[i]%10==0){
for(int j=i+1;j<nums.length && nums[j]%10!=0;j++){
nums[j]=nums[i];
}
}
}
return nums;
}
Veuillez ajouter quelques commentaires, explications, astuces, etc.