Un zéro-tableau indexé donné & Un équilibre index de ce tableau

100 Score en Javascript

function solution(V) {

    var sum = 0;
    for (i=0; i < V.length; i++) {
      sum += V[i];   
    }

    var leftSum= 0;
    var rightSum = 0;

    for (j=0; j < V.length; j++) {
      rightSum = sum - (leftSum + V[j]);
      if(leftSum == rightSum) {
          return j;
      }
      leftSum += V[j];
    }
    return -1;
}

OriginalL'auteur Eko Bayu

100% Java

int solution(int A[], int N) {

    long sum = 0;
    for (int i = 0; i < A.length; i++) {
        sum += (long) A[i];
    }
    long leftSum = 0;
    long rightSum = 0;

    for (int i = 0; i < A.length; i++) {
        rightSum = sum - (leftSum + A[i]);
        if (leftSum == rightSum) {
            return i;
        }
        leftSum += A[i];
    }
    return -1;
}

}

OriginalL'auteur Asiri Liyana Arachchi

La réponse est posté dans ce blog: http://blog.codility.com/2011/03/solutions-for-task-equi.html. Afin d'éviter de O(N^2) et de réaliser de O(N) performance:
L'observation essentielle pour le meilleur temps de course est de mettre à jour la gauche/droite des sommes en temps constant au lieu de recalculer eux à partir de l'éraflure.

int equi(int arr[], int n) 
{
    if (n==0) return -1; 
    long long sum = 0;
    int i; 
    for(i=0;i<n;i++) sum+=(long long) arr[i]; 

    long long sum_left = 0;    
    for(i=0;i<n;i++) {
        long long sum_right = sum - sum_left - (long long) arr[i];
        if (sum_left == sum_right) return i;
        sum_left += (long long) arr[i];
    } 
    return -1; 
} 

OriginalL'auteur chris hu

Dynamique de l'approche de la programmation. O(N) fois. O(2N) de l'espace.

1. Garder deux tables (tableaux), tableBefore et tableAfter.
2. tableBefore a la somme de l'indice i pour tout i; i -> 1 à N.
3. tableAfter a la somme de l'indice i pour tout i; i -> N à 1.

4. Par la suite de boucles et de comparer chaque index dans tableBefore et tableAfter. Si c'est égal, c'est votre équilibre index.

   public static int EquilibriumIndex2(int[] a) {
   int len = a.length;
   int[] tableBefore = new int[len];
   int[] tableAfter = new int[len];
   
   tableBefore[0] = 0;
   for (int i = 1; i < len; i++) {
       tableBefore[i] = tableBefore[i - 1] + a[i - 1];
   }
   
   //System.out.println("tableBefore: " + Arrays.toString(tableBefore));
   tableAfter[len - 1] = 0;
   for (int i = len - 2; i >= 0; i--) {
       tableAfter[i] = tableAfter[i + 1] + a[i + 1];
   }
   //System.out.println("tableAfter: " + java.util.Arrays.toString(tableAfter));
   
   for (int j = 0; j < len; j++) {
       if (tableAfter[j] == tableBefore[j]) {
           return j;
       }
   }
   return -1;

   }

OriginalL'auteur Hilary Brobbey

La simple approche semble la manière suivante.

Tout d'abord, vous devez calculer la somme de tous les éléments de la matrice

Par exemple, si vous avez le tableau en C++

int a[] = { -1, 3, -4, 5, 1, -6, 2, 1 };

ensuite, vous pouvez utiliser un simple boucle pour calculer la somme ou de l'algorithme standard std::accumulate déclaré dans l'en-tête <numeric>

Par exemple

long long int right_sum = 
    std::accumulate( std::begin( a ), std::end( a ), 0ll );

La somme des éléments de la gauche de la sous-suite au départ est égal à zéro

long long int left_sum = 0;

Ensuite, vous pouvez appliquer l'algorithme standard std::find_if avec une lambda-expression ou encore écrire un ordinaire boucle comme par exemple

for ( size_t i = 0; i < sizeof( a ) / sizeof( *a ); i++ )
{
    right_sum -= a[i];
    if ( left_sum == right_sum ) std::cout << i << ' ';
    left_sum += a[i];
}

Le résultat sera

1 3 7

OriginalL'auteur Vlad from Moscow

en python 🙂

def solution(A):
    INDEX_NOT_FOUND = -1
    right_sum = 0 
    left_sum = 0

    for item in range(0, len(A)):
        right_sum += A[item]

    for item in range(0, len(A)):
        if item == 0:
            left_sum +=  0 
        else: 
            left_sum += A[item -1]
        right_sum -= A[item]
        if left_sum == right_sum:
            return item
    return INDEX_NOT_FOUND;

OriginalL'auteur David Castro

Solution Simple :

étapes :

1) Chèque (Tableau = null)

Then Print “Pas de point d'Équilibre présent que la matrice est NULLE”

2) Chèque (longueur de la pile = 1)

Then Print "Equilibrium_Index = 0" => un seul élément présent dans la gamme qui est le point d'équilibre

3) Chèque (Longueur de Tableau > 1)

Boucle (Index de Tableau 1 to Length-1)

Considérer chaque index en tant que point d'équilibre

Vérifier (somme des éléments ci-dessous point d'équilibre = somme des éléments ci-dessus équilibre poin)

Oui => equilibrium_index = i (rupture de la boucle)

Pas => continuer à l'étape 3 de la prochaine valeur de compteur de boucle

4) si le contrôle n'est pas retourné à partir de l'étape 3 signifie que le point d'équilibre n'est pas présent dans la boucle

Then Print "Pas de point d'équilibre présent dans le tableau."

Veuillez trouver ci-dessous le code pour la même :

 public int findSum(int equillibrium,int a[],int flag)
 {


      /*Flag - It represents whether sum is required for left side of equilibrium 
       point or right side of equilibrium point
      *Flag = 0 => Sum is required for left side of equilibrium point
      *Flag = 1 => Sum is required for right side of equilibrium point
      */

     int lowlimit = 0, uplimit = a.length-1, i ,sum = 0;

     if(flag==0)
         uplimit = equillibrium - 1;
     else
         lowlimit = equillibrium + 1;

     for(i=lowlimit ; i<=uplimit; i++)
         sum = sum + a[i];

     return sum;
 }

 public int findEquillibriumPoint(int a[])
 {
     int i = 0; //Loop Counter

     //Since only one element is present it is at equilibrium only and index of equillibrium point is index of single element i.e 0
     if(a.length==1)
         return 0;
     else
     {
         for(i=1;i<a.length;i++)
         {
             if(findSum(i,a,0)==findSum(i,a,1)) //checking if some of lower half from equilibrium point is equal to sum of upper half
                 return i; //if equilibrium point is found return the index of equilibrium point
         }
     }

     return -1;//if equilibrium point is not present in array then return -1 
 }

OriginalL'auteur NinjaNick

100 Score en Ruby

def equilibrium(a)
  sum = 0
  n = a.length
  left_sum = 0
  right_sum = 0

  n.times do |i|
    sum += a[i]
  end

  n.times do |i|
    right_sum = sum - left_sum - a[i]
    if right_sum == left_sum
      return i
    end
    left_sum += a[i]
  end
  return -1
end

OriginalL'auteur Pulkit Agarwal