Le moyen le plus rapide de trouver le nombre manquant dans un tableau de nombres
J'ai un tableau de nombres de 1 à 100 (les deux inclus). La taille du tableau est 100. Les nombres sont ajoutés aléatoirement au tableau, mais il y a un emplacement vide aléatoire dans le tableau. Quel est le moyen le plus rapide de trouver cet emplacement ainsi que le nombre à insérer dans cet emplacement? Une solution Java est préférable.
Vous pouvez le faire dans O (n). Parcourez le tableau et calculez la somme de tous les nombres. Maintenant, la somme des nombres naturels de 1 à N peut être exprimée par Nx(N+1)/2. Dans votre cas, N = 100.
Soustrayez la somme du tableau de Nx(N+1)/2, où N = 100.
C'est le numéro manquant. L'emplacement vide peut être détecté lors de l'itération au cours de laquelle la somme est calculée.
// will be the sum of the numbers in the array.
int sum = 0;
int idx = -1;
for (int i = 0; i < arr.length; i++)
{
if (arr[i] == 0)
{
idx = i;
}
else
{
sum += arr[i];
}
}
// the total sum of numbers between 1 and arr.length.
int total = (arr.length + 1) * arr.length / 2;
System.out.println("missing number is: " + (total - sum) + " at index " + idx);
Nous pouvons utiliser l'opération XOR qui est plus sûre que la somme car, dans les langages de programmation, si l'entrée fournie est grande, elle peut déborder et donner une mauvaise réponse.
Avant de passer à la solution, sachez que A xor A = 0. Donc, si nous XOR deux nombres identiques, la valeur est 0.
Maintenant, XORing [1..n] avec les éléments présents dans le tableau annule les nombres identiques. Donc, à la fin, nous aurons le numéro manquant.
// Assuming that the array contains 99 distinct integers between 1..99
// and empty slot value is zero
int XOR = 0;
for(int i=0; i<100; i++) {
if (ARRAY[i] != 0)
XOR ^= ARRAY[i];
XOR ^= (i + 1);
}
return XOR;
Laisser le tableau donné être A de longueur N. Supposons que, dans le tableau donné, le seul emplacement vide est rempli de 0.
Nous pouvons trouver la solution à ce problème en utilisant de nombreuses méthodes, y compris l'algorithme utilisé dans Counting sort. Mais, en termes d'utilisation efficace du temps et de l'espace, nous avons deux algorithmes. On utilise principalement la somme, la soustraction et la multiplication. Un autre utilise XOR. Mathématiquement, les deux méthodes fonctionnent bien. Mais par programme, nous devons évaluer tous les algorithmes avec des mesures principales telles que
- Limitations (comme les valeurs d'entrée sont grandes (
A[1...N]) et/ou le nombre de valeurs d'entrée est important (N)) - Nombre de contrôles de condition impliqués
- Nombre et type d'opérations mathématiques impliquées
etc. Ceci est dû aux limitations de temps et/ou de matériel (limitation des ressources matérielles) et/ou de logiciel (limitation du système d'exploitation, limitation du langage de programmation, etc.), etc. Permet de répertorier et d'évaluer les avantages et les inconvénients de chacun d'entre eux. .
Algorithme 1:
Dans l'algorithme 1, nous avons 3 implémentations.
Calculez la somme totale de tous les nombres (y compris le nombre inconnu inconnu) en utilisant la formule mathématique (
1+2+3+...+N=(N(N+1))/2). Ici,N=100. Calculez la somme totale de tous les nombres donnés. Soustrayez le deuxième résultat du premier résultat pour obtenir le nombre manquant.Missing Number = (N(N+1))/2) - (A[1]+A[2]+...+A[100])Calculez la somme totale de tous les nombres (y compris le nombre inconnu inconnu) en utilisant la formule mathématique (
1+2+3+...+N=(N(N+1))/2). Ici,N=100. À partir de ce résultat, soustraire chaque nombre donné donne le nombre manquant.Missing Number = (N(N+1))/2)-A[1]-A[2]-...-A[100](
Note:Bien que la formule de la deuxième implémentation soit dérivée de la première, les deux points de vue sont identiques, mais, du point de vue de la programmation, ils sont différents car la première formule est plus sujette au débordement de bits que la seconde ( même si l’addition est plus rapide que la soustraction, la seconde implémentation réduit le risque de débordement de bits dû à l’addition de valeurs élevées (elle n’est pas complètement éliminée car il n’ya encore que très peu de chance depuis (N+1) existe dans la formule). Les deux implémentations ne donnent le résultat correct que siN(N+1)<=MAXIMUM_NUMBER_VALUE. Pour la première implémentation, la limitation supplémentaire est qu'elle ne donne le résultat correct que siSum of all given numbers<=MAXIMUM_NUMBER_VALUE.)Calculez la somme totale de tous les nombres (y compris le nombre inconnu inconnu) et soustrayez chaque nombre donné dans la même boucle en parallèle. Ceci élimine le risque de débordement de bits par multiplication mais risque de déborder de bits par addition et soustraction.
//ALGORITHM missingNumber = 0; foreach(index from 1 to N) { missingNumber = missingNumber + index; //Since, the empty slot is filled with 0, //this extra condition which is executed for N times is not required. //But for the sake of understanding of algorithm purpose lets put it. if (inputArray[index] != 0) missingNumber = missingNumber - inputArray[index]; }
Dans un langage de programmation (comme C, C++, Java, etc.), si le nombre de bits représentant un type de données entier est limité, toutes les implémentations ci-dessus sont sujettes au débordement de bits en raison de la somme, de la soustraction et de la multiplication, ce qui donne un résultat erroné. en cas de valeurs d'entrée importantes (A[1...N]) et/ou d'un grand nombre de valeurs d'entrée (N).
Algorithme 2:
Nous pouvons utiliser la propriété de XOR pour trouver une solution à ce problème sans vous soucier du problème de débordement de bits. Et aussi XOR est à la fois plus sûr et plus rapide que la sommation. Nous connaissons la propriété de XOR que XOR de deux mêmes nombres est égal à 0 (A XOR A = 0). Si nous calculons le XOR de tous les nombres de 1 à N (ceci inclut le nombre manquant inconnu), puis avec ce résultat, XOR tous les nombres donnés, les nombres communs sont annulés out (depuis A XOR A=0) et nous obtenons le numéro manquant. Si nous n'avons pas de problème de débordement de bits, nous pouvons utiliser à la fois les algorithmes de somme et ceux basés sur XOR pour obtenir la solution. Mais, l'algorithme qui utilise XOR est à la fois plus sûr et plus rapide que l'algorithme qui utilise la somme, la soustraction et la multiplication. Et nous pouvons éviter les soucis supplémentaires causés par la sommation, la soustraction et la multiplication.
Dans toutes les implémentations de l'algorithme 1, nous pouvons utiliser XOR à la place de l'addition et de la soustraction.
Supposons, XOR(1...N) = XOR of all numbers from 1 to N
Mise en oeuvre 1 => Missing Number = XOR(1...N) XOR (A[1] XOR A[2] XOR...XOR A[100])
Mise en oeuvre 2 => Missing Number = XOR(1...N) XOR A[1] XOR A[2] XOR...XOR A[100]
Mise en œuvre 3 =>
//ALGORITHM
missingNumber = 0;
foreach(index from 1 to N)
{
missingNumber = missingNumber XOR index;
//Since, the empty slot is filled with 0,
//this extra condition which is executed for N times is not required.
//But for the sake of understanding of algorithm purpose lets put it.
if (inputArray[index] != 0)
missingNumber = missingNumber XOR inputArray[index];
}
Les trois implémentations de l'algorithme 2 fonctionneront bien (du point de vue de la programmation également). Une optimisation est, semblable à
1+2+....+N = (N(N+1))/2
On a,
1 XOR 2 XOR .... XOR N = {N if REMAINDER(N/4)=0, 1 if REMAINDER(N/4)=1, N+1 if REMAINDER(N/4)=2, 0 if REMAINDER(N/4)=3}
Nous pouvons le prouver par une induction mathématique. Ainsi, au lieu de calculer la valeur de XOR (1 ... N) par XOR tous les nombres de 1 à N, nous pouvons utiliser cette formule pour réduire le nombre d'opérations XOR .
De plus, calculer XOR (1 ... N) en utilisant la formule ci-dessus a deux implémentations. Mise en œuvre, calcul
// Thanks to https://a3nm.net/blog/xor.html for this implementation
xor = (n>>1)&1 ^ (((n&1)>0)?1:n)
est plus rapide que le calcul
xor = (n % 4 == 0) ? n : (n % 4 == 1) ? 1 : (n % 4 == 2) ? n + 1 : 0;
Ainsi, le code Java optimisé est,
long n = 100;
long a[] = new long[n];
//XOR of all numbers from 1 to n
// n%4 == 0 ---> n
// n%4 == 1 ---> 1
// n%4 == 2 ---> n + 1
// n%4 == 3 ---> 0
//Slower way of implementing the formula
// long xor = (n % 4 == 0) ? n : (n % 4 == 1) ? 1 : (n % 4 == 2) ? n + 1 : 0;
//Faster way of implementing the formula
// long xor = (n>>1)&1 ^ (((n&1)>0)?1:n);
long xor = (n>>1)&1 ^ (((n&1)>0)?1:n);
for (long i = 0; i < n; i++)
{
xor = xor ^ a[i];
}
//Missing number
System.out.println(xor);
Cette question a été interviewée par Amazon et a été initialement répondue ici: Nous avons des nombres de 1 à 52 qui sont placés dans un tableau de 51 nombres, quel est le meilleur moyen de déterminer le nombre qui manque?
Il a été répondu, comme ci-dessous:
1) Calculate the sum of all numbers stored in the array of size 51.
2) Subtract the sum from (52 * 53)/2 ---- Formula : n * (n + 1) / 2.
Il a également été blogué ici: Software Job - Question d'entretien d'embauche
Voici un programme simple pour trouver les nombres manquants dans un tableau entier
ArrayList<Integer> arr = new ArrayList<Integer>();
int a[] = { 1,3,4,5,6,7,10 };
int j = a[0];
for (int i=0;i<a.length;i++)
{
if (j==a[i])
{
j++;
continue;
}
else
{
arr.add(j);
i--;
j++;
}
}
System.out.println("missing numbers are ");
for(int r : arr)
{
System.out.println(" " + r);
}
5050 - (somme de toutes les valeurs du tableau) = nombre manquant
int sum = 0;
int idx = -1;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == 0) idx = i; else sum += arr[i];
}
System.out.println("missing number is: " + (5050 - sum) + " at index " + idx);
Sur un scénario similaire, où le tableau est déjà trié , il n'inclut pas les doublons et un seul nombre est manquant, il est possible de trouver ce nombre manquant dans log (n) time , à l'aide de la recherche binaire .
public static int getMissingInt(int[] intArray, int left, int right) {
if (right == left + 1) return intArray[right] - 1;
int pivot = left + (right - left) / 2;
if (intArray[pivot] == intArray[left] + (intArray[right] - intArray[left]) / 2 - (right - left) % 2)
return getMissingInt(intArray, pivot, right);
else
return getMissingInt(intArray, left, pivot);
}
public static void main(String args[]) {
int[] array = new int[]{3, 4, 5, 6, 7, 8, 10};
int missingInt = getMissingInt(array, 0, array.length-1);
System.out.println(missingInt); //it prints 9
}
Eh bien, utilisez un filtre de bloom.
int findmissing(int arr[], int n)
{
long bloom=0;
int i;
for(i=0; i<;n; i++)bloom+=1>>arr[i];
for(i=1; i<=n, (bloom<<i & 1); i++);
return i;
}
La solution qui n’implique pas d’additions répétitives ou peut-être que la formule n (n + 1)/2 ne vous parvient pas lors d’une interview, par exemple.
Vous devez utiliser un tableau de 4 ints (32 bits) ou 2 ints (64 bits). Initialisez le dernier int avec (-1 & ~ (1 << 31)) >> 3. (les bits supérieurs à 100 sont définis sur 1). Vous pouvez également définir les bits supérieurs à 100 à l'aide d'une boucle for.
- Parcourez le tableau de nombres et définissez 1 pour la position du bit correspondant au nombre (par exemple 71 serait défini sur le 3ème int sur le 7ème bit de gauche à droite)
- Parcourez le tableau de 4 ints (version 32 bits) ou 2 ints (version 64 bits)
public int MissingNumber(int a[])
{
int bits = sizeof(int) * 8;
int i = 0;
int no = 0;
while(a[i] == -1)//this means a[i]'s bits are all set to 1, the numbers is not inside this 32 numbers section
{
no += bits;
i++;
}
return no + bits - Math.Log(~a[i], 2);//apply NOT (~) operator to a[i] to invert all bits, and get a number with only one bit set (2 at the power of something)
}
Exemple: (version 32 bits), disons que le nombre manquant est 58. Cela signifie que le 26ème bit (de gauche à droite) du second entier est défini sur 0.
Le premier int est égal à -1 (tous les bits sont définis), nous passons au deuxième et ajoutons à "non" le nombre 32. Le deuxième int est différent de -1 (un bit n'est pas défini). l'opérateur NOT (~) au nombre que nous obtenons 64. Les nombres possibles sont 2 à la puissance x et nous pouvons calculer x en utilisant log sur la base 2; dans ce cas, nous obtenons log2 (64) = 6 => 32 + 32 - 6 = 58.
J'espère que cela t'aides.
C'est c # mais cela devrait être assez proche de ce dont vous avez besoin:
int sumNumbers = 0;
int emptySlotIndex = -1;
for (int i = 0; i < arr.length; i++)
{
if (arr[i] == 0)
emptySlotIndex = i;
sumNumbers += arr[i];
}
int missingNumber = 5050 - sumNumbers;
J'ai trouvé cette belle solution ici:
http://javaconceptoftheday.com/Java-puzzle-interview-program-find-missing-number-in-an-array/
public class MissingNumberInArray
{
//Method to calculate sum of 'n' numbers
static int sumOfNnumbers(int n)
{
int sum = (n * (n+1))/ 2;
return sum;
}
//Method to calculate sum of all elements of array
static int sumOfElements(int[] array)
{
int sum = 0;
for (int i = 0; i < array.length; i++)
{
sum = sum + array[i];
}
return sum;
}
public static void main(String[] args)
{
int n = 8;
int[] a = {1, 4, 5, 3, 7, 8, 6};
//Step 1
int sumOfNnumbers = sumOfNnumbers(n);
//Step 2
int sumOfElements = sumOfElements(a);
//Step 3
int missingNumber = sumOfNnumbers - sumOfElements;
System.out.println("Missing Number is = "+missingNumber);
}
}
Je pense que la solution la plus simple et peut-être la plus efficace consisterait à parcourir toutes les entrées et à utiliser un bitet pour se souvenir des nombres définis, puis de tester le bit 0. L'entrée avec le bit 0 est le nombre manquant.
Ce n'est pas un problème de recherche. L'employeur se demande si vous maîtrisez une somme de contrôle. Vous pourriez avoir besoin d'une boucle binaire ou for ou autre, si vous recherchiez plusieurs entiers uniques, mais la question précise "un emplacement vide aléatoire". Dans ce cas, nous pouvons utiliser la somme de flux. La condition: "Les nombres sont ajoutés aléatoirement au tableau" n'a pas de sens sans plus de détails. La question ne suppose pas que le tableau doit commencer par le nombre entier 1 et tolère donc le nombre entier de début du décalage.
int[] test = {2,3,4,5,6,7,8,9,10, 12,13,14 };
/*get the missing integer*/
int max = test[test.length - 1];
int min = test[0];
int sum = Arrays.stream(test).sum();
int actual = (((max*(max+1))/2)-min+1);
//Find:
//the missing value
System.out.println(actual - sum);
//the slot
System.out.println(actual - sum - min);
Temps de réussite: 0,18 mémoire: 320576 signal: 0
Récemment, j'avais une question similaire (pas exactement la même) lors d'un entretien d'embauche et un ami m'a également posé la même question exactement lors d'un entretien. Voici donc une réponse à la question du PO et quelques autres variantes pouvant être potentiellement posées. L’exemple de réponses est donné dans Java car il est écrit que:
Une solution Java est préférable.
Solution 1:
Tableau de nombres compris entre 1 et 100 (les deux inclus) ... Les nombres sont ajoutés au tableau de façon aléatoire, mais il y a un emplacement vide aléatoire dans le tableau
public static int findMissing1(int [] arr){
int sum = 0;
for(int n : arr){
sum += n;
}
return (100*(100+1)/2) - sum;
}
Explication: Cette solution (comme beaucoup d'autres solutions publiées ici) est basée sur la formule de Triangular number , qui nous donne la somme de tous les nombres naturels allant de 1 à n (dans ce cas, n est 100). Maintenant que nous connaissons la somme qui devrait être comprise entre 1 et 100, il suffit de soustraire la somme réelle des nombres existants dans un tableau donné.
Solution 2:
Tableau de nombres de 1 à n (ce qui signifie que le nombre maximal est inconnu)
public static int findMissing2(int [] arr){
int sum = 0, max = 0;
for(int n : arr){
sum += n;
if(n > max) max = n;
}
return (max*(max+1)/2) - sum;
}
Explication: Dans cette solution, puisque le nombre maximal n'est pas indiqué, nous devons le trouver. Après avoir trouvé le nombre maximum - la logique est la même.
Solution 3:
Tableau de nombres de 1 à n (le nombre maximum est inconnu), il y a deux emplacements vides aléatoires dans le tableau
public static int [] findMissing3(int [] arr){
int sum = 0, max = 0, misSum;
int [] misNums = {};//empty by default
for(int n : arr){
sum += n;
if(n > max) max = n;
}
misSum = (max*(max+1)/2) - sum;//Sum of two missing numbers
for(int n = Math.min(misSum, max-1); n > 1; n--){
if(!contains(n, arr))misNums = new int[]{n, misSum-n};
}
return misNums;
}
private static boolean contains(int num, int [] arr){
for(int n : arr){
if(n == num)return true;
}
return false;
}
Explication: Dans cette solution, le nombre maximal n'est pas indiqué (comme dans le précédent), mais il peut également manquer deux nombres et non un. Donc, au début, nous trouvons la somme des nombres manquants - avec la même logique que précédemment. Deuxième recherche du nombre le plus petit entre la somme manquante et le dernier (éventuellement) numéro manquant - pour réduire les recherches inutiles. Troisième étant donné que Javas Array (pas une collection) n'a pas de méthodes comme indexOf ou contains, j'ai ajouté une petite méthode réutilisable pour cette logique. Quatrième lorsque le premier nombre manquant est trouvé, le second correspond à la soustraction de la somme manquante. Si un seul nombre est manquant, le second nombre dans le tableau sera zéro.
Remarque
Si vous voulez des exemples dans autres langues ou une autre variations intéressantes de cette question, vous pouvez consulter mon référentiel Github pour Questions et réponses d’entrevue .
Trouver le numéro manquant d'une série de chiffres. Points IMP à retenir.
- le tableau doit être trié ..
- la fonction ne fonctionne pas sur plusieurs absences.
la séquence doit être un AP.
public int execute2(int[] array) { int diff = Math.min(array[1]-array[0], array[2]-array[1]); int min = 0, max = arr.length-1; boolean missingNum = true; while(min<max) { int mid = (min + max) >>> 1; int leftDiff = array[mid] - array[min]; if(leftDiff > diff * (mid - min)) { if(mid-min == 1) return (array[mid] + array[min])/2; max = mid; missingNum = false; continue; } int rightDiff = array[max] - array[mid]; if(rightDiff > diff * (max - mid)) { if(max-mid == 1) return (array[max] + array[mid])/2; min = mid; missingNum = false; continue; } if(missingNum) break; } return -1; }
public class MissingNumber {
public static void main(String[] args) {
int array[] = {1,2,3,4,6};
int x1 = getMissingNumber(array,6);
System.out.println("The Missing number is: "+x1);
}
private static int getMissingNumber(int[] array, int i) {
int acctualnumber =0;
int expectednumber = (i*(i+1)/2);
for (int j : array) {
acctualnumber = acctualnumber+j;
}
System.out.println(acctualnumber);
System.out.println(expectednumber);
return expectednumber-acctualnumber;
}
}
Une chose à faire est de trier les nombres en utilisant un tri rapide, par exemple. Utilisez ensuite une boucle for pour parcourir le tableau trié de 1 à 100. À chaque itération, comparez le nombre figurant dans le tableau avec votre incrément de boucle for. Si vous constatez que l'incrément d'index n'est pas identique à la valeur du tableau, ont trouvé votre numéro manquant ainsi que l'index manquant.
Utilisez la formule somme,
class Main {
// Function to ind missing number
static int getMissingNo (int a[], int n) {
int i, total;
total = (n+1)*(n+2)/2;
for ( i = 0; i< n; i++)
total -= a[i];
return total;
}
/* program to test above function */
public static void main(String args[]) {
int a[] = {1,2,4,5,6};
int miss = getMissingNo(a,5);
System.out.println(miss);
}
}
Référence http://www.geeksforgeeks.org/find-the-missing-number/
Disons que vous avez n comme 8, et nos nombres vont de 0 à 8 pour cet exemple Nous pouvons représenter la représentation binaire de tous les 9 nombres comme suit: __. 0000 0001 0010 0011 0100 0101 0110 0111 1000.
dans la séquence ci-dessus, il n'y a pas de nombre manquant et dans chaque colonne, le nombre de zéros et ceux qui correspondent, mais dès que vous supprimez une valeur, disons que 3 nous obtenons un équilibre dans le nombre de 0 et de 1 dans les colonnes. Si le nombre de 0 dans une colonne est <= le nombre de 1, notre nombre manquant aura un 0 à cette position de bit, sinon si le nombre de 0> le nombre de 1 à cette position de bit, cette position de bit sera à 1 Nous testons les bits de gauche à droite et, à chaque itération, nous jetons la moitié du tableau pour tester le bit suivant, soit les valeurs de tableau impaires, soit les valeurs de tableau pair sont rejetées à chaque itération, en fonction du bit pour lequel nous sommes déficients. sur.
La solution ci-dessous est en C++
int getMissingNumber(vector<int>* input, int bitPos, const int startRange)
{
vector<int> zeros;
vector<int> ones;
int missingNumber=0;
//base case, assume empty array indicating start value of range is missing
if(input->size() == 0)
return startRange;
//if the bit position being tested is 0 add to the zero's vector
//otherwise to the ones vector
for(unsigned int i = 0; i<input->size(); i++)
{
int value = input->at(i);
if(getBit(value, bitPos) == 0)
zeros.Push_back(value);
else
ones.Push_back(value);
}
//throw away either the odd or even numbers and test
//the next bit position, build the missing number
//from right to left
if(zeros.size() <= ones.size())
{
//missing number is even
missingNumber = getMissingNumber(&zeros, bitPos+1, startRange);
missingNumber = (missingNumber << 1) | 0;
}
else
{
//missing number is odd
missingNumber = getMissingNumber(&ones, bitPos+1, startRange);
missingNumber = (missingNumber << 1) | 1;
}
return missingNumber;
}
À chaque itération, nous réduisons notre espace d’entrée de 2, c.-à-d. N, N/2, N/4 ... = O (log N), avec un espace O (N).
//Test cases
[1] when missing number is range start
[2] when missing number is range end
[3] when missing number is odd
[4] when missing number is even
======== Solution la plus simple pour un tableau trié ===========
public int getMissingNumber(int[] sortedArray)
{
int missingNumber = 0;
int missingNumberIndex=0;
for (int i = 0; i < sortedArray.length; i++)
{
if (sortedArray[i] == 0)
{
missingNumber = (sortedArray[i + 1]) - 1;
missingNumberIndex=i;
System.out.println("missingNumberIndex: "+missingNumberIndex);
break;
}
}
return missingNumber;
}
Voici la solution pour trouver tous les nombres manquants dans un tableau donné:
public class FindMissingNumbers {
/**
* The function prints all the missing numbers from "n" consecutive numbers.
* The number of missing numbers is not given and all the numbers in the
* given array are assumed to be unique.
*
* A similar approach can be used to find all no-unique/ unique numbers from
* the given array
*
* @param n
* total count of numbers in the sequence
* @param numbers
* is an unsorted array of all the numbers from 1 - n with some
* numbers missing.
*
*/
public static void findMissingNumbers(int n, int[] numbers) {
if (n < 1) {
return;
}
byte[] bytes = new byte[n / 8];
int countOfMissingNumbers = n - numbers.length;
if (countOfMissingNumbers == 0) {
return;
}
for (int currentNumber : numbers) {
int byteIndex = (currentNumber - 1) / 8;
int bit = (currentNumber - byteIndex * 8) - 1;
// Update the "bit" in bytes[byteIndex]
int mask = 1 << bit;
bytes[byteIndex] |= mask;
}
for (int index = 0; index < bytes.length - 2; index++) {
if (bytes[index] != -128) {
for (int i = 0; i < 8; i++) {
if ((bytes[index] >> i & 1) == 0) {
System.out.println("Missing number: " + ((index * 8) + i + 1));
}
}
}
}
// Last byte
int loopTill = n % 8 == 0 ? 8 : n % 8;
for (int index = 0; index < loopTill; index++) {
if ((bytes[bytes.length - 1] >> index & 1) == 0) {
System.out.println("Missing number: " + (((bytes.length - 1) * 8) + index + 1));
}
}
}
public static void main(String[] args) {
List<Integer> arrayList = new ArrayList<Integer>();
int n = 128;
int m = 5;
for (int i = 1; i <= n; i++) {
arrayList.add(i);
}
Collections.shuffle(arrayList);
for (int i = 1; i <= 5; i++) {
System.out.println("Removing:" + arrayList.remove(i));
}
int[] array = new int[n - m];
for (int i = 0; i < (n - m); i++) {
array[i] = arrayList.get(i);
}
System.out.println("Array is: " + Arrays.toString(array));
findMissingNumbers(n, array);
}
}
Ce programme trouve les numéros manquants
<?php
$arr_num=array("1","2","3","5","6");
$n=count($arr_num);
for($i=1;$i<=$n;$i++)
{
if(!in_array($i,$arr_num))
{
array_Push($arr_num,$i);print_r($arr_num);exit;
}
}
?>
Solution avec PHP $ n = 100 ;
$n*($n+1)/2 - array_sum($array) = $missing_number
et array_search($missing_number) donnera l'index du nombre manquant
Ici, la complexité du programme prend O(logn) et la complexité de l’espace O (logn)
public class helper1 {
public static void main(String[] args) {
int a[] = {1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12};
int k = missing(a, 0, a.length);
System.out.println(k);
}
public static int missing(int[] a, int f, int l) {
int mid = (l + f) / 2;
//if first index reached last then no element found
if (a.length - 1 == f) {
System.out.println("missing not find ");
return 0;
}
//if mid with first found
if (mid == f) {
System.out.println(a[mid] + 1);
return a[mid] + 1;
}
if ((mid + 1) == a[mid])
return missing(a, mid, l);
else
return missing(a, f, mid);
}
}
simple solution with test data :
class A{
public static void main(String[] args){
int[] array = new int[200];
for(int i=0;i<100;i++){
if(i != 51){
array[i] = i;
}
}
for(int i=100;i<200;i++){
array[i] = i;
}
int temp = 0;
for(int i=0;i<200;i++){
temp ^= array[i];
}
System.out.println(temp);
}
}
function solution($A) {
// code in PHP5.5
$n=count($A);
for($i=1;$i<=$n;$i++) {
if(!in_array($i,$A)) {
return (int)$i;
}
}
}