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

Question

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

libin1991 opened this issue 4 years ago · 185 comments

libin1991 commented 4 years ago

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

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

Answer 1 · 2020-09-16T02:10:01.000Z

/**
 * @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;
}

Answer 2 · 2020-09-16T02:12:37.000Z

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

Answer 3 · 2020-09-16T02:33:39.000Z

@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 4 · 2020-09-16T06:48:52.000Z

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

Answer 5 · 2020-09-16T09:59:39.000Z

@tanxin520 上下文方便说一下嘛

Answer 6 · 2020-09-16T10:04:56.000Z

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

Answer 7 · 2020-09-21T13:57:52.000Z

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 8 · 2020-09-22T01:22:26.000Z

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

Answer 9 · 2020-09-22T02:23:19.000Z

@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 10 · 2020-09-22T02:54:46.000Z

@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 11 · 2020-09-22T02:56:22.000Z

常规写法

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 12 · 2020-09-22T03:21:53.000Z

<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 13 · 2020-09-24T10:09:14.000Z

会不会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 14 · 2020-09-25T03:14:16.000Z

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

Answer 15 · 2020-10-12T14:55:39.000Z

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

Answer 16 · 2020-10-16T03:10:44.000Z

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 17 · 2020-10-16T03:32:38.000Z

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 18 · 2020-10-18T01:29:40.000Z

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 19 · 2020-10-27T12:45:01.000Z

实现的比较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 20 · 2020-11-09T06:17:26.000Z

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 21 · 2020-11-09T09:19:27.000Z

// 不知道有没有重复的元素, 那就直接取了最前出现的, 时间复杂度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 22 · 2020-11-12T02:08:35.000Z

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 23 · 2020-11-12T15:29:23.000Z

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 24 · 2020-11-13T15:21:23.000Z

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

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

Answer 25 · 2020-11-15T10:03:18.000Z

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

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

赞同👍

Answer 26 · 2020-11-16T10:26:11.000Z

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

Answer 27 · 2020-11-18T02:13:06.000Z

// 方法一
function getIndex(arr){
    let index = null;
    let min;
    for(let i = 0, l = arr.length; i < l; i++) {
        if(arr[i] < min && arr[i] > 0 || !min && arr[i] > 0) {
            min = arr[i];
            index = i;
        }
    }
    return index;
}

//方法二
function getIndex(arr){
    return arr.indexOf(Math.min(...arr.filter(v => v > 0)));
}

Answer 28 · 2020-11-18T06:53:31.000Z

function getIndex(arr) {
    return arr.reduce((v, x, i, ori) => x > 0 ? (x < ori[(v === -1 ? 0 : v)] ? i : v) : v, -1);
}

Answer 29 · 2020-11-18T07:12:31.000Z

function getIndex(arr){
  let index=null;
  let min = arr[0];
  let len = arr.length;

  for(let i = 0; i < len;i++){
    if(arr[i] > 0){
      if(min > arr[i]){
        index = i;
        min = arr[i];
      }
    }
  }
  return index;
}

逐个对比每次记录最小值以及下标

Answer 30 · 2020-11-19T05:32:31.000Z

const minIndex = arr => 
  arr.indexOf(Math.min(...arr.filter(val => val > 0)));

Answer 31 · 2020-11-19T07:01:35.000Z

function getIndex(arr) {
    return arr.reduce((pre, next, k) => {
        if (next <=0) return -1
        if (pre === -1) return k
        return Math.min(arr[pre], next) === next ? k : pre
    }, -1)
}
getIndex([10,21,0,-7,35,7,9,23,18])  // 5

Answer 32 · 2020-11-23T07:33:16.000Z

const minIndex = (arr)=>{
let arr1= arr.filter(item=>item>0)
retutn arr1.length > 0 ? arr.findIndex(Math.min(...arr1)) : -1
}
minIndex([-1,0,0,0])

Answer 33 · 2020-11-24T02:07:55.000Z

function getMin(arr) {
  let min = 0;
  let result = 0;
  arr.forEach((item, index) => {
    if (item > 0 && (!min || item < min)) {
      min = item;
      result = index;
    }
  });
  return result;
}

Answer 34 · 2020-11-24T02:41:41.000Z

一个for循环解决
// 方法一
this.minVal = this.arr[0];
this.result = 0;
for (let i = 0; i < this.arr.length; i++) {
let curVal = this.arr[i];
if (curVal > 0 && curVal < this.minVal) {
this.minVal = curVal;
this.result = i;
}
}
console.log(this.minVal,this.result, "val")
}`

Answer 35 · 2020-11-27T08:05:41.000Z

function getIndex(arr) {
  let index = null
  index = arr.reduce(function (minI, item, i) {
    return item > 0 && (item < arr[minI] || minI === null) ? i : minI
  }, null)
  return index
}

Answer 36 · 2020-12-01T02:39:14.000Z

function getIndex(arr){
  let i = 0;
  let index;
  let min;
  while (i < arr.length) {
    if (!min && arr[i] > 0) {
      index = i;
    }
    if (min && arr[i] > 0 &&  arr[i] < min) {
      index = i;
    }
    i++;
  }
  return index;
}

Answer 37 · 2020-12-04T08:12:48.000Z

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

使用reduce可选参数要从0开始，-1的话会输出-1

Answer 38 · 2020-12-06T07:17:03.000Z

    const array = [0,-10,-5,1,9,5,1,4,7,10];
    function getIndex(arr){
        let minValue = arr.filter(item => item > 0).sort((a,b) => a -b)[0]
        return arr.indexOf(minValue)
    }
    console.log(getIndex(array));
    function getIndex1(arr){
        return arr.findIndex(item => item === arr.filter(item => item > 0).sort((a,b) => a -b)[0]);
    }
    console.log(getIndex1(array));

Answer 39 · 2020-12-07T06:21:26.000Z

function getIndex(arr){
    let index=null;
    let minNum = Math.min(...arr.filter(item => item > 0));
    index = arr.findIndex(item => item === minNum);
    return index;
}

Answer 40 · 2020-12-18T02:48:45.000Z

function getIndex(arr) {
  let min = undefined;
  let index = -1;
  arr.forEach((item, i) => {
    if (item > 0 && ((min && item < min) || !min)) {
      min = item;
      index = i;
    } 
  })
  return index;
}

Answer 41 · 2020-12-21T12:40:20.000Z

function getIndex(arr) {
  let index = -1;
  let min = Number.MAX_SAFE_INTEGER;
  for (const i in arr) {
    if (arr[i] < min && arr[i] > 0) {
      min = arr[i];
      index = i;
    }
  }
  return index;
}

Answer 42 · 2020-12-27T07:26:03.000Z

function getIndex(arr){
            let minIndex = -1;
            let min = Number.MAX_SAFE_INTEGER;
            arr.forEach( (item, index) => {
                if( item > 0 &&  item < min){
                    min = item;
                    minIndex = index;
                }
            })
            return minIndex;
        }

Answer 43 · 2020-12-30T16:22:09.000Z

function getIndex(arr) {
let min = Math.min(...arr.filter(item => item > 0))
let index = arr.indexOf(min)
return ${index} ${min}
}

Answer 44 · 2021-01-02T16:37:54.000Z

function getIndex(arr){
let res = Array.from(arr)
return res.indexOf(arr.filter((v, i) => v > 0).sort((a,b) => Number(a) - Number(b))[0]);
}

Answer 45 · 2021-01-06T02:04:02.000Z

function getIndex(arr) {
    let index = 0, mixEle = arr[0]
    arr.forEach((ele, i) => {
        if (ele > 0 && mixEle > ele) {
            index = i
            mixEle = ele
        }
    });
    return index
}

这个只要遍历一遍就好了吧？

Answer 46 · 2021-01-07T10:37:11.000Z

// 时间复杂度O(N)
function getIndex(arr) {
let index = -1;
arr.reduce((prev, cur, i) => {
if (cur > 0) {
const min = Math.min(prev, cur);
if (cur === min) {
index = i;
prev = cur;
}
}
return prev;
}, Infinity);
return index;
}
const res = getIndex([10, 21, 0, -7, 35, 7, 9, 23, 18]);
console.log(res); //5

Answer 47 · 2021-01-12T07:05:49.000Z

题目有点不清楚，我理解的是，如果一个数组中全部都是<= 0的数，那返回-1，而且用reduce看起来很酷，但性能真的没有for循环好呀，是我对这个题目没有理解清楚吗？大家都用reduce做

function getIndex(arr){
    if(arr.length <= 0) return -1
    let index = -1;
    for(let i = 0; i < arr.length; i++) {
        if(index < 0) {
            index = arr[i] > 0 ? i : index
            continue;
        }
        if(arr[i] < arr[index] && arr[i] > 0) {
            index = i
        }
    }
    return index;
}

Answer 48 · 2021-01-21T09:13:15.000Z

function getIndex(arr) { return arr.indexOf(Math.min.apply(null, arr.filter(item => item > 0))) }

Answer 49 · 2021-01-24T04:09:30.000Z

let arr = [10, 21, 0, -7, 35, 7, 9, 23, 18]
let min = -1
let minItem = arr[0]
let len = arr.length
for (let i = 0; i < len; i++) {
    if (arr[i] > 0 && arr[i] < minItem) {
        min = i
        minItem = arr[i]
    }
}
console.log(min, minItem)

Answer 50 · 2021-01-25T07:25:42.000Z

for循环的

function getIndex (arr) {
  let index = -1
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] > 0 && (index < 0 || arr[i] < arr[index])) {
      index = i
    }
  }
  return index
}

优雅的

function getIndex (arr) {
  const _arr = arr.filter(val => val > 0)
  const min = Math.min(..._arr)
  const index = arr.indexOf(min)
  return index
}

精（zhuang）简（bi）的

function getIndex (arr) {
  return arr.reduce((index, val, i) => val <= 0 ? index : ((index < 0 || arr[i] < arr[index]) ? i : index), -1)
}

Answer 51 · 2021-01-28T02:34:00.000Z

let obj = [10, 21, 0, -7, 35, 7, 9, 23, 18].reduce((result, item, index) => {
if (!result[item] && item > 0) {
result[item] = index;
}
return result
}, {})
let res = Object.keys(obj)[0]
console.info(res, obj[res])

Answer 52 · 2021-02-23T06:53:58.000Z

function getIndex(arr) {
let index = null;
index = arr.findIndex(item => item === Math.min(...arr.filter(item => item > 0)))
return index;
}

Answer 53 · 2021-02-23T09:56:21.000Z

一次遍历就行了，循环找到符合条件的替换下标返回，不符合还返回原本下标
function getIndex(arr){
return arr.reduce((acc, cur, idx)=> cur > 0 && cur < arr[acc] ? idx : acc, -1)
}

Answer 54 · 2021-02-25T03:32:32.000Z

function getIndex(arr){
    // 先找到第一个非符的数及其下标
    let index = 0;
    while(arr[index] <=0 && index < arr.length){
        index++;
    }
    if(index >= arr.length){
        return -1;
    }
    // 从第一个非负的数字开始遍历
    let min = arr[index];
    for(let i = index+1;i < arr.length;i++){
        if(arr[i] > 0 && arr[i] <min){
            min = arr[i];
            index = i;
        }
    }
    return index;
}

Answer 55 · 2021-03-02T06:28:38.000Z

function getIndex(arr){
    return arr.indexOf(Math.min.apply(null,[].concat(arr).filter(item=>item>0)))
}

Answer 56 · 2021-03-02T07:35:55.000Z

function getMinIndex(arr) {
    let min = Infinity
    let minIndex
    arr.forEach((v, i) => {
        if (typeof v === 'number' && v > 0) {
            if (v < min) {
                min = v
                minIndex = i
            }
        }
    })
    return minIndex
}

Answer 57 · 2021-03-02T08:23:36.000Z

easy

function getIndex(arr){
    let index=null;
    let index_0 = arr[0]  // 假设符合预期的值为第一个
    for(let i = 0; i < arr.length; i++) {
        if(arr[i] <= index_0 && arr[i] > 0) {
             index_0 = arr[i] 
             index = i 
        }
    }
    return index;
}

Answer 58 · 2021-03-04T11:31:05.000Z

题目考的是应该条件判断的使用： 如何用最精炼的条件判断来描述题目给出的逻辑
使用reduce
如果只要求找非0非负最小值
条件判断next < 0 || (prev > 0 && perv < next) ? prev : next

如果next < 0 则直接返回prev
如果next > 0，继续判断prev；如果prev < 0 直接返回next
如果上面两条都不满足证明next和prev都大于0，最后再比较prev和next的大小

如果只找到满足条件的值，这么写即可;
如果数组内的值都是小于等于0的值，会默认返回第一个值（可以根据具体情景做调整）

function getIndex(arr) {
  return arr.reduce((prev, next) => (next < 0 || (prev > 0 && prev < next) ? prev : next))
}

题目不光要求找到值，还要求找到下角标，用变量存一下下角标就行了

function getIndex(arr) {
  let minIdx = -1;
  let min = arr.reduce((prev, next, currIdx) => {
    if (next < 0 || (prev > 0 && prev < next)) {
	    return prev;
    } else {
	    minIdx = currIdx;
	    return next;
    }
});
return minIdx > -1 ? [minIdx, min].join(",") : -1;
}

Answer 59 · 2021-03-05T00:36:13.000Z

function getIndex(arr) {
let index = arr.filter(i=>i>0).sort((a,b)=>a-b)[0];
let value=arr.findIndex(i=> i ==value )
return [value, index ].join(",")
}

Answer 60 · 2021-03-05T03:19:14.000Z

// 最小正数
function minRPlus(arr) {
  const l = arr?.length;
  let i = 0,
    minIdx;

  // 先找到最小非零、非负数
  for (; i < l; i++) {
    if (arr[i] > 0) {
      minIdx = i;
      break;
    }
  }

  // 再找到最小数
  for (; i < l; i++) {
    if (arr[i] > 0 && arr[i] < arr[minIdx]) {
      minIdx = i;
    }
  }
  return minIdx;
}

Answer 61 · 2021-03-13T10:29:13.000Z

function getIndex(arr) {
    let index = null;
    for (let i = 0; i < arr.length; i++) {
        if(arr[i] > 0) {
            if(arr[index] > arr[i] || !index) {
                index = i
            }
        }
    }
    return index;
}

类似选择排序，只是不需要排序，而是在第一层遍历时增加逻辑判断。

Answer 62 · 2021-03-16T01:38:20.000Z

function getIndex(arr){
  let index=null;
  index = arr.findIndex(item => item === Math.min.apply(null, arr.filter(item => item > 0)))
  return index;
}

Answer 63 · 2021-03-19T08:00:05.000Z

虽然代码有点多，但时间复杂度应该是最低的吧？

function getIndex(arr){
    let index = -1;
    if(!Array.isArray(arr) || arr.length==0) return index;
    let target;
    for(let i=0,len=arr.length; i<len; i++){
        const value = arr[i];
        if(typeof target==="undefined"){
            target = value;
            if(target>0){
                index = i;
            }
        }else{
            if(target>value && value>0){
                target = value;
                index = i;
            }
        }
    }
    return index;
}


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

Answer 64 · 2021-03-29T08:09:26.000Z

const find05 = (arr) => {
let index = null, minval = arr[0];
for (let i = 0; i < arr.length; i++) {
let val = arr[i];
if (val < minval && val > 0) {
minval = val
index = i
}
}
return index
}

Answer 65 · 2021-04-01T07:05:54.000Z

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

function getIndex(arr) {
let index = -1
arr.forEach((item, i) => {
if(item <= 0) {
index ++
}else if(item < arr[index]) {
index = i
}
})
return index
}

const index = getIndex(arr)
console.log(index, arr[index])

Answer 66 · 2021-04-02T02:34:50.000Z

function getIndex(arr){
return arr.indexOf(Math.min(...arr.filter(item=>item>0)))
}

Answer 67 · 2021-04-07T06:13:33.000Z

function getIndex(arr){
let index=null;
index = arr.indexOf( arr.filter(a => a > 0).sort((a, b ) => { return a - b })[0])
return index;
}

Answer 68 · 2021-04-08T14:11:01.000Z

`
function getMin(arr,min = 0) {

for (let i=0; i<arr.length; i++) {
  if (arr[i]>0 && min==0) min = i;
  min = arr[i]>0 && arr[i]< arr[min] ? i : min
}
return min

}
`

Answer 69 · 2021-04-09T08:12:45.000Z

var list = [10,21,0,-7,35,7,9,23,18];
function getIndex(arr) {
    let index = null
    let num = arr[0]
    arr.forEach((item, index2) => {
        if (num > 0 && arr[index2 + 1] > 0 && num > arr[index2 + 1]) {
            num = arr[index2 + 1]
            index = index2 + 1
        }
    })
    return index
}
console.log('getIndex', getIndex(list))

Answer 70 · 2021-04-12T09:57:13.000Z

function getMinIndex(list){
            const result = [Infinity, -1];
            for(let i = 0 , len = list.length ; i < len ; i++){
                const temp = list[i]
                if(temp > 0 && temp < result[0]){
                    result[0] = temp
                    result[1] = i
                }
            }
            if(result[1] > -1){
                return result[1];
            }else {
                return undefined;
            }
        }

时间复杂度 O(n)

Answer 71 · 2021-04-13T01:55:29.000Z

function findNumIndex(arr) {
      let result = [-1, Infinity];
      arr.forEach(function (obj, index) {
          if (obj > 0 && obj < result[1]) {
              result = [index, obj];
          }
      });
      return result;
  }

这个最简练确实每个人理解都有不同

Answer 72 · 2021-04-19T02:54:18.000Z

const min = arr.filter(v => v > 0).sort((a, b) => a - b)[0]

const index = arr.findIndex(v => v === min);

Answer 73 · 2021-04-19T06:29:30.000Z

function findMinNumIndex(arr) {
  if (!arr || !(arr || []).length) return -1
  let min = { index: -1, data: Infinity }
  arr.forEach((ele, idx) => {
    if (ele > 0 && ele < min.data) {
      min.data = ele
      min.index = idx
    }
  })
  return min.index
}

Answer 74 · 2021-04-20T03:30:44.000Z

function getIndex(arr){
let indexs = arr.filter((item)=>item !== 0 && Math.sign(item) !== -1);
let a0 = indexs.sort((a,b)=> a-b)[0];
return arr.indexOf(a0);
}

Answer 75 · 2021-04-22T15:19:34.000Z

function findMinNumIndex(arr){
    let min = Number.MAX_SAFE_INTEGER, ind = -1;
    arr.forEach((item,index) => {
        if(typeof item === 'number' && item > 0 && item < min){
            min = item;
            ind = index;
        }
    });
    return ind;
}

Answer 76 · 2021-04-24T06:36:06.000Z

Answer 77 · 2021-04-24T06:39:38.000Z

function getIndex(arr) {
     const [, minIndex] = arr.reduce(
       ([min, minIndex], el, index) => {
         if (el > 0 && (minIndex === -1 || min > el)) {
           return [el, index];
         }
         return [min, minIndex];
       },
       [null, -1],
     );
     return minIndex;
   }

Answer 78 · 2021-04-27T11:36:29.000Z

function getIndex(arr) {
    let index = null;
    arr.reduce((min, cur, internalIndex) => {
        if (cur <= 0) return min;
        if (cur < min) {
            index = internalIndex;
            return cur;
        }
        return min;
    }, Infinity)
    return index;
}

Answer 79 · 2021-05-02T02:27:04.000Z

function getIndex(arr) {
        let index = null
        const obj = {}
        arr.forEach((num, i) => {
            if (num > 0) {
                obj[num] = i
            }
        })
        index = Object.values(obj)[0]
        return index
    }

Answer 80 · 2021-05-07T09:18:27.000Z

//  尝试使用补码
function getIndex(arr){
    return arr.reduce(
        (prevIndex,curVal,curIndex) =>
            ~curVal < -1  
            && 
            (!~prevIndex || arr[prevIndex] >= curVal)  
                ? 
                curIndex 
                : 
                prevIndex,
        -1)
}

Answer 81 · 2021-05-08T16:04:22.000Z

function getIndex(arr) {
  return arr.reduce((minIndex, value, index) => {
    if (value > 0) {
      if (minIndex === -1) {
        minIndex = index;
      } else if (value < arr[minIndex]) {
        minIndex = index;
      }
    }
    return minIndex;
  }, -1);
}

Answer 82 · 2021-05-10T08:37:38.000Z

按我自己理解方式试了一把，又是留下了没有技术的泪水一天
`
// 找出最小值 [10,21,0,-7,35,7,9,23,18]
const temp = [10, 21, 0, -7, 35, 7, 9, 23, 18];

function findMin(value) {
    if (value.length === 0) return [-1, -1];
    return value.reduce((cur, item, index) => {
        console.log("item", item, cur);
        if (index === 0) cur = [index, item];
        if (item > 0 && item < cur[1]) {
            cur[0] = index;
            cur[1] = item;
        }
        return cur;
    }, []);
}

findMin(temp);

`

Answer 83 · 2021-05-10T08:53:52.000Z

按我自己理解方式试了一把，又是留下了没有技术的泪水一天
// 找出最小值 [10,21,0,-7,35,7,9,23,18]
const temp = [10, 21, 0, -7, 35, 7, 9, 23, 18];
function findMin(value) {
    if (value.length === 0) return [-1, -1];
    return value.reduce((cur, item, index) => {
        console.log("item", item, cur);
        if (index === 0) cur = [index, item];
        if (item > 0 && item < cur[1]) {
            cur[0] = index;
            cur[1] = item;
        }
        return cur;
    }, []);
}

findMin(temp);

这样好像也行

function findMin2(value) {
        if (value.length === 0) return false;
        return value.reduce((cur, item, index) => item > 0 && item < value[cur] ? index : cur, value.length - 1);
    }

Answer 84 · 2021-05-12T09:50:38.000Z

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

function getIndex(arr){
      let index=null;
      arr.reduce((acc, cur, i) => {
        if (acc > cur && cur > 0) {
          index = i
          return cur
        } else {
          return acc
        }
      })
      return index;
}

function getIndex(arr){
      return arr.indexOf(arr.reduce((acc, cur, index) => acc > cur && cur > 0 ? cur : acc))
}

Answer 85 · 2021-05-14T06:06:42.000Z

// 例如：[10,21,0,-7,35,7,9,23,18] 输出 5, 7 最小
function getIndex(arr) {
  let index = null
  let prev = null
  arr.forEach((item, currentIndex) => {
    if (item > 0 && (!prev || item < prev)) {
      prev = item
      index = currentIndex
    }
  })
  return index
}
const index = getIndex([10,21,0,-7,35,7,9,6,23,18])
console.log(index)

Answer 86 · 2021-05-14T08:30:31.000Z

function demo(arr) {
let index = 0;
let min = arr[0];
for (let i = 1; i < arr.length - 1; i++) {
if (arr[i] > 0 && arr[i] < min) {
index = i;
min = arr[i];
}
}
return [index, min]
}

Answer 87 · 2021-05-17T03:16:30.000Z

const arr = [10,21,0,-7,35,7,9,23,18];
function getIndex(arr){
return arr.reduce((prev, next, index) => (next>0 && next < prev[0]) ? [next, index] : prev ,[Infinity, -1]);
}
getIndex(arr)
这应该挺简洁的

Answer 88 · 2021-05-19T09:50:07.000Z

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

准确来说，第二把冒泡拿到最小的就行，不需要完整的排序，复杂度两者还是有点差距的。

Answer 89 · 2021-05-19T10:17:09.000Z

function getIndex(arr) {
    let min = -1;
    return arr.reduce((res, item, idx) => {
        if (item > 0 && (idx === 0 || item < min)) {
            min = item;
            return idx;
        }
        return res;
    }, -1);
}

Answer 90 · 2021-05-20T07:05:26.000Z

function getIndex(arr) {
    let index = null;
    const res = arr.reduce((obj, item, index) => {
        if (obj.value) {
            if (item > 0 && item < obj.value) {
                return {value: item, index}
            }
            return obj;
        } else {
            if (item > 0) {
                return {value: item, index}
            }
            return obj;
        }
    }, {})
    index = res.index;
    return index;
}

Answer 91 · 2021-05-20T09:50:22.000Z

function getIndex(arr){
if(!arr || arr.length ===0) {return null}
let index=null;
arr.forEach((item,theIndex) =>{if((index === null || item < arr[index]) && item > 0) index = theIndex} )
return index;
}

时间复杂度N，空间复杂度1

Answer 92 · 2021-06-04T07:19:49.000Z

function g(a) {
  return a.findIndex(i => i === a.filter(i => i > 0).sort((a, b) => a - b)[0])
}

g([10, 21, 0, -7, 35, 7, 9, 23, 18])

function g(a) { return a.findIndex(i => i === a.filter(i => i > 0).sort((a, b) => a - b)[0]) } g([10, 21, 0, -7, 35, 7, 9, 23, 18]).length

133个字符~~

Answer 93 · 2021-06-04T09:39:48.000Z

function getIndex(arr) {
  const newArr = [...arr].sort((a, b) => a - b).filter(x => x > 0)
  return newArr.length ? arr.indexOf(newArr[0]) : null;
}

Answer 94 · 2021-06-06T06:39:20.000Z

function getIndex(arr){
return arr.reduce((pre,cur,index,array)=>{
if(cur>0){
return cur>array[pre]? pre:index;
}
return pre;
},null)
}

Answer 95 · 2021-06-08T14:24:21.000Z

function getIndex(arr){
     let index=null;
     for(let i = 0;i<arr.length;i++){
            if(arr[i]>0 && (index === null||arr[i]<arr[index])){
                index = i
            }
        }
      return index;
}

Answer 96 · 2021-06-17T02:13:20.000Z

很简单的题怎么被你们整的那么复杂
function getIndex(arr){
let maxValue = Infinity;
let index=null;
arr.forEach((element, ind) => {
if (element > 0 && element < maxValue) {
maxValue = element;
index = ind;
}
});
return index;
}
这样不就行了嘛

Answer 97 · 2021-06-25T16:19:06.000Z

// 实现数组非零非负最小值index
const minIndex = arr.reduce((pre, cur, i) => cur > 0 ? (cur > arr[pre] ? pre : i) : pre);

Answer 98 · 2021-06-26T11:32:09.000Z

Without reduce

function getIndex(arr) {
    let index = null;
    let m = Number.POSITIVE_INFINITY;
    for(let i=0; i<arr.length; i++){
        if (arr[i] < m && arr[i] > 0) {
            index = i;
            m = arr[i];
        } 
    }
    return index;
}

Answer 99 · 2021-06-30T02:26:22.000Z

function posMin(arr) { let arr2 = arr.map(i => i + Math.abs(i)); let min = 0; return arr2.reduce((acc, cur, idx) => { return !cur ? acc : !min || cur < min ? (min = cur, idx) : acc; }, -1) }

没跑几个用例，写了图一乐

Answer 100 · 2021-07-06T02:08:25.000Z

function getIndex(arr) {
  let index = -1;
  let prev = Infinity;
  arr.forEach((item, idx) => {
    if (item > 0 && item < prev) {
      prev = item;
      index = idx;
    }
  });
  return index;
}