JavaScript 在数组中查找缺少的数字
JavaScript find missing number in array
我有这个数组
var a = [5] , count = 5;
我想知道这个数组(a(上缺少的数字，结果必须是
1,2,3,4
我只是尝试这个但失败了
var missing = [];
for ( var j = 0; j < a.length; j++ ) {
for ( var i = 1; i <= count; i++ ) {
if (a[j] != i) {
missing.push( i );
}
}
}
我立刻称它为给予
1,2,3,4
向 (a( 数组添加一些值，例如
a = [2,3,4,5]
它给我这个
[1， 3， 4， 5， 1， 2， 4， 5， 1， 2， 3，5， 1， 2， 3， 4]
我该如何解决它找到计数值的缺失数字
注意*查找计数值的缺失数字
您可以使用
indexOf函数来执行此操作：
var a = [5],
count = 5;
var missing = new Array();
for (var i = 1; i <= count; i++) {
if (a.indexOf(i) == -1) {
missing.push(i);
}
}
console.log(missing); // to check the result.处理动态 MIN 和 MAX 数字以查找数组中缺失数字范围的更好方法
const findMissing = num => {
const max = Math.max(...num); // Will find highest number
const min = Math.min(...num); // Will find lowest number
const missing = []
for(let i=min; i<= max; i++) {
if(!num.includes(i)) { // Checking whether i(current value) present in num(argument)
missing.push(i); // Adding numbers which are not in num(argument) array
}
}
return missing;
}
findMissing([1,15]);
使用 indexOf() 检查数组中的元素
var a = [5],
count = 5,
missing = [];
for (var i = 1; i <= count; i++) {
if (a.indexOf(i) == -1) {
missing.push(i);
}
}
document.write('<pre>' + JSON.stringify(missing) + '</pre>');单行 ES6 即兴演奏：
let missingNumbers = (a, l=true) => Array.from(Array(Math.max(...a)).keys()).map((n, i) => a.indexOf(i) < 0 && (!l || i > Math.min(...a)) ? i : null).filter(f=>f);
默认情况下，返回多个数字序列中缺少的数字：
array = [2, 5, 9]
missingNumbers(array)
// returns [3, 4, 6, 7, 8]
但是您可以将低值标志设置为 false 并获得以 1 开头的结果：
missingNumbers(array, false)
// returns [1, 3, 4, 6, 7, 8]
missingNumbers([5])
// returns [1, 2, 3, 4]
或者只是定义没有标志的函数
let missingNumbers = (a) => Array.from(Array(Math.max(...a)).keys()).map((n, i) => a.indexOf(i) < 0? i : null).filter(f=>f);
尝试运行代码片段
var a = [1,4,7], count = a[a.length - 1];
var missing = [];
for ( var i = 1; i <= count; i++ ) {
if (a.indexOf(i) == -1) {
missing.push(i);
}
}
alert(missing.toString());可以通过查找总(n*(n+1)/2)并从每个值中减去总计来找到缺失的数字，重命名的数字将是所需的数字。
function findNumber(arr) {
var n = arr.length;
var total = ((n + 2) * (n + 1)) / 2;
for (let i = 0; i < n; i++) {
total -= arr[i];
}
return total;
}
var arr = [1, 2, 3, 4, 5, 6, 7, 8];
console.log(findNumber(arr));function missingItems(arr, n) {
let missingItems = [];
for (let i = 1; i <= n; i++) if (!arr.includes(i)) missingItems.push(i);
return missingItems;
}
console.log(missingItems([9, 1, 4, 2, 10, 6], 10));尽管此解决方案需要 0(n( 的时间复杂度，但您可以通过运行从 1 到 n 的循环并在每次迭代时检查数组 arr 中是否存在索引，轻松获取 1 到 n 之间的所有缺失项。
简单
考虑 _ 是 lodash 或下划线
var arr = [2,3,4,5];
var min = _.min(arr);
var result = [];
for (var i = 0; i < min; i++) {
result.push(i);
}
result // [0, 1];您可以切换循环并设置一个标志。这可能不是最快的方法，但值得一看，因为这是您的第一个想法。
修复
示例：jsFiddle
var missing = [];
var a = [5];
var count = 5;
var found = false;
for (var j = 1; j < count; j++) {
found = false;
for (var i = 0; i <= a.length; i++) {
if (a[i] == j) {
found = true;
break;
}
}
if (!found) {
missing.push(j);
}
}
alert(JSON.stringify(missing));
一种方法是使用以下方法查找缺失的数字：
Array.from({length: Math.max(...b)},(_,x) => !b.includes(x+1)?x+1:false).filter(Boolean)
var a = [100,1,4,7];
a.sort(function(a, b) {
return a - b;
});
count = a[a.length - 1];
var missing = [];
for ( var i = 1; i <= count; i++ ) {
if (a.indexOf(i) == -1) {
missing.push(i);
}
}
console.log(missing.toString());var a = [5],
count = 5;
var missing = new Array();
for (var i = 1; i <= count; i++) {
if (a.indexOf(i) == -1) {
missing.push(i);
}
}
console.log(missing); // to check the result.Lodash solution：
它将适用于数组值的最小值和最大值之间缺少的任何数字。
let numbersArray = [0, 1, 3, 6, 7];
let missedNumbersArray = [];
_.forEach(_.range(_.min(numbersArray), _.max(numbersArray)), (number, index) => {
if (_.findIndex(numbersArray, val => val == number) == -1) {
missedNumbersArray.push(index);
}
});
const myFunc = (arr) => {
const sum = ((arr.length + 1) * (arr.length + 2)) / 2;
const arrSum = (arr) => arr.reduce((a, b) => a + b, 0);
return sum - arrSum(arr);
};
const myArray = [1, 2, 10, 5, 6, 4, 7, 9, 3, 11];
console.log(myFunc(myArray));
解释：
- 将自然数的总和存储在"sum"变量中，最多为数组长度的长度之一。我们在数组的长度上再添加一个，因为缺少一个数字。为了计算总和，我们使用 n 个自然数公式的总和，即 n*(n+1(/2。
- 现在使用 reduce(( 计算给定数组的总和。 很明显，我们的数组中
- 缺少一个数字，因此从自然数的总和中减去给定数组的总和将得到缺失的数字。
您可以使用 XOR 运算符来执行此操作：
let arr1 = [1, 2, 3, 4, 5, 6, 7, 8];
let x1 = xorOfArray(arr1, arr1.length); // 8
console.log(x1);
let arr2 = [1, 2, 3, 4, 5, 7, 8]; // 6 is missing
let x2 = xorOfArray(arr2, arr2.length); // 14
console.log(x2);
let arr3 = [x1, x2];
let x3 = xorOfArray(arr3, arr3.length); // 6
console.log(x3);
// x3 is the missing number
function xorOfArray(arr, n)
{
// Resultant variable
let xor_arr = 0;
// Iterating through every element in
// the array
for (let i = 0; i < n; i++) {
// Find XOR with the result
xor_arr = xor_arr ^ arr[i];
}
// Return the XOR
return xor_arr;
} // you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(A) {
// write your code in JavaScript (Node.js 8.9.4)
const filterArr= [...new Set(A.filter(x=> x>0).sort())];
let k=1;
function newArr(){
for(let i=0;i<filterArr.length;i++){
if(filterArr[i]=== k){
k++;
}
else{
return k;
}
}
return k;
}
return filterArr.length? newArr():1;
}
console.log(solution([3,2,1,5])); output:4
console.log(solution([-1,-2.-5])); output: 1
console.log(solution([1,2.3,4])); output: 5
这仅适用于排序数组：
const findMissingNumber = (arr) => {
for (let i = 1; i <= arr.length; i++) {
if (arr[i - 1] !== i) {
return i;
}
}
}
const arr = [1, 2, 3, 4, 5, 6, 8, 10];
console.log(findMissingNumber(arr));使用 javascript 查找给定数组的缺失数字;
添加排序功能以获得精确输出
let len = parseInt(prompt("Enter the range : "));
let arr = [];let i = 0;
for (i = 0; i < len;i++){
let num = parseInt(prompt("Enter the numbers : "));
arr.push(num);
/*arr.sort(function(a,b){
return a - b;
});*/
}
missingNum = (arr) => {
let i = 0,j = 0;
let start = arr[0];
let end = arr[arr.length - 1];
let miss = [];
let found = false;
let result = "";
for (i = start; i<=end; i++){
found = false;
for(j = 0;j<arr.length;j++){
if(arr[j] == i){
found = true ;
break;
}
}
if(!found){
miss.push(i)
}
}
return miss;
}
console.log(missingNum(arr))
function missingArray(params) {
var arr =[1,3,5,8,9];
var missing = [];
for (let i = 0; i < arr[arr.length-1]; i++) {
if(!(arr.includes(i))){
missing.push(i);
}
}
return missing;
}
console.log(missingArray());
arr=[1,2,3,9]
newArr=[]
for(let i=1;i<Math.max(...arr);i++){
if(arr.indexOf(i)===-1){
newArr.push(i)
}
}
console.log(newArr)function findMissingNumbers(arr) {
// sort the array in ascending order
arr.sort(function(a, b) {
return a - b;
});
// initialize the missing numbers array
const missing = [];
// iterate through the array
for (let i = 0; i < arr.length - 1; i++) {
// calculate the difference between the current and next number
const diff = arr[i + 1] - arr[i];
// if the difference is greater than 1, there is a missing number(s)
if (diff > 1) {
// push the missing number(s) into the array
for (let j = 1; j < diff; j++) {
missing.push(arr[i] + j);
}
}
}
// return the missing numbers array
return missing;
}
蛮力、缓冲和最佳解决方案，仅使用纯 JS：
const nums = [1,2,3,4,6];
// Brute sol
// Time complexity = O(n2)
// Space complexity = O(n)
const findMissingNumberBrute = (nums, n) => {
for(let i = 1; i <= n - 1; i++) {
let flag = 0;
for(let j = 0; j <= n; j++) {
if(nums[j] == i) {
flag = 1;
}
}
if(flag === 0) {
return i;
}
}
}
// 5
console.log(findMissingNumberBrute(nums, 6))
// Buffer sol
// Time complexity = O(n) + O(n)
// Space complexity = O(n)
const findMissingNumberBuffer = (nums, n) => {
const obj = {};
for(let i = 0; i < n-1; i++) {
obj[nums[i]] = 1
}
for(let j = 1; j <= n; j++) {
if(obj[j] === undefined) {
return j
}
}
}
// 5
console.log(findMissingNumberBuffer(nums, 6))
// Best sol
// Time complexity = O(n)
// Space complexity = O(1)
const findMissingNumberBest = (nums, n) => {
// get the sum of first n natural numbers
const totalSumOfFirstNNumners = (n*(n+1)/2);
let sum = 0;
for(let i = 0; i <= nums.length -1; i++) {
sum = sum + nums[i]
}
return totalSumOfFirstNNumners - sum;
}
// 5
console.log(findMissingNumberBest(nums, 6))
// Best1 with xor sol
// Time complexity = O(1)
// Space complexity = O(1)
const findMissingNumberBest1 = (nums, n) => {
// get the sum of first n natural numbers
let xor1 = 0;
for(let i = 0; i <= n; i++) {
xor1 = xor1 ^ i;
}
let xor2 = 0;
for(let j = 0; j <= n - 1; j++) {
xor2 = xor2 ^ nums[j];
}
return xor1 ^ xor2;
}
// 5
console.log(findMissingNumberBest1(nums, 6))class Solution{
missingNumber(array,n){
let res = 0;
for (let i = 0; i <= n; i++) res ^= i;
for (let i = 0; i < n-1; i++) res ^= array[i]
return res
}
}
N = 10
A = [6,1,2,8,3,4,7,10,5]
const find = new Solution()
console.log(find.missingNumber(A, N))
这是如何在数组(排序数组(中查找缺失的数字，
它只检查一个缺失的号码。
function miss(arr) {
for (let i = 0; i < arr.length; i++) {
if (arr[i] !== i + 1) {
return i + 1;
}
}
}
let a = miss([1, 2, 3, 4, 5, 7, 8, 9, 10])
console.log(a)
function missing(arr) {
let n = arr.length;
let sum = (n + 1) * (n + 2) / 2
let total = arr.reduce((acc, item) => acc + item);
let missin = sum - total
return missin
}
let b = missing([1, 2, 3, 4, 6, 7, 8, 9]);
console.log(b)相关文章：
- 如何使用JavaScript查找1和N之间的所有数字的总和
- JavaScript 在数组中查找缺少的数字
- RegEx查找4位数字前后的逗号
- 如何使用 num.toString 和 str.split 查找整数的最后一位数字
- Javascript Regex，在字符串中查找数字
- 查找总和最大的数字(Javascript）
- JS:从数组中查找特定范围内的最低/最高数字
- 查找字符串及其索引中的最大数字
- 给定一个带有数字的数组，我如何编写一个递归函数，当 2 个元素加起来为一个目标时，它会在数组中查找索引
- Javascript从关联数组中查找最低数字(气泡排序方法）
- 如何在HTML5 / javascript中查找十六进制值的特定位或数字
- 在一串数字中查找特定值
- 搜索并查找以特定数字开头的数字
- reg ex表达式，以查找并替换[]中的数字
- Javascript循环数组以查找可被3整除的数字
- 如何使用javascript查找可被多个数字整除的数字
- 查找数组中的下一个最高数字 - jquery
- 如何查找和替换包含数字的名称并将该数字存储在变量中
- 自动查找数字总和，因为用户输入值是动态的，而不管输入的数量如何.如果用户输入的数字不是，则提醒用户
- 数字查找器regex问题
