Codewars – Gipfel auswählen

Anreden.

Ich poste in dieser Serie Codewars-Herausforderungen und meinen Denkprozess. Ich verwende wann immer möglich JS und Node 18. Nur der Klarheit halber nutze ich sie fair.

Ich habe eine Pause gemacht und bin jetzt zurück. Habe allerdings einige Herausforderungen gemeistert, ohne die Lösung hier zu veröffentlichen. Gehen wir eine einfache Herausforderung an.

Gipfel auswählen macht Spaß. Sie müssen lokale Maxima entsprechend ihrer mathematischen Definition finden. Von GFG:

Mathematisch gilt f (a) ≥ f (a -h) und f (a) ≥ f (a h), wobei h > 0, dann wird a als lokaler Maximalpunkt bezeichnet.

Im Wesentlichen müssen wir sehen, welche Werte größer sind als ihre nächsten Nachbarn. Wenn ein Nachbar fehlt, können wir nicht überprüfen, ob es sich um ein lokales Maximum handelt oder nicht. Daher werden wir die Grenzen des Arrays nicht überprüfen.

Die folgende Lösung ist nicht optimiert. Es sollte ein Durchgang sein. Außerdem wurde mir beigebracht, Pausen und Fortfahren zu vermeiden. Aber es erfüllt seinen Zweck.

Zuerst legen wir die Regeln fest:

• Wenn das Array leer ist, werden leere Arrays zurückgegeben. [] => {pos:[], Spitzen:[]}
• Wenn ein Wert kleiner oder gleich dem vorherigen ist, wird er automatisch verworfen (Plateaus werden in einer anderen Regel behandelt). (array[i] <= array[i-1]) ? verwerfen
• Wenn ein Wert NICHT durch die vorherige Regel verworfen wird UND größer als der nächste Wert ist, handelt es sich um ein Maximum. (array[i] > array[i 1])? maximal
• Wenn ein Wert NICHT durch die oben genannte Regel verworfen wird UND er GLEICH DEM nächsten Wert ist, bedarf er einer besonderen Behandlung. Wir werden das später lösen.

Zweitens benötigt es einen bestimmten Rückgabewert: {pos:[],peaks:[]}
Diese Herausforderung fragt nach Position und Wert der Maxima.

Drittens müssen wir eine Schleife für das Array festlegen:
for (sei i = 1 ; i < arr.length -1 ; i )
Wir überspringen den ersten und den letzten Wert, da es sich laut Definition nie um Maxima handelt.

Viertens setzen wir die Regeln um:

  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>Wir müssen den letzten Teil verfeinern. Das ist die oben erwähnte Sonderbehandlung bei der Festlegung der Regeln. Es handelt sich lediglich um eine weitere Schleife, die als Unterprozess fungiert:<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]);
        }
      }
    }

Die Summe von allem ist folgende:

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;
}

Und jetzt testen wir es... Juhu! Es ist vergangen! Lasst uns einreichen und...

Oh nein. Was???

Dieser spezielle Test: 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])
Dies sollte Folgendes zurückgeben: {pos:[2,7,14,20], Peaks:[5,6,5,5]}
Es wird zurückgegeben: {pos:[2,7,14,20,20], Peaks:[5,6,5,5,5]}

Aber warum? Die Logik ist fundiert. Und jede Schleife ist richtig... Ähmmm... Warte... Es wird dupliziert. Position 20, Wert 5. Es ist zweimal da. Hier stimmt etwas nicht:

  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
    }
  }

Nach einigem Debuggen mit Dev Tools habe ich es gefunden. Hier ist das Problem:

    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]);
        }
      }
    }

Es fehlt eine Break-Anweisung. [...3,5,5,4,3] dupliziert den zweiten Wert, da es nur dann aus der inneren Schleife ausbricht, wenn es eine Sequenz findet, in der diese Beendigungsbedingung auftritt:

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;
}

Sonst geht es weiter. Es stellt sich heraus, dass es auch beendet werden sollte, wenn es ein Maximum findet:

    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]);
        }
      }
    }

BEHOBEN:

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

Ineffizient, aber effektiv.

Pass auf dich auf. Wasser trinken???.

Zurück

Das obige ist der detaillierte Inhalt vonCodewars – Gipfel auswählen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!