Question

我需要找到前两个数字并显示索引，如：

var arrWithNumbers = [2,5,5,2,3,5,1,2,4];

所以首先重复号是2所以变量firstIndex的值应为0.我必须使用for循环。

＆＃13;

var numbers = [7, 5, 7, 6, 6, 4, 9, 10, 2, 11];
var firstIndex

for (i = numbers[0]; i <= numbers.length; i++) {
  firstIndex = numbers[0]
  if (numbers[i] == firstIndex) {
    console.log(firstIndex);
    break;
  }
}

＆＃13;

Answer 1

您可以将方法与Array#indexOf参数一起使用。

＆＃13;

var numbers = [7, 5, 7, 6, 6, 4, 9, 10, 2, 11],
  ref = {};

// iterate over the array
for (var i = 0; i < numbers.length; i++) {
  // check value already defined or not
  if (numbers[i] in ref) {
    // if defined then log data and brek loop
    console.log("index:", ref[numbers[i]], "value: ", numbers[i]);
    break;
  }
  // define the reference of the index
  ref[numbers[i]] = i;
}

＆＃13;

<小时/> 更新：使用对象引用元素的索引可以使它更好。

＆＃13;


    Renderer.context.disable(Renderer.context.DEPTH_TEST);
    Renderer.autoClearDepth = true;
    Renderer.autoClearStencil = true;
    Renderer.sortObjects = true;
    Renderer.shadowMapCullFace = THREE.CullFaceBack;
    Renderer.shadowMap.enabled = true;
    Renderer.shadowMap.type = THREE.PCFSoftShadowMap;
    Renderer.gammaInput = true;
    Renderer.gammaOutput = true;

＆＃13;

Answer 2

您可以使用两个for循环检查每个值对每个值。如果找到重复值，则迭代停止。

此提案使用labeled statement来打破外部循环。

var numbers = [1, 3, 6, 7, 5, 7, 6, 6, 4, 9, 10, 2, 11],
    i, j;

outer: for (i = 0; i < numbers.length - 1; i++) {
    for (j = i + 1; j < numbers.length; j++) {
        if (numbers[i] === numbers[j]) {
            console.log('found', numbers[i], 'at index', i, 'and', j);
            break outer;
        }
    }
}

Answer 3

浏览每个项目并查找是否在不同的索引上找到相同的项目，如果是，则重复并将其保存到重复变量和中断循环

＆＃13;

var numbers = [7, 5, 7, 6, 6, 4, 9, 10, 2, 11];
var duplicate = null;
for (var i = 0; i < numbers.length; i++) {
  if (numbers.indexOf(numbers[i]) !== i) {
    duplicate = numbers[i];
    break; // stop cycle 
  }
}
console.log(duplicate);

＆＃13;

Answer 4

var numbers = [7, 5, 7, 6, 6, 4, 9, 10, 2, 11];
var map = {};
    
for (var i = 0; i < numbers.length; i++) {
   if (map[numbers[i]] !== undefined) {
       console.log(map[numbers[i]]);
       break;
   } else {
       map[numbers[i]] = i;
   }
}

好的，让我们打破这个。我们在这里做的是为它们首次出现的索引创建一个数字映射。因此，当我们遍历数字数组时，我们检查它是否在我们的数字地图中。如果它是我们找到它并在我们的地图中返回该键的值。否则，我们将数字添加为地图中的一个键，该键指向它首次出现的索引。我们使用map的原因是它非常快O（1）所以我们的整体运行时间是O（n），这是你在未排序数组上执行此操作的最快速度。

Answer 5

作为替代方案，您可以使用indexOf和lastIndexOf，如果值不同，则会有多次重复，您可以打破循环;

＆＃13;

function getFirstDuplicate(arr) {
  for (var i = 0; i < arr.length; i++) {
    if (arr.indexOf(arr[i]) !== arr.lastIndexOf(arr[i])) 
      return arr[i];
  }
}

var arrWithNumbers = [2, 5, 5, 2, 3, 5, 1, 2, 4];
console.log(getFirstDuplicate(arrWithNumbers))

var numbers = [1, 3, 6, 7, 5, 7, 6, 6, 4, 9, 10, 2, 11]
console.log(getFirstDuplicate(numbers))

＆＃13;

Answer 6

许多好的答案......人们也可以在功能和效率方面做到这一点，如下所示;

Update.update(ColumnName cn, String value)

如果条件得到满足，var arr = [2,5,5,2,3,5,1,2,4], frei = arr.findIndex((e,i,a) => a.slice(i+1).some(n => e === n)); // first repeating element index console.log(frei)和.findIndex()函数都会终止，那么效果可能会有效。

Answer 7

我有相同的任务，并提出了这个非常基本的解决方案：

var arr = [7,4,2,4,5,1,6,8,9,4];
var firstIndex = 0;

for(var i = 0; i < arr.length; i++){
  for( var j = i+1; j < arr.length; j++){
    if(arr[i] == arr[j]){
      firstIndex = arr[i];
      break;      
    }

  }
}
console.log(firstIndex);

第一个 for 循环从数组中获取第一个元素（编号 7 ），然后另一个 for 循环将其与所有其他元素进行比较，等等。

重要的是在第二个循环中将 j 定义为 i + 1 ，如果没有，则任何元素都将在相同的索引处找到与 firstIndex相等的数字将在所有循环完成后获得最后一个的值。

Answer 8

要减少上述答案中的时间复杂度，可以使用以下解决方案：

function getFirstRecurringNumber(arrayOfNumbers) {
  const hashMap = new Map();

  for (let number of arrayOfNumbers) { // Time complexity: O(n)
    const numberDuplicatesCount = hashMap.get(number);

    if (numberDuplicatesCount) {
      hashMap.set(number, numberDuplicatesCount + 1);

      continue;
    }

    hashMap.set(number, 1); // Space complexity: O(n)
  }

  for (let entry of hashMap.entries()) { // Time complexity: O(i)
    if (entry[1] > 1) {
      return entry[0];
    }
  }
}

// Time complexity: O(n + i) instead of O(n^2)
// Space complexity: O(n)

Answer 9

使用下面的代码，我只能得到数组中出现的第一个“ 5”。 .some（）方法一旦找到匹配项，便停止循环遍历。

let james = [5, 1, 5, 8, 2, 7, 5, 8, 3, 5];
let onlyOneFives = [];
james.some(item =>  {
    //checking for a condition. 
    if(james.indexOf(item) === 0) {
        //if the condition is met, then it pushes the item to a new array and then   
        //returns true which stop the loop

        onlyOneFives.push(item);
         return james.indexOf(item) === 0;
   }
})

console.log(onlyOneFives)

Answer 10

创建一个接受数字数组的函数，在其中执行以下操作：首先，实例化一个空对象。其次，创建一个循环遍历数组的每个元素，并为每个元素将它们添加到空对象并检查对象的长度是否发生了变化，如果没有，那么这意味着您添加了一个已经存在的元素所以你可以退货：

//Return first recurring number of given array, if there isn't return undefined.

const firstRecurringNumberOf = array =>{
    objectOfArray = {};

    for (let dynamicIndex = 0; dynamicIndex  < array.length; dynamicIndex ++) {
        const elementsBeforeAdding = (Object.keys(objectOfArray)).length;0
        objectOfArray[array[dynamicIndex]] = array[dynamicIndex]
        const elementsAfterAdding = (Object.keys(objectOfArray)).length;

        if(elementsBeforeAdding == elementsAfterAdding){ //it means that the element already existed in the object, so it didnt was added & length doesnt change.
             return array[dynamicIndex];
        }
    }

    return undefined;
}

console.log(firstRecurringNumberOf([1,2,3,4])); //returns undefined
console.log(firstRecurringNumberOf([1,4,3,4,2,3])); //returns 4

Answer 11

var addIndex = [7, 5, 2, 3, 4, 5, 7,6, 2];
var firstmatch = [];
for (var i = 0; i < addIndex.length; i++) {

    if ($.inArray(addIndex[i], firstmatch) > -1) {
        return false;
    }
    firstmatch.push(addIndex[i]);
}

在Javascript数组中查找第一个重复的数字

11 个答案: