第 161 题：用最精炼的代码实现数组非零非负最小值 index

Question

例如：[10,21,0,-7,35,7,9,23,18] 输出 5, 7 最小

function getIndex(arr){
      let index=null;
      ...
      return index;
}

Answer 1

常规写法

function rankVoteMaxIndex(arr) {
            let itemIndex = 0;   // 非0最小index
            let itemRank=0;      // 非0最小值
            let length=arr.length;
            if(!length){
                 return -1;
            }
            for(let i=0;i<length;i++){
                let item=arr[i];
                if(item<0) continue;
                if(!itemRank) {
                    itemIndex = i;
                    itemRank = item;
                }
                if(item < itemRank ){
                    itemIndex = i;
                    itemRank = item;
                }
               
            }
            return itemIndex;
        }

这个答案面试官给了65分（满分100）

rankVoteMaxIndex([-1] // 0
rankVoteMaxIndex([-1, 0, 1] // 0

Answer 2

<script>

    function rankVoteMaxIndex(arr) {
        let itemIndex = -1;   // 非0最小index
        let itemRank = -1;      // 非0最小值
        let length = arr.length;
        if (!length) {
            return itemIndex;
        }
        for (let i = 0; i < length; i++) {
            let item = arr[i];
            if (item > 0) {
                if (itemRank < 0) {
                    itemIndex = i;
                    itemRank = item;
                }
                if (item < itemRank) {
                    itemIndex = i;
                    itemRank = item;
                }
            }

        }
        return itemIndex < 0 ? -1 : itemIndex;
    }

    // rankVoteMaxIndex([-1] // 0
    // rankVoteMaxIndex([-1, 0, 1] // 0

    console.log(rankVoteMaxIndex([-1]));
    console.log(rankVoteMaxIndex([-1, 0, 1]));
    console.log(rankVoteMaxIndex([10, 21, 0, -7, 35, 7, 9, 23, 18]))
    console.log(rankVoteMaxIndex([0, 10, 21, 0, -7, 35, 7, 9, 23, 18]))
</script>

Answer 3

会不会B格不够高

const arr = [-10, 0, 10, 21, 0, -7, 35, 7, 9, 23, 18]
let minNum
let minIndex = -1
for (let i = 0, len = arr.length; i < len; i++) {
	if (minNum) {
		if (arr[i] < minNum && arr[i] > 0) {
			minNum = arr[i]
			minIndex = i
		}
	} else {
		if (arr[i] > 0) {
			minNum = arr[i]
			minIndex = i
		}
	}
}

console.log(minIndex, minNum)

Answer 4

const minIndex = (arr) => arr.reduce((num, v, i) => v > 0 && v < arr[num] ? i : num, 0)

Answer 5

先找出大于0的数，然后排序，最小值就是非负非零的最小值，楼上的这个也算一个方法

Answer 6

const minIndex = (arr) => arr.reduce((num, v, i) => v > 0 && v < arr[num] ? i : num, -1)

初始值为-1的话是没法找到最小值的，经测试这条式子有点问题，做了一点调整，代码如下

// 先找到第一个非负非零的值的下标
function findInitialValue(arr) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] > 0) return i;
  }
  return -1;
}
const arr = [10, 21, 0, -7, 35, 7, 9, 23, 18];
function minIndex(arr) {
  let first = findInitialValue(arr);
  // 无非负非零的数，直接返回-1
  if (first === -1) return -1;
  return arr.reduce(
    (num, cur, curIndex) => (cur > 0 && cur < arr[num] ? curIndex : num),
    // 关键是reduce的初始值
    first
  );
}
console.log(minIndex(arr)); // 5

reduce用法相关参考链接：
https://aotu.io/notes/2016/04/14/js-reduce/index.html

Answer 7

function getIndex(arr) {
	return arr.reduce((idx, cur, k) => idx = cur <= idx[1] && cur > 0 ? [k, cur] : idx, [-1, Number.MAX_SAFE_INTEGER])[0]
}

Answer 8

const minIndex = (arr) => arr.reduce((num, v, i) => v > 0 && v < arr[num] ? i : num, -1)

初始值为-1的话是没法找到最小值的，经测试这条式子有点问题，做了一点调整，代码如下

// 先找到第一个非负非零的值的下标
function findInitialValue(arr) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] > 0) return i;
  }
  return -1;
}
const arr = [10, 21, 0, -7, 35, 7, 9, 23, 18];
function minIndex(arr) {
  let first = findInitialValue(arr);
  // 无非负非零的数，直接返回-1
  if (first === -1) return -1;
  return arr.reduce(
    (num, cur, curIndex) => (cur > 0 && cur < arr[num] ? curIndex : num),
    // 关键是reduce的初始值
    first
  );
}
console.log(minIndex(arr)); // 5

reduce用法相关参考链接：
https://aotu.io/notes/2016/04/14/js-reduce/index.html

code:

arr.reduce((res, value, index) => value > 0 && (res === -1 || arr[index] < arr[res]) ? index : res, -1)

Answer 9

实现的比较low，用for对比实现的：

(() => {
    function getIndex(arr) {
        let index;
        let n = Infinity;
        for (let i = 0; i < arr.length; i++) {
            const item = arr[i];
            if (item > 0 && item<n) {
                n = item;
                index = i;
            }
        }

        return index;
    }

    let arr = [10, 21, 0, -7, 35, 7, 9, 23, 18]

    console.log(getIndex(arr));
})();

Answer 10

function getIndex(arr){
  let index = null
  index = arr.reduce((temp, v, i, arr)=>{
    if(v > 0 && v < arr[temp]){
      return i
    }else{
      return temp
    }
  }, 0)
  return index
}

Answer 11

// 不知道有没有重复的元素, 那就直接取了最前出现的, 时间复杂度O(n), 空间复杂度O(1)
function getIndex(arr){
  let index = -1;
  let min = Infinity
  for(let i = 0; i < arr.length; i++){
    if(arr[i] > 0 && arr[i] < min) {
      min = arr[i]
      index = i
    }
  }
  return index;
}

let test = [
  [[10,21,0,-7,35,7,9,23,18], 5],
  [[10,21,0,-7,35,7,9,23,1], 8],
  [[1,21,0,-7,35,7,9,23,1], 0],
  [[], -1]
]
for(let i = 0; i < test.length; i++){
  let [arr, n] = test[i]
  console.log(getIndex(arr) === n)
}

其实就看怎么理解最精简, 我认为是时间空间复杂度小的,
如果说从代码行数来讲, 并没有什么意义, 都可以压缩成一行代码,
还有就是有可读性

Answer 12

function getIndex(arr){
  const indexMap = arr.reduce((map,item,index) => { map[item] = index ; return map;}, {});
  return indexMap[arr.filter(i => i>0).sort(a, b => a - b)[0]] || -1;
}

Answer 13

function getIndex(arr) {
  const min = Math.min(...(arr.filter(i => i > 0)));
  const index = arr.indexOf(min);
  return index + ',' + min;
}

const arr = [10,21,0,-7,35,7,9,23,18];
console.log(getIndex(arr));

Answer 14

最精炼的代码，没说是最小的复杂度啊

function getIndex(arr) {
        let min=Math.min(...arr.filter(i=>i>0))；
        let index=arr.indexOf(min)；
        return [index, min].join(', ');
}

Answer 15

最精炼的代码，没说是最小的复杂度啊

function getIndex(arr) {
        let min=Math.min(...arr.filter(i=>i>0))；
        let index=arr.indexOf(min)；
        return [index, min].join(', ');
}

赞同

Answer 16

@libin1991 上面的时间复杂度是 O(N^2),

function getIndex(arr) {
      let index = -1;
      arr.reduce((pre, cur, k) => {
            if (cur <= 0 || pre <= 0) {
                  index = cur <= 0 && pre <= 0 ? -1 : cur > pre ? k : index;
            } else {
                  index = cur > pre ? index : k;
            }
            return cur > pre ? pre : cur;
      }, -1);
      return index;
}

时间复杂度是 O(N)

function getIndex(arr) {
      let index = -1;
      arr.reduce((pre, cur, k) => {
            if (cur <= 0 || pre <= 0) {
                  index = cur <= 0 && pre <= 0 ? -1 : cur > pre ? k : index;
            } else {
                  index = cur > pre ? index : k;
            }
            return cur > pre ? pre : cur;
      }, -1);
      return index;
}

输出答案都是错的！

getIndex([10,21,0,-7,35,7,9,23,18])
// 8

调整了一下

function getIndex(arr) {
    if (!arr.length) return -1;
    let index = -1;
    arr.reduce((pre, next, k) => {
        const min = Math.min(pre, next);
        const max = Math.max(pre, next, 0);
        // 都是正数
        if (pre > 0 && next > 0) {
            index = min === pre ? index : k
            return min;
        }

        index = (max === 0 ||  max === pre) ? index : k;
        return max;
    }, 0)
    return index;
}

Answer 17

@libin1991 上面的时间复杂度是 O(N^2),

function getIndex(arr) {
      let index = -1;
      arr.reduce((pre, cur, k) => {
            if (cur <= 0 || pre <= 0) {
                  index = cur <= 0 && pre <= 0 ? -1 : cur > pre ? k : index;
            } else {
                  index = cur > pre ? index : k;
            }
            return cur > pre ? pre : cur;
      }, -1);
      return index;
}

时间复杂度是 O(N)

function getIndex(arr) {
      let index = -1;
      arr.reduce((pre, cur, k) => {
            if (cur <= 0 || pre <= 0) {
                  index = cur <= 0 && pre <= 0 ? -1 : cur > pre ? k : index;
            } else {
                  index = cur > pre ? index : k;
            }
            return cur > pre ? pre : cur;
      }, -1);
      return index;
}

输出答案都是错的！

getIndex([10,21,0,-7,35,7,9,23,18])
// 8

Answer 18

const arr = [10, 21, 0, -7, 35, 7, 9, 23, 18];

function findMinimumIndex(arr) {
  return arr.findIndex(item => item === arr.filter(item => item > 0).sort((a, b) => a - b)[0])
}
console.log(findMinimumIndex(arr))

这个时间复杂度也不低

Answer 19

@libin1991 楼主，我是否可以贡献一题，实现 JSON.stringify 方法

Answer 20

https://www.webpackjs.com/loaders/worker-loader/
您访问下这个地址，这上面有这个demo，但是没讲这个！的意思，我想了解一下，麻烦了 @slogeor

Answer 21

@tanxin520 上下文方便说一下嘛

Answer 22

import postwroker from 'worker-loader!./postworker'
有人知道加!这种引入方法是什么意思吗

Answer 23

@libin1991 上面的时间复杂度是 O(N^2),

function getIndex(arr) {
      let index = -1;
      arr.reduce((pre, cur, k) => {
            if (cur <= 0 || pre <= 0) {
                  index = cur <= 0 && pre <= 0 ? -1 : cur > pre ? k : index;
            } else {
                  index = cur > pre ? index : k;
            }
            return cur > pre ? pre : cur;
      }, -1);
      return index;
}

时间复杂度是 O(N)

Answer 24

@slogeor reduce和reduce一起复杂度是多少？ 没有体现最精炼

Answer 25

/**
 * @description 用最精炼的代码实现数组非零最小值 index
 * @param {array} arr 数组
 * @returns {number} index 索引
 */
function getIndex(arr) {
      let index = -1;
      const minVal = arr.reduce((cur, pre) => {
            return (cur <= 0 || pre <= 0) ? Math.max(cur, pre) : cur > pre ? pre : cur;
      }, -1);
      index = arr.findIndex(item => item == minVal && minVal > 0)
      return index;
}