दिलचस्प पोस्ट
कैसे प्रोग्रामिंग आईफोन पर एसएमएस भेजें? एक "अस्पष्ट रीडायरेक्ट" त्रुटि प्राप्त करना सिद्धांत 2: संदर्भ तालिका में अतिरिक्त कॉलम के साथ कई-से-कई संभाल करने का सर्वोत्तम तरीका जावास्क्रिप्ट छिपाना / शो तत्व जावा 1.8 एएसएम क्लास रीडर क्लास फ़ाइल को पार्स करने में असफल रहा – संभवतः एक नए जावा क्लास फ़ाइल संस्करण के कारण जो अभी तक समर्थित नहीं है UINavigationBar शीर्षक के बिना कस्टम वापस बटन देखो और महसूस स्विंग जेटबबेदपैन में अपडेट नहीं कर रहा है एक स्ट्रिंग में बाइट्स कनवर्ट करें? जावा के लिए एक हेप विश्लेषण उपकरण की सिफारिशें? बाइट सरणी के लिए जावा पूर्णांक आसान संभव जावास्क्रिप्ट उलटी गिनती टाइमर? त्रुटि: 10 $ डाइजेस्ट () पुनरावृत्तियों तक पहुंचे। निरस्त किया जा रहा! डायनेमिक सॉर्टबी पॉकेट के साथ क्या मैं रनटाइम पर एक .NET विधानसभा को लोड कर सकता हूँ और केवल एक ही नाम जानकर एक प्रकार का इन्स्टॉलेशन कर सकता हूँ? क्या एंड्रॉइड पर शेयर्डपेरेन्फ़्रेंस के लिए सरणी या ऑब्जेक्ट जोड़ना संभव है? मैं ScrollView में एक ListView कैसे डाल सकता हूं बिना इसे गिरता?

नंबरों की एक सरणी में याद आ रही संख्या ढूंढने का सबसे तेज़ तरीका

मेरे पास संख्या 1 से 100 (दोनों समावेशी) से है। सरणी का आकार 100 है। संख्याएं बेतरतीब ढंग से सरणी में जोड़ दी जाती हैं, लेकिन सरणी में एक यादृच्छिक खाली स्थान है। उस स्लॉट के साथ-साथ नंबर को खोजने का सबसे तेज़ तरीका क्या है जो स्लॉट में रखा जाना चाहिए? एक जावा समाधान बेहतर है।

वेब के समाधान से एकत्रित समाधान "नंबरों की एक सरणी में याद आ रही संख्या ढूंढने का सबसे तेज़ तरीका"

आप हे (एन) में कर सकते हैं सरणी के माध्यम से फिराना और सभी संख्याओं की राशि की गणना करना। अब, 1 से एन तक की प्राकृतिक संख्याओं का योग, Nx(N+1)/2 रूप में व्यक्त किया जा सकता है आपके मामले में एन = 100

Nx(N+1)/2 से सरणी का योग घटाएं, जहां N = 100

यह लापता संख्या है रिक्त स्लॉट का पुनरावृत्ति के दौरान पता लगाया जा सकता है जिसमें योग की गणना की जाती है।

 // 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); 
 long n = 100; int a[] = new int[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 long xor = (n % 4 == 0) ? n : (n % 4 == 1) ? 1 : (n % 4 == 2) ? n + 1 : 0; for (long i = 1; i <= n; i++) { xor = xor ^ a[i]; } //Missing number System.out.println(xor); 

हम XOR ऑपरेशन का उपयोग कर सकते हैं जो समीकरण से अधिक सुरक्षित है क्योंकि प्रोग्रामिंग भाषाओं में यदि दी गई इनपुट बड़ी है तो यह अतिप्रवाह हो सकता है और गलत जवाब दे सकता है।

समाधान पर जाने से पहले, पता है कि A xor A = 0 इसलिए यदि हम दो समान संख्याओं को एक्स 0 कहते हैं तो वैल्यू 0 है

अब, एक्सरिंग [1..एन] सरणी में मौजूद तत्वों के साथ समान संख्या रद्द कर देता है। तो अंत में हम लापता संख्या प्राप्त करेंगे।

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

यह एक अमेज़ॅन साक्षात्कार प्रश्न था और मूल रूप से यहां उत्तर दिया गया था: 1 से 52 की संख्या है जो 51 नंबर सरणी में डाल दी जाती है, यह पता लगाने का सबसे अच्छा तरीका क्या है कि कौन सी संख्या गायब है?

इसे नीचे दिए गए उत्तर दिए गए:

 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. 

यह यहां यहां लिखा गया था: सॉफ्टवेयर जॉब – साक्षात्कार प्रश्न

यहाँ एक पूर्णांक सरणी में गुम संख्याओं को खोजने के लिए एक सरल कार्यक्रम है

 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 – (सरणी में सभी मानों का योग) = अनुपलब्ध संख्या

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

यह सी # है लेकिन यह आपके लिए क्या आवश्यक है:

 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; 

ठीक है, एक खिल फिल्टर का उपयोग करें।

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

ऐसी स्थिति में, जहां पहले से ही सरणी हल हो गई है , इसमें डुप्लिकेट शामिल नहीं है और केवल एक ही नंबर अनुपलब्ध है, द्विआधारी खोज का उपयोग करते हुए, लॉग (एन) के समय में यह अनुपलब्ध संख्या खोजना संभव है

 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 } 

समाधान जिसमें दोहरावदार बदलाव शामिल नहीं हैं या शायद n (n + 1) / 2 सूत्र आपको उदाहरण के लिए एक साक्षात्कार समय पर नहीं मिल रहा है।

आपको 4 ints (32 बिट) या 2 ints (64 बिट) की एक सरणी का उपयोग करना होगा। (-1 और ~ (1 << 31)) के साथ अंतिम पूर्णांक को प्रारंभ करें। 3. (100 से ऊपर वाले बिट्स को 1 पर सेट किया गया है) या आप लूप के लिए 100 का उपयोग करके बिट्स सेट कर सकते हैं।

  1. संख्याओं की सरणी के माध्यम से जाओ और संख्या के अनुरूप बिट स्थिति के लिए 1 सेट करें (जैसे कि 71 बाएं से दाएं 7 वें बिट पर 3 जी पर सेट किया जाएगा)
  2. 4 ints (32 बिट संस्करण) या 2 ints (64 बिट संस्करण) की सरणी के माध्यम से जाओ
 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) }
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) } 

उदाहरण: (32 बिट संस्करण) बताता है कि गुम संख्या 58 है। इसका मतलब है कि दूसरा पूर्णांक का 26 वां बिट (बाएं से दाएं) 0 पर सेट है

पहला इंट -1 है (सभी बिट्स सेट हैं), तो हम दूसरे के लिए आगे बढ़ते हैं और नंबर 32 में "नहीं" जोड़ते हैं। दूसरा इंट -1 से थोड़ा अलग है (एक बिट सेट नहीं है) तो, आवेदन करके नंबर पर नॉट (~) ऑपरेटर जो हमें 64 मिलता है। संभव संख्या 2 एक्स पर पावर है और हम बेस 2 पर लॉग का उपयोग करके एक्स की गणना कर सकते हैं; इस मामले में हम log2 (64) = 6 => 32 + 32 – 6 = 58 प्राप्त करते हैं।

उम्मीद है की यह मदद करेगा।

यह एक खोज समस्या नहीं है नियोक्ता सोच रहा है कि क्या आपके पास चेकसम की समझ है। आपको एक बाइनरी या पाश के लिए या जो भी कई अनूठे पूर्णांक की तलाश होती है, हो सकता है, लेकिन सवाल "एक यादृच्छिक खाली स्लॉट" के लिए आवश्यक हो सकता है। इस मामले में हम स्ट्रीम राशि का उपयोग कर सकते हैं। स्थिति: "संख्याएं बेतरतीब ढंग से सरणी में जोड़ दी जाती हैं" बिना अधिक विस्तार के अर्थहीन हैं। प्रश्न यह नहीं मानता है कि सरणी पूर्णांक 1 के साथ शुरू होनी चाहिए और इसलिए ऑफसेट प्रारंभ पूर्णांक के साथ सहन करना चाहिए

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

सफल समय: 0.18 मेमोरी: 320576 संकेत: 0

मैंने इस सुंदर समाधान को यहां पाया:

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

सॉर्ट किए गए अर्रे ======== सरल उपाय ===========

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

संख्याओं की एक श्रृंखला से लापता संख्या ढूँढना याद करने के लिए आईएमपी अंक

  1. सरणी को हल किया जाना चाहिए ..
  2. फ़ंक्शन कई मिसालों पर काम नहीं करता है
  3. अनुक्रम एक एपी होना चाहिए

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

मुझे लगता है कि सबसे आसान और संभवत: सबसे कुशल समाधान सभी प्रविष्टियों पर लूप के लिए होगा और यह याद रखने के लिए कि बिट्स सेट किए गए हैं, और फिर 0 बिट के लिए परीक्षण करें। 0 बिट के साथ प्रविष्टि लापता संख्या है।

इस कार्यक्रम में लापता संख्या मिलती है

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

एक बात आप कर सकते हैं, उदाहरण के लिए त्वरित प्रकार का उपयोग करके संख्याओं को क्रमबद्ध करना। फिर सॉर्ट करने वाली सरणी के माध्यम से 1 से 100 तक पुनरावृत्त करने के लिए एक का उपयोग करें। प्रत्येक पुनरावृत्ति में, आप अपने लूप वेतन वृद्धि के साथ एरे में संख्या की तुलना करते हैं, यदि आपको लगता है कि इंडेक्स इंडेरमेंट सरणी मान के समान नहीं है, तो आप आपकी अनुपस्थित संख्या और साथ ही गुम इंडेक्स मिल गया है।

नीचे दी गई सरणी से सभी लापता नंबर खोजने के लिए समाधान है:

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

आइए कि आपके पास एन के रूप में 8 है, और हमारी संख्या 0-8 से लेकर इस उदाहरण के लिए हम सभी 9 नंबरों के द्विआधारी प्रतिनिधित्व का प्रतिनिधित्व कर सकते हैं, 0000 0001 0010 0011 0100 0101 0110 0111 1000

उपरोक्त अनुक्रम में कोई लापता संख्या नहीं है और प्रत्येक कॉलम में शून्य और लोगों की संख्या का मिलान होता है, लेकिन जैसे ही आप 1 मूल्य निकाल देते हैं, 3 कहने देता है, 3 में हम 0 और 1 के कॉलम के बराबर राशि प्राप्त करते हैं। यदि किसी कॉलम में 0 की संख्या <= 1 की संख्या की हमारी गुम संख्या में इस बिट की स्थिति में 0 हो, अन्यथा यदि 0 की संख्या> इस बिट स्थिति में 1 की संख्या तो यह बिट स्थिति 1 होगी हम बिट्स को सही से छोड़ते हैं और प्रत्येक चलने पर हम अगले बिट के परीक्षण के लिए सरणी का आधा हिस्सा निकालते हैं, या तो अजीब सरणी मान या यहां तक ​​कि सरणी मूल्यों को प्रत्येक चलना पर दूर फेंक दिया जाता है, इसके आधार पर हम किस चीज की कमी पर।

नीचे समाधान सी ++ में है

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

प्रत्येक चलने पर हम अपने इनपुट स्थान को 2, अर्थात् एन, एन / 2, एन / 4 … = हे (लॉग एन) से कम करते हैं, अंतरिक्ष हे (एन) के साथ

 //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 

PHP $ n = 100 के साथ समाधान;

 $n*($n+1)/2 - array_sum($array) = $missing_number 

और array_search($missing_number) गुम संख्या के सूचक को देगा

 function solution($A) { // code in PHP5.5 $n=count($A); for($i=1;$i<=$n;$i++) { if(!in_array($i,$A)) { return (int)$i; } } } 

यहां कार्यक्रम में समय की जटिलता ओ (लॉगन) है और अंतरिक्ष जटिलता हे (लॉगन) है

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

हाल ही में मेरे पास नौकरी की साक्षात्कार में एक समान (बिल्कुल नहीं) प्रश्न था और मैंने एक मित्र से भी सुना है जिसे साक्षात्कार में एक ही सवाल पूछा गया था। तो यहां ओपी प्रश्न का उत्तर दिया गया है और कुछ और बदलाव हैं जिन्हें संभावित रूप से पूछा जा सकता है। उत्तर उदाहरण जावा में दिए गए हैं, क्योंकि यह कहा गया है कि:

एक जावा समाधान बेहतर है।

समाधान 1:

1 से 100 तक संख्याओं का सरणी (दोनों समावेशी) … संख्याएं बेतरतीब ढंग से सरणी में जोड़ दी जाती हैं, लेकिन सरणी में एक यादृच्छिक खाली स्थान है

 public static int findMissing1(int [] arr){ int sum = 0; for(int n : arr){ sum += n; } return (100*(100+1)/2) - sum; } 

स्पष्टीकरण: यह समाधान (जैसा कि कई अन्य समाधान यहां पोस्ट किए गए हैं) Triangular number के सूत्र पर आधारित है, जो हमें 1 से n तक सभी प्राकृतिक संख्याओं का योग देता है (इस मामले में n 100 है)। अब जब हम उस राशि को जानते हैं जो 1 से 100 तक होनी चाहिए – हमें दिए गए सरणी में मौजूदा संख्याओं का वास्तविक योग घटाना होगा।

समाधान 2:

1 से n से संख्याओं का सरणी (जिसका अर्थ है कि अधिकतम संख्या अज्ञात है)

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

स्पष्टीकरण: इस समाधान में, क्योंकि अधिकतम संख्या नहीं दी गई है – हमें इसे ढूंढना होगा। अधिकतम संख्या प्राप्त करने के बाद – तर्क एक ही है।

समाधान 3:

1 से n तक संख्याओं का सरणी (अधिकतम संख्या अज्ञात है), सरणी में दो यादृच्छिक खाली स्लॉट हैं

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

स्पष्टीकरण: इस समाधान में, अधिकतम संख्या नहीं दी गई है (जैसा कि पिछले में है), लेकिन यह दो संख्याओं में भी गायब हो सकती है और एक भी नहीं। पहले तो हम लापता संख्याओं का योग पाते हैं – पहले के समान तर्क के साथ। लापता राशि और अंतिम (संभावित) अनुपलब्ध संख्या के बीच छोटी संख्या दूसरी खोज – अनावश्यक खोज को कम करने के लिए तीसरा है क्योंकि Java एस अर्रे (संग्रह नहीं) में indexOf या contains , मैंने उस तर्क के लिए एक छोटी पुन: उपयोग करने योग्य विधि जोड़ दी है जब पहली बार लापता संख्या मिलती है तो चौथा, दूसरा राशि बेमिसाल से घटाई जाती है। यदि केवल एक ही नंबर गुम है, तो सरणी में दूसरी संख्या शून्य होगी।

ध्यान दें

यदि आप अन्य भाषाओं में उदाहरण चाहते हैं या इस प्रश्न के किसी अन्य दिलचस्प विविधता चाहते हैं, तो आप इंटरव्यू प्रश्नों और उत्तरों के लिए मेरे Github रिपॉजिटरी की जांच के लिए स्वागत है ।

योग सूत्र का उपयोग करें,

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

संदर्भ http://www.geeksforgeeks.org/find-the-missing-number/

  //Array is shorted and if writing in C/C++ think of XOR implementations in java as follows. int num=-1; for (int i=1; i<=100; i++){ num =2*i; if(arr[num]==0){ System.out.println("index: "+i+" Array position: "+ num); break; } else if(arr[num-1]==0){ System.out.println("index: "+i+ " Array position: "+ (num-1)); break; } }// use Rabbit and tortoise race, move the dangling index faster, //learnt from Alogithimica, Ameerpet, hyderbad** 

यदि सरणी को बेतरतीब ढंग से भरा हुआ है, तो सबसे अच्छा आप ओ (एन) जटिलता में एक रैखिक खोज कर सकते हैं। हालांकि, हम गियर के अनुसार ओ (लॉग एन) की जटिलता में सुधार कर सकते हैं और त्वरित तरीके से समान दृष्टिकोण पर विजय प्राप्त कर सकते हैं जैसे गिरी ने बताया कि संख्या आरोही / अवरोही क्रम में थी।

अब मैं बिग ओ नोटेशन के साथ बहुत तेज हूं, लेकिन आप कुछ भी ऐसा नहीं कर सकते (जावा में)

 for (int i = 0; i < numbers.length; i++) { if(numbers[i] != i+1){ System.out.println(i+1); } } 

जहां नंबर 1-100 से आपकी संख्याओं के साथ सरणी है प्रश्न के अपने पढ़ने से यह नहीं कहा गया था कि लापता संख्या लिखना कब।

वैकल्पिक रूप से यदि आप i + 1 का मान दूसरे सरणी में डाल सकते हैं और पुनरावृत्ति के बाद प्रिंट कर सकते हैं।

बेशक यह समय और स्थान नियमों का पालन नहीं कर सकता है। जैसा मैंने कहा। मुझे बिग ओ पर दृढ़ता से ब्रश करना होगा।

एक अन्य होमवर्क सवाल एक अनुक्रमिक खोज सर्वोत्तम है जो आप कर सकते हैं जावा समाधान के लिए, रीडर के लिए एक व्यायाम का विचार करें। : पी

त्वरित प्रकार अधिकतम दक्षता के साथ सबसे अच्छा विकल्प है ….