Schreiben Sie bei einem gegebenen Array ein PHP-Programm, um die Anzahl der umgekehrten Paare der Größe drei zu zählen

Abwärtszählen ist eine Schrittzählmethode, mit der wir die Anzahl der für ein bestimmtes Array durchgeführten Sortierschritte zählen können. Es ist auch in der Lage, die Betriebszeitspanne eines Arrays zu berechnen. Wenn wir das Array jedoch umgekehrt sortieren möchten, entspricht die Anzahl der maximal im Array vorhandenen Anzahl.

Array: { 5, 4, 3, 2, 1}  // for the reverse manner
Pairs: {5, 4}, {5,3} , {3,2}, {3,1}, {2,1},{4,3}, {4,2}, {4,1},}, {5,2}, {5,1}
Output: 10
Array: {1, 2, 3, 4, 5}  // for the increasing manner
Pairs: No Pairs
Output: 0
Array: {1,5,2,8,3,4}
Pairs: {5, 2}, {5, 3}, {5, 4}, {8, 3}, {8, 4}
Output: 5  

Die Inversionsanzahl gibt an, wie weit dieses bestimmte Array von der Sortierung in aufsteigender Reihenfolge entfernt ist. Hier sind zwei spezifische Verfahren, die diese Situation mit Lösungen beschreiben –

• Um das kleinere Element zu finden – Um das kleinere Element aus dem Array zu finden, müssen wir den Index von n-1 bis 0 iterieren. Durch Anwenden von (a[i]-1) können wir hier getSum() berechnen. Der Prozess wird ausgeführt, bis er a[i]-1 erreicht.

• Um die größere Zahl zu finden – Um die größere Zahl aus dem Index zu finden, müssen wir die Iterationen 0 bis n-1 durchführen. Für jedes Element müssen wir jede Zahl bis a[i] berechnen. Subtrahiere es von i. Dann erhalten wir eine Zahl größer als a[i].

Algorithmus zur Berechnung der Inversion der Größe 3 in einem Array:-

In diesem Algorithmus lernen wir, wie man die Inversion von Größe 3 in einem bestimmten Array in einer bestimmten Programmierumgebung berechnet.

• Schritt 1 – Los geht’s

• Schritt 2 – Deklarieren Sie das Array und invertieren Sie die Anzahl (wie arr[] -> array und invCount -> invertieren Sie die Anzahl)

• Schritt 3 – Innere Schleife y=x+1 bis N

• Schritt 4 – Wenn das Element bei x größer ist als das Element bei y Index

• Schritt 5 – Dann invCount++ erhöhen

• Schritt 6 – Drucken Sie das Paar aus

• Schritt 7 – Kündigung

Syntax zur Berechnung der Inversion von Größe 3 in einem Array: -

Ein Paar (A[i], A[j]) befindet sich in einem invertierten Zustand, wenn die folgenden Bedingungen erfüllt sind: A[i] > A[j] und i

C++-Implementierung

int getInversions(int * A, int n) {
   int count = 0;
   for (int i = 0; i < n; ++i) {
      for (int j = i + 1; j < n; ++j) {
         if (A[i] > a[j]) {
            ++count;
         }
      }
   }
  return count;
}

Java-Implementierung

public static int getInversions(int[] A, int n) {
  int count = 0;
 
  for (int i = 0; i < n; i++) {
      for (int j = i + 1; j < n; j++) {
         if (A[i] > A[j]) {
            count += 1;
         }
 
      }
   }
  return count;
}

Python-Implementierung

def getInversions(A, n):
    count = 0
    for i in range(n):
        for j in range(i + 1, n):
            if A[i] > A[j]:
                count += 1
 
   return count;
}

PHP-Implementierung

<?php
$a=array("a "=>"Volvo","b"=>"BMW","c"=>"Toyota");
print_r(array_reverse($a));
?>

Hier haben wir die mögliche Syntax zur Berechnung der Inversion von Größe 3 in einem bestimmten Array erwähnt. Für diese Methode: Zeitkomplexität: O(N^2), wobei N die Gesamtgröße des Arrays ist; Raumkomplexität: O(1), da kein zusätzlicher Platz verwendet wird.

Zu befolgende Methode:-

• Methode 1 – Berechnen Sie die Umkehrung von Größe 3 im angegebenen Array mit einem Programm, um die Umkehrung von Größe 3 zu berechnen

• Methode 2 – Bessere Methode zur Berechnung der Umkehrung von Größe 3

• Methode 3 – Berechnen Sie die Umkehrung der Größe 3 mithilfe des binären Indexbaums

Zählen Sie Umkehrungen der Größe 3 in einem bestimmten Array mit dem Programm, um Umkehrungen der Größe 3 zu berechnen

Um eine Inversion der Größe 3 auf einfache Weise zu berechnen, müssen wir eine Schleife für alle möglichen Werte von i, j und k ausführen. Die Zeitkomplexität beträgt O(n^3), O(1) spiegelt den Hilfsraum wider.

Die Bedingungen sind:

a[i] > a[j] > a[k] und i

Beispiel 1

<?php
function getInvCount($arr, $n){
	$invcount = 0;

	for ($i = 1; $i < $n - 1; $i++){
		$small = 0;
		for($j = $i + 1; $j < $n; $j++)
			if ($arr[$i] > $arr[$j])
				$small++;
		$great = 0;
		for($j = $i - 1; $j >= 0; $j--)
			if ($arr[$i] < $arr[$j])
				$great++;
		$invcount += $great * $small;
	}

	return $invcount;
}
	$arr = array(16, 7, 22, 10);
	$n = sizeof($arr);
	echo "Inversion Count : "
		, getInvCount($arr, $n);
?>

Ausgabe

Inversion Count : 0

Bessere Methode zur Berechnung der Inversion von Größe 3

Bei dieser Methode behandeln wir jedes Element des Arrays als das invertierte mittlere Element. Es hilft, die Komplexität zu reduzieren. Bei diesem Ansatz beträgt die Zeitkomplexität O(n^2) und der Hilfsraum O(1).

Beispiel 2

<?php
function getInvCount($arr, $n){
	$invcount = 0;

	for ($i = 1; $i < $n - 1; $i++){
		$small = 0;
		for ($j = $i + 1; $j < $n; $j++)
			if ($arr[$i] > $arr[$j])
				$small++;
		$great = 0;
		for ($j = $i - 1; $j >= 0; $j--)
			if ($arr[$i] < $arr[$j])
				$great++;
		$invcount += $great * $small;
	}

	return $invcount;
}

$arr = array (81, 14, 22, 7);
$n = sizeof($arr);
echo "Inversion Count For The Input Is : " ,
	getInvCount($arr, $n);

?>

Ausgabe

Inversion Count For The Input Is : 2

Berechnen Sie die Inversion von Größe 3 mithilfe eines binären Indexbaums

Bei dieser Methode berechnen wir auch das größere und das kleinere Element. Führen Sie dann die Multiplikation von größer[] und kleiner[] durch und addieren Sie sie zum Endergebnis. Die Zeitkomplexität beträgt hier O(n*log(n)) und der Hilfsraum wird als O(n) ausgedrückt.

Beispiel 3

<?php
function getInvCount($arr, $n) {
	$invcount = 0;

	for ($i = 1; $i < $n - 1; $i++){
		$small = 0;
		for ($j = $i + 1; $j < $n; $j++)
			if ($arr[$i] > $arr[$j])
				$small++;
		$great = 0;
		for ($j = $i - 1; $j >= 0; $j--)
			if ($arr[$i] < $arr[$j])
				$great++;
		$invcount += $great * $small;
	}

	return $invcount;
}
$arr = array (811, 411, 16, 7);
$n = sizeof($arr);
echo "Inversion Count After The Process : " ,
	getInvCount($arr, $n);
?>

Ausgabe

Inversion Count After The Process : 4

Fazit

In diesem Artikel erfahren Sie, wie Sie die Inversion von Größe 3 in einem bestimmten Array berechnen. Hoffentlich haben Sie durch diesen Artikel und den erwähnten Code unter Verwendung bestimmter Sprachen ein umfassendes Verständnis des Themas gewonnen.

Das obige ist der detaillierte Inhalt vonSchreiben Sie bei einem gegebenen Array ein PHP-Programm, um die Anzahl der umgekehrten Paare der Größe drei zu zählen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!