某外企 机试题

Question

如果数组中存在这样的数，这个数比它左边的所有的数大，并且比它右边的所有的数小，返回它的索引；如果不存在，返回-1。
例如：int[] arr = {5,3,6,2,7,10,8,12}; 7比它左边的数都大，比它右边的数都小，所以返回4

Answer 1

效率不高的代码,按照题目意思, 如果int[] arr = [1,2,3,4,5,6,7,8,9]那应该返回第二个, 理论上是应该返回一个int数组的
package compare;public class Main {

public static void main(String[] args)
{
int[] aa= new int[]{1,2,3,4,5,6,7,8,9};
System.out.println(getIndex(aa));
}

private static int getIndex(int[] dataArr)
{
for (int i = 1; i < dataArr.length-1; i++)
{
boolean find = true;
int currentData = dataArr[i];
for (int j = 0; j < dataArr.length; j++)
{
if (j <= i)
{
if (i != j)
{
if (currentData < dataArr[j])
{
find = false;
break;
}
}
}
else
{
if (currentData > dataArr[j])
{
find = false;
break;
}
}
}
if (find)
{
return i;
}
}
return -1;
}}

Answer 2

返回第一个符合要求的 public static int find(int[] arr) {
int i, j, k;
for(i=0; i<arr.length; i++) {
for(j=0; j<i; j++) {
if(arr[i] < arr[j])
break;
}
if(j == i) {
for(k=i+1; k<arr.length; k++) {
if(arr[i] > arr[k])
break;
}
if(k == arr.length)
return i;
}
}
return -1;
}

Answer 3

public  int getresult(){
int index = -1;
if(arrs.length < 3){
return -1;
}
for(int i = 1 ;i < arrs.length - 1;i++){
if(arrs[i]>arrs[i-1] && arrs[i]<arrs[i+1]){
if(check(i)){
index = i;
break;
}
}
}
return index;

}
public boolean check(int index){
boolean rs = true;
int a = arrs[index];
for(int i = 0 ;i < index;i++){
if(arrs[i] >= a){
return false;
}
}

for(int i = index+1; i < arrs.length;i++){
if(arrs[i] <= a){
return false;
}
}
return rs;
}

Answer 4

  我的答案：public class Test {
public static int getIndex(int[] arr){
boolean isOK=true;
for(int i=1;i<arr.length;i++){
for(int font=i-1;font>=0;font--){
if(arr[font] >arr[i])
isOK=false;
break;
}
if(true == isOK){
for(int last=i+1;last<arr.length;last++){
if(arr[last] <arr[i]){
isOK=false;
break;
}
}
}
if(true == isOK){
return i;
}
isOK=true;
}
return -1;
}
public static void main(String[] args) {
int[] arr = {5,3,6,2,7,10,8,12};
System.out.println(Test.getIndex(arr));
}
}

Answer 5

public class T {
private static List<Integer> list = new LinkedList<Integer>();//符合要求的都返回 public static void main(String[] args) {
          int[] arr = {1,2,3,4,5,6,7,8,9};
          get(arr);
          for(Integer i:list){
           System.out.println(i);
          }
} private static void get(int[] a) {
if (a.length <= 2)
list.add(-1);
else {
for (int i = 1; i < a.length - 1;i++) {
                if(a[i-1]<a[i]&&a[i]<a[i+1])
                 list.add(i);                
}
if(list.size()==0)
list.add(-1);
}
}
}

Answer 6

重新来-_-
public class T {
private static List<Integer> list = new LinkedList<Integer>();//符合要求的都返回 public static void main(String[] args) {
          int[] arr = {1,2,3,4,6,5,7,8,9};
          get(arr);
          for(Integer i:list){
           System.out.println(i);
          }
} private static void get(int[] a) {
if (a.length <= 2)
list.add(-1);
else {
for (int i = 1; i < a.length - 1;i++) {
int []left=new int[i];
System.arraycopy(a, 0, left, 0, left.length);
int []right=new int[a.length-i-1];
System.arraycopy(a, i+1, right, 0, right.length);
Arrays.sort(left);
Arrays.sort(right);
                if(left[i-1]<a[i]&&a[i]<right[0])
                 list.add(i);                
}
if(list.size()==0)
list.add(-1);
}
}
}

Answer 7

 private static void test(int[] array) {
        for (int i = 1, k = array.length-2; i < k; i++) {
            if(test(array,i,array[i])){
                System.out.println(array[i]);
            }
        }
    }
    private static boolean test(int[] array,int k,int data) {
        for (int i = 0; i < k; i++) {
            if(array[i] > data){
                return false;
            }
        }
        for (int j = k, l = array.length - 1; j < l; j++) {
            if(array[k] > array[j]){
                return false;
            }
        }
        return true;
    }    public static void main(String[] args) {
        int[] array = {5,3,2,6,7,10,8,12};
        test(array);
    }

Answer 8

晕，贴错了，重贴 private static void test(int[] array) {
        for (int i = 1, k = array.length-2; i < k; i++) {
            if(test(array,i,array[i])){
                System.out.println(array[i]);
            }
        }
    }
    private static boolean test(int[] array,int k,int data) {
        for (int i = 0; i < k; i++) {
            if(array[i] > data){
                return false;
            }
        }
        for (int j = k, l = array.length - 1; j < l; j++) {
            if(array[k] > array[j]){
                return false;
            }
        }
        return true;
    }    public static void main(String[] args) {
        int[] array = {5,3,2,6,7,10,8,12};
        test(array);
    }

Answer 9

我算的 只要遍历一遍就可以了，大家可以看看
public static int getFirstNum(int[] a) {
int len = a.length;//数组长度 int max = a[0];//最大值
int maxindex = 0; int tag = a[0];//目标
int index = 0;//目标下标 for (int i = 0; i < len; i++) {
if (max < a[i]) {//取得最大值
max = a[i];
maxindex = i;
} if (index <= maxindex) {//目标 在最大值的 左边
if (tag > a[i]) {//目标 值 比 a[i]小 ，把a[i+1}赋值给tag
index = i + 1;
tag = a[index];
} } else {// tag 在 最大值的右边或者相等 
if (tag == max) {//相等 

continue; } else if (tag < max) {//如果a[i]比 最大值小，tag继续 右移动
index = index + 1;
tag = a[index];
}
}
if(index ==len-1){//判断是不是 越界和 是不是没有取得值
if(maxindex < index){
index = -1;

}
 
break;
} }

if(index == len){
index = -1;
}
return index;
}

Answer 10

这个一定满足你的要求。
package compare;public class Main 
{        
        public static int getIndex(int[] arr)
        {
                int len=arr.length;
                for(int i=1;i<len-1;i++)
                {//最后一个运算下标为len-1
                        int left=0,right=i+1;
                        while(left<i){
                                //当前值任意一个左边的值大于它时则提前结束
                                if(arr[left++]>arr[i])
                                        break;
                        }
                        while(right<len){
                                //当前值任意一个右边的值小于它时则提前结束
                                if(arr[right++]<arr[i])
                                        break;
                        }
                        if(left==i&&right==len)
                                return i;
                }
                return -1;
        }
        
        public static void main(String[] args)
        {
                int[] arr = {5,3,6,2,7,10,8,12}; //可换数测试
                System.out.println(getIndex(arr));
        }
}

Answer 11

如果希望提高效率的话，改进如下：package compare;public class Main 
{        
        public static int getIndex(int[] arr)
        {
                int len=arr.length;
                for(int i=1;i<len-1;i++)
                {//最后一个运算下标为len-1
                        int left=0,right=i+1;
                        while(left<i){
                            //当前值任意一个左边的值大于它时则提前结束
                                if(arr[left++]>arr[i])
                                        break;
                        }
                        if(left<i)continue; //提前结束外层循环
                            while(right<len){
                            //当前值任意一个右边的值小于它时则提前结束
                                if(arr[right++]<arr[i])
                                        break;
                        }
                        if(right==len) //已经隐含了 left==i
                                return i;
                }
                return -1;
        }
        
        public static void main(String[] args)
        {
              int[] arr = {5,3,6,2,7,10,8,12}; //可换数测试
                System.out.println(getIndex(arr));
        }
}

Answer 12

<%int[] arr=new int[]{5,3,6,2,10,8,10,12}; 
int i=0;
for( i=0;i<arr.length;i++)
{
   if(i!=0&&i!=arr.length-1)
   {
      if(arr[i]>arr[i-1]&&arr[i]<arr[i+1])
      break;
   }
}
if(i==arr.length)
 {
  i=-1;
}
out.print(i);
 %>

Answer 13

public class Test {
public static int getIndex(int[] arr) {
boolean isOK = true;
for (int i = 1; i < arr.length; i++) {
int font = i - 1;
if (arr[font] > arr[i])
isOK = false; if (true == isOK) {
for (int last = i + 1; last < arr.length; last++) {
if (arr[last] < arr[i]) {
isOK = false;
break;
}
}
}
if (true == isOK&&i!=arr.length-1) {
return i;
}
isOK = true;
}
return -1;
} public static void main(String[] args) {
int[] arr = { 5, 3, 6, 7, 8, 5, 10, 8, 12 };
System.out.println(Test.getIndex(arr));
}
}

Answer 14

这题陷阱还是挺深的。
我在16楼贴的代码有点bug,那就是left++ 和 right++的问题
现改为for循环的(先操作后自增)
通过多组典型数据测试，均通过！！！
package compare;public class Main 
{        
        public static int getIndex(int[] arr)
        {
                int len=arr.length;
                for(int i=1;i<len-1;i++)
                {//最后一个运算下标为len-1
                        int left=0,right=i+1;
                        for(;left<i;left++){
                            //当前值任意一个左边的值大于它时则提前结束
                                if(arr[left]>arr[i])
                                break;
                        }
                        if(left<i)continue; //提前结束外层循环
                            for(;right<len;right++){
                            //当前值任意一个右边的值小于它时则提前结束
                                if(arr[right]<arr[i])
                                break;
                        }
                        if(right==len) //此时已经隐含了 left==i
                            return i;
                }
                return -1;
        }
        
        public static void main(String[] args)
        {
                int[] arr1 = {5,3,6,9,7,10,5,12}; //应返回-1
                int[] arr2 = {5,3,6,2,7,10,8,12}; //应返回4
                int[] arr3 = {5,3,6,9,7,10,8,12}; //应返回2
                int[] arr4 = {5,3,6,2,7,10,5,12}; //应返回-1
                System.out.println(getIndex(arr1));
                System.out.println(getIndex(arr2));
                System.out.println(getIndex(arr3));
                System.out.println(getIndex(arr4));
        }
}

Answer 15

此程序也有BUG!
当数组为
{ 3, 5, 7, 4, 6, 10, 9, 12 }
时应该返回-1,但却返回了4

Answer 16

一点补充：
20楼的代码有个bug规律，那就是在下标取值合法的情况下
当arr[i-2]>a[i]>arr[i-1]，并且a[i]同时小于{a[i+1]....a[n]}时
程序返回结果总是返回i。而此时应该返回-1

Answer 17

总结的不好，修正为：20楼的代码有个bug规律，那就是在下标取值合法的情况下 
当arr[i-2]>a[i]>arr[i-1]，并且a[i]同时小于{a[i+1]....a[n]}时(a[i]到a[n]的值并不是从小到大排列的) 
程序返回结果总是返回i。而此时应该返回-1

Answer 18

本人初学，写了个C的
int test(int *a,int n)
{
int *b,c,temp;
int i;
b=(int*)malloc(n);
b[0]=a[0];
for(i=1;i<n;i++)
if(a[i]>b[i-1])
b[i]=a[i];
else b[i]=b[i-1];
c=a[n-1];
for(i=n-2;i>0;i--)
{
if(a[i]<c)
{
if(a[i]>b[i-1])
return i;
else
c=a[i];
}
}
return -1;
}

Answer 19

唉。。CSDN有一点很不方便，写错了不能修改！！再针对我27楼中的修正一下：
a[i]到a[n]的值并不是从小到大排列的
应为：
a[i+1]到a[n]的值并不是从小到大排列的

Answer 20

这个代码不怎么好...期待更好的！public class A {
public static void main(String[] args) {
// 楼主的情况
int[] arr = { 5, 3, 6, 2, 7, 10, 8, 12 };
// 多个数符合的情况
// int[] arr = { 5, 3, 6, 2, 7, 10, 8, 16, 13, 17, 18 };
// 更极端的一种情况(头尾数是否考虑的情况等...)
// int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
// 不存在的情况
// int[] arr = { 11, 10, 9, 8 };
getIndex(arr);
} public static void getIndex(int[] arr) {
boolean flag1 = false;
boolean flag2 = false;
for (int i = 1; i < arr.length - 1; i++) {
for (int j = 0; j < i; j++) {
if (arr[i] < arr[j]) {
flag1 = false;
break;
} else {
flag1 = true;
}
}
for (int k = i + 1; k < arr.length; k++) {
if (arr[i] > arr[k]) {
flag2 = false;
break;
} else {
flag2 = true;
}
}
if (flag1 && flag2) {
System.out.println("符合元素索引------" + i);
}
// else {// 这个else主要针对不存在的情况...会打印多次
// System.out.println("不符合------"+-1);
// }
}
}
}

Answer 21

我也写了一个，貌似很复杂，只是我想正好学习JAVA，当做练习，熟悉些特性吧
其实核心就是getIndices，这个方法返回所有符合条件的Index,
思想是先找到所有大于左边所有的数的那些数
再找到所有小于右边所有的数的那些数
两个条件都符合的，就是我们要找的
如果只需要第一个，取返回数组的第一个就OK了
没找到符合条件的时候，就返回-1import java.util.*;class FindIndexAux
{
int value;
boolean isGreaterThanBefore;
boolean isLessThanAfter; public FindIndexAux(int i, boolean gtb, boolean lta)
{
value = i;
isGreaterThanBefore = gtb;
isLessThanAfter = lta;
} public boolean greaterThan(FindIndexAux o)
{
return (value > o.value);
} public boolean lessThan(FindIndexAux o)
{
return (value < o.value);
}
}class FindIndex
{
public static Integer[] getIndices(int... args)
{
FindIndexAux[] fi = new FindIndexAux[args.length]; //初始化
for (int index = 0; index < args.length; index++)
{
fi[index] = new FindIndexAux(args[index],false,false);
} //在以下查找过程中，默认第一个和最后一个都是无效的
//先正向查找，标识所有大于左边的对象；
FindIndexAux max=fi[0];
for (int index = 1; index < fi.length-1; index++)
{
if (fi[index].greaterThan(max))
{
max = fi[index];
fi[index].isGreaterThanBefore = true;
}
} //再反向查找，标识所有小于右边的对象； FindIndexAux min=fi[fi.length - 1]; for (int index = fi.length-2; index > 0; index--)
{
if (fi[index].lessThan(min))
{
min = fi[index];
fi[index].isLessThanAfter = true;
}
} //最后遍历所有对象，查找isGreaterThanBefore、isLessThanAfter都为true的，就是要找的
ArrayList<Integer> ial = new ArrayList<Integer>();
for (int index = 1; index < fi.length-1; index++)
{
if (fi[index].isGreaterThanBefore && fi[index].isLessThanAfter) ial.add(index);
} if (ial.size() > 0) return ial.toArray(new Integer[1]);
else return (new Integer[]{-1}); } public static void main(String[] args)
{
Integer[] indices = getIndices(new int[]{5,3,6,9,7,10,5,12});
System.out.println("getIndices(new int[]{5,3,6,9,7,10,5,12}):");
if (indices.length == 1) System.out.println(indices[0]);
else System.out.println(Arrays.toString(indices)); indices = getIndices(new int[]{5,3,6,2,7,10,8,12});
System.out.println("getIndices(new int[]{5,3,6,2,7,10,8,12}):");
if (indices.length == 1) System.out.println(indices[0]);
else System.out.println(Arrays.toString(indices)); indices = getIndices(new int[]{5,3,6,9,7,10,8,12});
System.out.println("getIndices(new int[]{5,3,6,9,7,10,8,12}):");
if (indices.length == 1) System.out.println(indices[0]);
else System.out.println(Arrays.toString(indices)); indices = getIndices(5,3,6,2,7,10,5,12);
System.out.println("getIndices(5,3,6,2,7,10,5,12):");
if (indices.length == 1) System.out.println(indices[0]);
else System.out.println(Arrays.toString(indices)); indices = getIndices(3,4,5,6,7,8,9,10);
System.out.println("getIndices(3,4,5,6,7,8,9,10):");
if (indices.length == 1) System.out.println(indices[0]);
else System.out.println(Arrays.toString(indices)); indices = getIndices(3,4,7,13,10,15,17,16);
System.out.println("getIndices(3,4,7,13,10,15,17,16):");
if (indices.length == 1) System.out.println(indices[0]);
else System.out.println(Arrays.toString(indices));
}
}
测试结果
getIndices(new int[]{5,3,6,9,7,10,5,12}):
-1
getIndices(new int[]{5,3,6,2,7,10,8,12}):
4
getIndices(new int[]{5,3,6,9,7,10,8,12}):
2
getIndices(5,3,6,2,7,10,5,12):
-1
getIndices(3,4,5,6,7,8,9,10):
[1, 2, 3, 4, 5, 6]
getIndices(3,4,7,13,10,15,17,16):
[1, 2, 5]

Answer 22

加个这个if (flag1) continue;效率要高一些。
回过头看了一下大家的，和20楼一样了。
大家讨论一下：outer这个怎样使用更好？

Answer 23

有些眼花？
写个直接点的
只写出核心方法 public static Integer[] getIndicesAnother(int... args)
{
boolean[] nGreaterThanBefore = new boolean[args.length];
boolean[] nLessThanAfter = new boolean[args.length]; //初始化
for (int index = 0; index < args.length; index++)
{
nGreaterThanBefore[index] = false;
nLessThanAfter[index] = false;
} //在以下查找过程中，默认第一个和最后一个都是无效的
//先正向查找，标识所有大于左边的对象；
int max=args[0];
for (int index = 1; index < args.length-1; index++)
{
if (args[index] > max)
{
max = args[index];
nGreaterThanBefore[index] = true;
}
} //再反向查找，标识所有小于右边的对象； int min=args[args.length - 1]; for (int index = args.length-2; index > 0; index--)
{
if (args[index]<min)
{
min = args[index];
nLessThanAfter[index] = true;
}
} //最后遍历所有对象，查找isGreaterThanBefore、isLessThanAfter都为true的，就是要找的
ArrayList<Integer> ial = new ArrayList<Integer>();
for (int index = 1; index < args.length-1; index++)
{
if (nGreaterThanBefore[index] && nLessThanAfter[index]) ial.add(index);
} if (ial.size() > 0) return ial.toArray(new Integer[1]);
else return (new Integer[]{-1}); }

Answer 24

写出来的思路和22楼类似,我觉得这样判断 挺好.
public static int findwhere(int[] arr){
        int l=arr.length;
        int res=-1;
        for(int i=0;i<l;i++){
         int n=0;
         int m=0;
         for(int j=0;j<l;j++){
         if(i<j){
         if(arr[i]>arr[j]){
                 break;
                 }else{
                 n++;
                 }
         }
         if(i>j){
         if(arr[i]<arr[j]){
                 break;
                 }else{
                 m++;
                 }
         }
            }
         if((m+n==l-1)&&i!=0&&i!=l-1){
         res=i;
         break;
         }
        }
        return res;
}

Answer 25

Java code
public class Find
{
public static int find(int []with){
int temp;
int length = with.length;
for(int i=0; i<length; i++){
for(int j=0; j<length; j++){
if((j < i) && (with[j] >= with [i]))//判断是否左边的数都小于它
break;
if((j > i) && (with[j] <= with [i]))//判断是否右边的数都大于它
break;
if(j == length - 1)
return i;
}
}
return -1;//无满足条件的数
} public static void main(String []args){
int []test = {22,2,33,5,77,88,999,1000,111,100};
int temp = find(test);
System.out.println(temp);
}
}

Answer 26

博大精深   太强了 刚刚血JAVA 就看懂啊这么炫目的东西

Answer 27

嘻嘻，先说说我对题目的理解吧。
要找一个数比它左边的所有的数大，并且比它右边的所有的数小，那么应该不包括最左和最右的数字。
我对这题的理解怕与各位不同的主要就是这么一点。
我之前其实是学C++的，比较喜欢算法题，学过两天JAVA，来瞧瞧~看感兴趣就做了做，高手莫见笑
下面代码是我由C++转过来的，语法不知道有没有错
如果有可以改进的地方希望各位指出，不常上网，有改进可以发到我邮箱[email protected]
呵呵，大家互相交流//====================================================================================
int temp=arr[0],Re=0;
for(int i=1;i<arr.length;i++)
{
if(temp>arr[i]&&arr[Re]>=arr[i])Re=i+1;
else temp=arr[i];
}
return (Re==0||Re>=arr.length-1?-1:Re);
//====================================================================================测试结果：
input                   output     PS.
{1,2,3,4,5,6,7,8,9}     -1         arr[0]比右边所有数字要小，但左边无数，arr[9]反之
{9,8,7,6,5,4,3,2,1}     -1         任何一个数比右边数大，比左边数小
{5,5,5,5,5,5,5,5,5}     -1
{2,1,4,3,5,9,6,8,7}     4
{5,3,6,2,7,9,8,9,9}     4

Answer 28

说说我自己代码的思想吧初始返回下标变量Re=0；temp=arr[0]
随着一次for循环将遍历arr[1]~arr[arr.length-1]
temp始终保持大于等于arr[Re]中的最大数值当存在一个arr[i]比temp小且不大于arr[Re]时
那么现在的arr[Re]就存在了右边比他小或等于他的数
无论何种情况，arr[Re]不可能为要寻找的数
而arr[i]也不可能为要找的数字，因为其左边的temp比他大故取Re=i+1，arr[Re]可能为所要找的数字
因为在arr[Re]前的数字最大数值为temp，arr[Re]可能比temp大且比右边所有数字小
到底是不是就看下一步循环当temp大于arr[i]而arr[i]比arr[Re]小时
依旧执行temp=arr[i]
这一步对结果没有影响，因为arr[i]比arr[Re]大，故temp依旧比arr[Re]大
temp只要比arr[Re]大就足够去检测arr[Re]右边的数字是否符合要求呵呵，说得挺乱的，建议大家用纸笔对着程序举个例子来走走步骤

Answer 29

/*
 * 复杂度为O(n)的算法 Ydy from wyu
 */
public static int findMid(int arr[]) {
int maxInd = 0;// 序列中的最大值
int result = 0;// 暂存的结果index
boolean ok = false;// 是否合法的标志位 // 循环开始，里面没有嵌套for
for (int i = 1; i < arr.length; i++) {
//如果小于或等于结果ok置false
if (arr[i] <= arr[result]) {
ok = false;
} else if (!ok && arr[i] > arr[maxInd]) {
maxInd = i;
ok = true;
result = i;
}
}
return (ok && result != arr.length - 1) ? result : -1;
}

Answer 30

输入数据int[] arr = { 5, 3, 2, 7, 6, 8, 10, 12, 9 };
int[] arr2 = { 1, 2, 3 };
int[] arr3 = { 3, 2, 4 };
int[] arr4 = { 22, 2, 33, 5, 77, 88, 999, 1000, 111, 100 };
int[] arr5 = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int[] arr6 = { 5, 5, 5, 5, 5, 5, 5, 5, 5 };
int[] arr7 = { 2, 1, 4, 3, 5, 9, 6, 8, 7 };
int[] arr8 = { 5, 3, 6, 2, 7, 9, 8, 9, 9 };结果5
1
-1
4
1
-1
4
4

Answer 31

貌似53楼有bug，再贴一段/*
 * 复杂度为O(n)的算法 Ydy from wyu
 */
public static int findMid(int arr[]) {
int maxInd = 0;// 序列中的最大值
int result = 0;// 暂存的结果index
boolean ok = false;// 是否合法的标志位 // 循环开始，里面没有嵌套for
for (int i = 1; i < arr.length; i++) {
//找到最大值
if(arr[i]>arr[maxInd])
maxInd=i;

//如果小于或等于结果ok置false
if (arr[i] <= arr[result]) {
ok = false;
} else if (!ok && maxInd==i) {
ok = true;
result = i;
}
}
return (ok && result != arr.length - 1) ? result : -1;
}

Answer 32

52楼的也没测试通过目前只有5楼的没发现BUG

Answer 33

57楼的修正了bug但还是只能返回第一个出现的，后面的就无法返回了

Answer 34

单循环实现，做了简单的测试。
排除了第一个和最后一个元素作为答案的情况。 
例如 {1,2,3}返回 -1
     {3,2,1}返回 -1  public static int getIndex(int[] numbers){
    if(numbers == null || numbers.length < 4) {
      return -1;
    }
    int index = 0;
    boolean leftCheck = true;
    for(int i = 1; i < numbers.length; i++) {
      if(leftCheck) {
        if(numbers[index] < numbers[i]) {
          index = i;
          leftCheck = false;
        }
      } else {
        if(numbers[index] > numbers[i]) {
          index = i - 1;
          leftCheck = true;
        }
      }
    }
    return (leftCheck || index == numbers.length - 1 )? -1 : index;
  }

Answer 35

public class Test
{
public static void main( String[] args ) throws Exception
{
boolean bool = false;
int[] arr = { 5, 3, 6, 2, 7, 10, 8, 12 };
Map<Integer, Integer> map = new HashMap<Integer, Integer>(); for ( int i = 0; i < arr.length; i++ )
{
map.put( arr[i], i );
}

Arrays.sort( arr );
flag: 
for ( int i = 1; i < arr.length - 1; i++ )
{
for ( int j = 0; j < i; j++ )
{
if ( map.get( arr[j] ) > map.get( arr[i] ) )
{
bool = false;
continue flag;
} else
{
bool = true;
}
}
for ( int j = i + 1; j < arr.length; j++ )
{
if ( map.get( arr[j] ) < map.get( arr[i] ) )
{
bool = false;
continue flag;
} else
{
bool = true;
}
}
if ( bool )
{
System.out.println( i );
}
} }}

Answer 36

86楼的bug很明显，{1,7,34,0,3,46,45,56}，结果是什么都没有返回

Answer 37

我有个思路，我就说下思路，如果看着对就帮我写代码
int[] arr = {5,3,6,2,7,10,8,12}; 
以这个数为例，应该用 3开始 p 当前数 3
分别用 max 保存左边最大的 5
      min 保存右边最小的 2
      判断 p > max and p<min 输出p
    * 如果p > max 那么 max = p 第二次 p = 6 
      判断如果 p = min 那再在右边找最小值min
      判断 p > max and p<min 输出p
      * 如果p > max 那么 max = p 
.
.
.
这样应该可以减少数据的遍例

Answer 38

开头那段安全判断是多余的。简化掉。
感觉应该很难再简化啦，哪位高手指教。  public static int getIndex(int[] numbers){
    int index = 0;
    boolean leftCheck = true;
    for(int i = 1; i < numbers.length; i++) {
      if(leftCheck) {
        if(numbers[index] < numbers[i]) {
          index = i;
          leftCheck = false;
        }
      } else if(numbers[index] > numbers[i]) {
        index = i - 1;
        leftCheck = true;
      }
    }
    return (leftCheck || index == numbers.length - 1) ? -1 : index;
  }

Answer 39

我用最笨的办法做的public class arrange{
public static void main(String[] args){
int[] arrs = {75,5,7,68,42,36,10};
int len = arrs.length;
for(int i=0;i<len;i++){
if(i==0||i!=0&&arrs[i]>arrs[i-1]){
for(int j=i;j<len-1;j++){
if(arrs[i]>arrs[j+1]){
break;
}
if(j+1==len-1){
System.out.println("answer :"+i);
return;
}
}
}
}
}
}

Answer 40

那我就写个可以返回序列的，大家帮忙测试。/*
 * 复杂度为O(n)的算法 Ydy from wyu
 */
public static int[] findMid2(int arr[]) {
int maxInd = 0;// 序列中的最大值
int result = 0;// 暂存的结果index
int last = 0;
boolean ok = false;// 是否合法的标志位 // 循环开始，里面没有嵌套for
for (int i = 1; i < arr.length; i++) {
// 找到最大值
if (arr[i] > arr[maxInd]) {
maxInd = i;
if (ok)
last++;
} // 如果小于或等于结果ok置false
if (arr[i] <= arr[result]) {
ok = false;
} else if (!ok && maxInd == i) {
ok = true;
result = i;
last = result;
}
}
if (ok && result <= arr.length) {
return Arrays.copyOfRange(arr, result, last);
} else
return null;
}

Answer 41

public static int getInterger(int[] arr){
        int index=-1;
        int[] arrLeft=new int[arr.length];
        int[] arrRight=new int[arr.length];
        int i,j,min=arr[0],max=arr[arr.length-1];
        arrLeft[0]=arr[0];
        arrRight[arr.length-1]=arr[arr.length-1];
        for(i=0,j=arr.length-1;i<arr.length;i++,j--){
            if(min<arr[i]){
                arrLeft[i]=arr[i];
                min=arr[i];
            }
            else{
                arrLeft[i]=min;
            }            if(max>arr[j]){
                arrRight[j]=arr[j];
                max=arr[j];
            }
             else{
                arrRight[j]=max;
            }
        }
        for(i=0;i<arr.length;i++){
            if(arr[i]==arrLeft[i]&&arr[i]==arrRight[i]) return arr[i];
        }
        return index;
    }就算要反回一个数组也可以！

Answer 42

/*
如果数组中存在这样的数，这个数比它左边的所有的数大，并且比它右边的所有的数
小，返回它的索引；如果不存在，返回-1。 例如：int[] arr = {5,3,6,2,7,10,8,
12}; 7比它左边的数都大，比它右边的数都小，所以返回4
*/
import java.util.*;
public class Search
{
int index = -1;
public int find(int[] array,int obj)
{
for(int i=0;i<array.length;i++)
{
if(array[i]==obj)
{
index = i;
}
}
if(index>0&&index<array.length-1)
{
if(array[index]>array[index-1]&&array[index]<array[index+1])
{
return index;
}
}
return -1;
}
public static void main(String[] args)
{
System.out.println("请输入数组，用空格符“ ”隔开");
Scanner in = new Scanner(System.in);
String str[] = in.nextLine().split(" ");
int[] array = new int[str.length];
for(int i=0;i<str.length;i++)
{
array[i]=Integer.parseInt(str[i]);
}
System.out.println("请输入你要查询的数：");
Scanner in1 = new Scanner(System.in);
int obj = Integer.parseInt(in1.nextLine());
Search search = new Search();
int index = search.find(array, obj);
if(index>0)
{
System.out.println("查询成功,index = "+index);
}
else
{
System.out.println("查询不成功！");
}
}
}

Answer 43

92楼的你测试过没有啊我测试一个都没通过莫名其妙的都返回[I@de6ced，还不如你上次的呢

Answer 44

public class FindIndex
{
public static int findIndex(int[] arr)
{
for(int i = 0; i < arr.length; i++)
{
boolean isFindHead = false;
boolean isFindEnd = false;
for(int j = 0; j < i; j++)
{
if(arr[j] >= arr[i])
{
break;
}
else if(j == i - 1)
{
isFindHead = true; 
}
}
for(int k = i + 1; k < arr.length; k++)
{
if(arr[k] <= arr[i])
{
break;
}
else if(k == arr.length - 1)
{
isFindEnd = true;
}
}
if(isFindHead == true && isFindEnd == true)
{
return i;
}
}
return -1;
}
public static void main(String agrs[])
{
int[] arr = {5,3,6,2,7,10,8,12}; 
System.out.println(findIndex(arr)); 
}
}

Answer 45

public class FindIndex
{
public static int findIndex(int[] arr)
{
for(int i = 0; i < arr.length; i++)
{
boolean isFindHead = false;
boolean isFindEnd = false;
for(int j = 0; j < i; j++)
{
if(arr[j] >= arr[i])
{
break;
}
else if(j == i - 1)
{
isFindHead = true; 
}
}
for(int k = i + 1; k < arr.length; k++)
{
if(arr[k] <= arr[i])
{
break;
}
else if(k == arr.length - 1)
{
isFindEnd = true;
}
}
if(isFindHead == true && isFindEnd == true)
{
return i;
}
}
return -1;
}
public static void main(String agrs[])
{
int[] arr = {5,3,6,2,7,10,8,12}; 
System.out.println(findIndex(arr)); 
}
}

Answer 46

public class Test {
public static void main(String[] args) {
int i[] = new int[] { 3,4,5,6,7 };
getIndex(i);
} private static void getIndex(int[] i) {
StringBuffer sb = new StringBuffer();
for (int j = 1; j < i.length - 1; j++) {
int c = 0;
for (int k = 0; k < j; k++) {
if (i[k] >= i[j]) {
c++;
break;
}
}
for (int m = j + 1; m > j && m < i.length; m++) {
if (i[m] <= i[j]) {
c++;
break;
}
}
if (c == 0)
sb.append(j).append("@");
}
if (sb.length() == 0)
sb.append(-1);
System.out.println(sb.toString());
}
}

Answer 47

不好意思，还是有bug，不过你不能直接用System.out.print打印数组，这样会显示该数组的内存地址，用for循环或者是Arrays.toString(int a[]);