Heim > Web-Frontend > js-Tutorial > Codewars – Gipfel auswählen

Codewars – Gipfel auswählen

Patricia Arquette
Freigeben: 2025-01-11 06:59:43
Original
671 Leute haben es durchsucht

Anreden.

Codewars - Pick peaks

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>

<div class="code" style="position:relative; padding:0px; margin:0px;"><div class="code" style="position:relative; padding:0px; margin:0px;"><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]);
        }
      }
    }
Nach dem Login kopieren
Nach dem Login kopieren
Nach dem Login kopieren

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;
}
Nach dem Login kopieren
Nach dem Login kopieren

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

Oh nein. Was???

Codewars - Pick peaks

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 dem Login kopieren

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]);
        }
      }
    }
Nach dem Login kopieren
Nach dem Login kopieren

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;
}
Nach dem Login kopieren
Nach dem Login kopieren

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]);
        }
      }
    }
Nach dem Login kopieren
Nach dem Login kopieren

BEHOBEN:

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

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!

Quelle:dev.to
Vorheriger Artikel:Die wichtigsten Fragen und Antworten zu HTML-Interviews Nächster Artikel:Von lokal zu global: Die Azure-Migration, die unsere Effizienz und Sicherheit steigerte
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Neueste Artikel des Autors
Aktuelle Ausgaben
verwandte Themen
Mehr>
Beliebte Empfehlungen
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage