智力题

1涂色

你要在一个nxm的格子图上涂色，你每次可以选择一个未涂色的格子涂上你开始选定的那种颜色。同时为了美观，我们要求你涂色的格子不能相邻，也就是说，不能有公共边，现在问你，在采取最优策略的情况下，你最多能涂多少个格子？

给定格子图的长n和宽m。请返回最多能涂的格子数目。

测试样例：

1,2

返回：1

import java.util.*;
 
public class Paint {
    public int getMost(int n, int m) {
        // write code here
        int res = (n*m+1)/2;
        return res;
    }
}

 

import java.util.*;
 
public class Paint {
    public int getMost(int n, int m) {
        // write code here
         
        if(n<0||m<0)
            return 0;
        if(n*m%2==0){
            return n*m/2;
        }else{
            return n*m/2+1;
        }
    }
}

 

import java.util.*;
 
public class Paint {
    public int getMost(int n, int m) {
        // write code here
        return (n*m)%2==0?n*m/2:n*m/2+1;
    }
}

2赛马

作为一个马场的主人，你要安排你的n匹赛马和另一个马场的n匹马比赛。你已经知道了对方马场的出战表，即参加每一场的马的强壮程度。当然你也知道你自己的所有马的强壮程度。我们假定比赛的结果直接由马的强壮程度决定，即更壮的马获胜(若相同则双方均不算获胜)，请你设计一个策略，使你能获得尽量多的场次的胜利。

给定对方每场比赛的马的强壮程度oppo及你的所有马的强壮程度horses(强壮程度为整数，且数字越大越强壮)同时给定n，请返回最多能获胜的场次。

测试样例：

[1,2,3],[1,2,3],3

返回：2

import java.util.*;
 
public class HorseRace {
     public int winMost(int[] oppo, int[] horses, int n) {
        // write code here
        sort(oppo, n);
        sort(horses, n);
        int i, j = n - 1 , count = 0;
        for(i = n - 1; i >= 0; i--)
        {
            if(oppo[i] < horses[j])
            {
                count++;
                j--;
                 
            }
        }
        return count;
    }
    void sort(int a[], int n)
    {
        int i, j;
        for(i = 0; i < n - 1; i++)
        {
            for(j = 0; j < n - i - 1; j++)
            {
                if(a[j] > a[j + 1])
                {
                    
                    swap(a, j, j + 1);
                }
            }
        }
         
    }
    void swap(int arr[], int a, int b)
    {
        int temp;
        temp = arr[a];
        arr[a] = arr[b]; 
        arr[b] = temp;
    }
}

3跳格子

你和你的朋友正在玩棋子跳格子的游戏，而棋盘是一个由n个格子组成的长条，你们两人轮流移动一颗棋子，每次可以选择让棋子跳1-3格，先将棋子移出棋盘的人获得胜利。我们知道你们两人都会采取最优策略，现在已知格子数目，并且初始时棋子在第一格由你操作。请你计算你是否能获胜。

给定格子的数目n(n为不超过300的正整数)。返回一个整数，1代表能获胜，0代表不能获胜。

测试样例：

3

返回：1

import java.util.*;
 
public class Jump {
    public int checkWin(int n) {
        // write code here
        return (n - 1) % 4 == 0 ? 0 : 1;
    }
}

4游戏

A与B做游戏。 在一个n*m的矩阵中的出发点是（1，m），终点是（n,1），规则是只能向左移动一格，向下一格或向左下移动一格，先走到终点的为winner。 A先走。

给定两个整数n和m，请返回最后的获胜者的名字(A或B)。

测试样例：

5 3

返回：B

import java.util.*;
  
public class Game {
    public char getWinner(int n, int m) {
        // write code here
          
        if((n & 1)==1 && (m & 1)==1) return 'B';
        else return 'A';
    }
}

 

import java.util.*;
 
public class Game {
    public char getWinner(int n, int m) {
       if(m%2!=0 && n%2!=0)
            return 'B';
        else
            return 'A';
    }
}

5数组清空

现在有一个整数数组，其元素值均为1-n范围内的某个整数，现在你和你的朋友在玩一个游戏，游戏的目的是把数组清空，你们轮流操作，你是先手，每次操作你可以删除数组中值为某个数的元素任意多个(当然数组中值为这个数的元素个数应大于等于你删除的个数,且你至少要删除一个数)。最先把数组清空的人获得胜利。假设你们都采取最优策略，请你计算你能否获得胜利。

给定一个整数数组A和元素个数n。请返回一个整数，1代表你能获胜，0代表你不能获胜。

测试样例：

[1,1,1]

返回：1

import java.util.*;
 
public class Clear {
    public int getWinner(int[] A, int n) {
        // write code here
        int res = 0;
        Arrays.sort(A);
        for(int i=0,j;i<n;i++){
            j = i;
            while(j<n&&A[i]==A[j]) j++;
            res ^= (j-i);
        }
        return res==0?0:1;
    }
}

 

import java.util.*;
 
public class Clear {
    public int getWinner(int[] A, int n) {
        // write code here
        sort(A, 0, n - 1);
        int res = 0;
        for(int i = 0; i < n; ++i)
            {
            int j = i;
            while( j < n &&A[i] == A[j])
                {
                ++j;
            }
            res ^= (j - i);
        }
        return res == 0 ? 0 : 1;
    }
    public void sort(int[] A, int start, int end)
        {
        int target = start + (end - start) / 2;
        int mid = partion(A, target, start, end);
        if(mid > start + 1)
            sort(A, start, mid - 1);
        if(mid < end - 1)
            sort(A, mid + 1, end);
    }
    public int partion(int[] A, int target, int start, int end)
        {
        int temp = A[target];
        A[target] = A[start];
        A[start] = temp;
        while(end > start)
            {
            while(end > start && A[end] > temp)
                --end;
            if(start < end)
                {
                A[start++] = A[end];
            }
            while(end > start && A[start] < temp)
                ++start;
            if(end > start)
                {
                A[end--] = A[start];
            }
        }
        A[start] = temp;
        return start;
         
    }
}

 

import java.util.*;
 
public class Clear {
    public int getWinner(int[] A, int n) {
        // write code here
        if(A == null || n == 0){
            throw new RuntimeException("数组为空!");
        }
        int result = 0;
        int num;
        Arrays.sort(A);
        for(int i = 0;i < n;++ i){
            int j = i;
            num = 0;
            while(j < n && A[i] == A[j]){
                ++ num;
                ++ j;
            }
            result ^= num;
        }
        /*for(int i = 1;i < n;++ i){
            if(A[i] == A[i-1]){
                ++ num;
            }else{
                result ^= num;
                num = 1;
            }
        }
        result ^= num;*/
        return result == 0 ? 0 : 1;
    }
}

 

import java.util.*;
 
public class Clear {
    public int getWinner(int[] A, int n) {
        // write code here
        int res = 0;
        Arrays.sort(A);
        for(int i=0,j;i<n;i++){
            j = i;
            while(j<n&&A[i]==A[j]) j++;
            res ^= (j-i);
        }
        return res==0?0:1;
    }
}