Étant donné un tableau, écrivez un programme PHP pour compter le nombre de paires inverses de taille trois

Le décomptage est une méthode de comptage par étapes par laquelle nous pouvons compter le nombre d'étapes de tri effectuées pour un tableau particulier. Il est également capable de calculer la durée de fonctionnement d’un réseau. Mais si nous voulons trier le tableau de la manière inverse, le nombre sera le nombre maximum présent dans le tableau.

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  

Le nombre d'inversions représente la distance qui sépare ce tableau particulier du tri par ordre croissant. Voici deux procédures spécifiques décrivant cette situation avec des solutions -

• Pour trouver le plus petit élément - Pour trouver le plus petit élément du tableau, nous devons parcourir l'index de n-1 à 0. En appliquant (a[i]-1), nous pouvons calculer getSum() ici. Le processus s'exécutera jusqu'à ce qu'il atteigne a[i]-1.

• Pour trouver le plus grand nombre - Pour trouver le plus grand nombre à partir de l'index, nous devons effectuer les itérations 0 à n-1. Pour chaque élément, nous devons calculer chaque nombre jusqu'à a[i]. Soustrayez-le de i. Nous obtiendrons alors un nombre supérieur à a[i].

Algorithme de calcul de l'inversion de taille 3 dans un tableau :-

Dans cet algorithme ; nous apprenons à calculer l'inversion de taille 3 dans un tableau donné dans un environnement de programmation spécifique.

• Étape 1 - Commencer

• Étape 2 - Déclarez le tableau et inversez le nombre (comme arr[] --> array et invCount --> inversez le nombre)

• Étape 3 - Boucle intérieure y=x+1 à N

• Étape 4 - Si l'élément en x est supérieur à l'élément en y index

• Étape 5 - Puis augmentez invCount++

• Étape 6 - Imprimez la paire

• Étape 7 - Résiliation

Syntaxe de calcul de l'inversion de taille 3 dans un tableau : -

Une paire (A[i], A[j]) est dite dans un état inversé si les conditions suivantes sont remplies : A[i] > A[j] et i < j< j

Implémentation C++

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

Implémentation Java

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

Implémentation Python

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

Implémentation PHP

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

Nous avons mentionné ici la syntaxe possible pour calculer l'inversion de taille 3 dans un tableau donné. Pour cette méthode : complexité temporelle : O(N^2), où N est la taille totale du tableau ; complexité spatiale : O(1), puisqu’aucun espace supplémentaire n’est utilisé.

Méthode à suivre :-

• Méthode 1 - Calculez l'inversion de la taille 3 dans le tableau donné par programme pour calculer l'inversion de la taille 3

• Méthode 2 - Meilleure façon de calculer l'inversion de la taille 3

• Méthode 3 - Calculer l'inversion de la taille 3 à l'aide d'un arbre d'index binaire

Comptez les inversions de taille 3 dans un tableau donné par programme pour calculer les inversions de taille 3

Pour un moyen simple de calculer une inversion de taille 3, nous devons exécuter une boucle pour toutes les valeurs possibles de i, j et k. La complexité temporelle est O(n^3), O(1) reflétant l'espace auxiliaire.

Les conditions sont :

a[i] > a[j] > a[k] et i < j < k. < j < k。

Exemple 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);
?>

Sortie

Inversion Count : 0

Meilleure façon de calculer l'inversion de taille 3

Dans cette méthode, nous traitons chaque élément du tableau comme l'élément central inversé. Cela aide à réduire la complexité. Pour cette approche, la complexité temporelle est O(n^2) et l'espace auxiliaire est O(1).

Exemple 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);

?>

Sortie

Inversion Count For The Input Is : 2

Calculez l'inversion de taille 3 à l'aide d'un arbre d'index binaire

Dans cette méthode, nous calculons également le plus grand élément et le plus petit élément. Effectuez ensuite la multiplication de plus grand[] et plus petit[] et ajoutez-le au résultat final. La complexité temporelle ici est O(n*log(n)) et l'espace auxiliaire est exprimé par O(n).

Exemple 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);
?>

Sortie

Inversion Count After The Process : 4

Conclusion

Dans cet article, nous verrons comment calculer l'inversion de taille 3 dans un tableau donné. Espérons que grâce à cet article et au code mentionné utilisant des langages spécifiques, vous avez acquis une large compréhension du sujet.

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!