Codewars - Choisissez des sommets

Salutations.

Je publie les défis Codewars et mon processus de réflexion dans cette série. J'utilise JS et Node 18 autant que possible. Par souci de clarté, j'en fais un usage équitable.

J'ai fait une pause, et maintenant je suis de retour. J'ai cependant fait quelques défis sans publier la solution ici. Abordons un défi facile.

Choisir des sommets est une activité amusante. Vous devez trouver les maxima locaux selon sa définition mathématique. De GFG :

Mathématiquement, f (a) ≥ f (a -h) et f (a) ≥ f (a h) où h > 0, alors a est appelé le point maximum local.

En substance, nous devons voir quelles valeurs sont plus grandes que ses plus proches voisins. S'il manque un voisin, nous ne pouvons pas vérifier s'il s'agit d'un maximum local ou non. Nous ne vérifierons donc pas les bordures du tableau.

La solution suivante n'est pas optimisée. Cela devrait être un seul passage. De plus, on m'a appris à éviter d'utiliser break et à continuer. Mais ça fait le travail.

Nous fixons d'abord les règles :

• Si le tableau est vide, renvoie les tableaux vides. [] => {pos :[], pics :[]}
• Si une valeur est inférieure ou égale à la précédente, elle est automatiquement écartée (les plateaux seront traités dans une autre règle). (tableau[i] <= tableau[i-1]) ? jeter
• Si une valeur n'est PAS écartée par la règle précédente, ET qu'elle est supérieure à la valeur suivante, c'est un maximum. (tableau[i] > tableau[i 1]) ? maximum
• Si une valeur n'est PAS écartée par la règle susmentionnée, ET qu'elle est ÉGALE À la valeur suivante, elle nécessite un traitement spécial. Nous résoudrons cela plus tard.

Deuxièmement, il a besoin d'une valeur de retour spécifique : {pos :[], Peaks :[]}
Ce défi demande la position et la valeur des maxima.

Troisièmement, nous devons définir une boucle pour le tableau :
pour (soit i = 1 ; i < arr.length -1 ; i )
Nous ignorons la première et la dernière valeur car elles ne seront jamais maximales selon la définition.

Quatrièmement, nous mettons en œuvre les règles :

  for (let i = 1 ; i < arr.length -1 ; i++){
    if (arr[i] <= arr[i-1]){
      continue;
    }
    if (arr[i] > arr[i+1]){
      cache.pos.push(i);
      cache.peaks.push(arr[i]);
    }
    if (arr[i] == arr[i+1]){
      // TO DO
    }
  }




</p>
<p>Nous devrons affiner cette dernière partie. C'est le traitement spécial mentionné ci-dessus lors de l'établissement des règles. Il s'agit simplement d'une autre boucle qui agit comme un sous-processus :<br>
</p>

<pre class="brush:php;toolbar:false">    if (arr[i] == arr[i+1]){
      for (let j=i +1 ; j< arr.length - 1; j++){
        if (arr[j] == arr[j+1]){
          continue;
        }
        if (arr[j] < arr[j+1]){
          break;
        }
        if (arr[j] > arr[j+1]){
          cache.pos.push(i);
          cache.peaks.push(arr[i]);
        }
      }
    }

La somme de tout cela est la suivante :

function pickPeaks(arr){
  let cache = {pos:[], peaks:[]};
  if (arr == false) {
    return cache;
  }

  for (let i = 1 ; i < arr.length -1 ; i++){
    if (arr[i] <= arr[i-1]){
      continue;
    }
    if (arr[i] > arr[i+1]){
      cache.pos.push(i);
      cache.peaks.push(arr[i]);
    }
    if (arr[i] == arr[i+1]){
      for (let j=i +1 ; j< arr.length - 1; j++){
        if (arr[j] == arr[j+1]){
          continue;
        }
        if (arr[j] < arr[j+1]){
          break;
        }
        if (arr[j] > arr[j+1]){
          cache.pos.push(i);
          cache.peaks.push(arr[i]);
        }
      }
    }
  }

  return cache;
}

Et maintenant, testons-le... Yay ! C'est passé ! Soumettons-nous et...

Oh non. Quoi???

Ce test particulier : pickPeaks([1,2,5,4,3,2,3,6,4,1,2,3,3,4,5,3,2,1,2,3, 5,5,4,3])
Cela devrait renvoyer : {pos :[2,7,14,20], pics :[5,6,5,5]}
Il renvoie : {pos :[2,7,14,20,20], pics :[5,6,5,5,5]}

Mais pourquoi ? La logique est bonne. Et chaque boucle est correctement... Uhmmm... Attendez... Elle est dupliquée. Position 20, valeur 5. C'est là deux fois. Il doit y avoir quelque chose qui ne va pas ici :

  for (let i = 1 ; i < arr.length -1 ; i++){
    if (arr[i] <= arr[i-1]){
      continue;
    }
    if (arr[i] > arr[i+1]){
      cache.pos.push(i);
      cache.peaks.push(arr[i]);
    }
    if (arr[i] == arr[i+1]){
      // TO DO
    }
  }

Après quelques débogages avec Dev Tools, je l'ai trouvé. Voici le problème :

    if (arr[i] == arr[i+1]){
      for (let j=i +1 ; j< arr.length - 1; j++){
        if (arr[j] == arr[j+1]){
          continue;
        }
        if (arr[j] < arr[j+1]){
          break;
        }
        if (arr[j] > arr[j+1]){
          cache.pos.push(i);
          cache.peaks.push(arr[i]);
        }
      }
    }

Il manque une instruction break. [...3,5,5,4,3] duplique la deuxième valeur car elle ne sort de la boucle interne que lorsqu'elle trouve une séquence où cette condition de sortie se produit :

function pickPeaks(arr){
  let cache = {pos:[], peaks:[]};
  if (arr == false) {
    return cache;
  }

  for (let i = 1 ; i < arr.length -1 ; i++){
    if (arr[i] <= arr[i-1]){
      continue;
    }
    if (arr[i] > arr[i+1]){
      cache.pos.push(i);
      cache.peaks.push(arr[i]);
    }
    if (arr[i] == arr[i+1]){
      for (let j=i +1 ; j< arr.length - 1; j++){
        if (arr[j] == arr[j+1]){
          continue;
        }
        if (arr[j] < arr[j+1]){
          break;
        }
        if (arr[j] > arr[j+1]){
          cache.pos.push(i);
          cache.peaks.push(arr[i]);
        }
      }
    }
  }

  return cache;
}

Sinon, ça continue. Il s'avère qu'il devrait également se terminer lorsqu'il trouve un maximum :

    if (arr[i] == arr[i+1]){
      for (let j=i +1 ; j< arr.length - 1; j++){
        if (arr[j] == arr[j+1]){
          continue;
        }
        if (arr[j] < arr[j+1]){
          break;
        }
        if (arr[j] > arr[j+1]){
          cache.pos.push(i);
          cache.peaks.push(arr[i]);
        }
      }
    }

CORRIGÉ :

        if (arr[j] > arr[j+1]){
          cache.pos.push(i);
          cache.peaks.push(arr[i]);
        }

Inefficace, mais efficace.

Prends soin de toi. Boire de l'eau ???.

Précédent

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!