一、33. 搜索旋转排序数组 - 力扣（LeetCode） (leetcode-cn.com)

实现一个函数，在一个整型数组中找一个整数，返回它的数组下标，如果不存在则返回-1

（1）传入的参数int*nums代表一个整型数组，int numsSize代表数组长度,target则表示要查找的数；

（2）遍历数组的每个元素；

（3）如果找到某个元素和传入参数target相等，则直接放回下标i;

（4）如果一直没有找的哦啊，则返回-1；

int search(int* nums, int numsSize, int target){
    for(int i = 0; i<numsSize ; i++){
        if(nums[i]==target){
            return i; 
        }
    }
    return -1;
}

二、81. 搜索旋转排序数组 II - 力扣（LeetCode） (leetcode-cn.com)

bool search(int* nums, int numsSize, int target){
    for(int i=0;i<numsSize;i++){
        if(nums[i]==target){
            return true;
        }
    }
    return false;
}

三、153. 寻找旋转排序数组中的最小值 - 力扣（LeetCode） (leetcode-cn.com)

（1）定义一个全局最小值；

（2）遍历数组所有元素；

（3）如果数组元素nums[i]比全局最小值小，则更新全局最小值。

用c写，但是java同理
int findMin(int* nums, int numsSize){
    int min =1;
    for(int i=1;i<numsSize;i++){
        if(nums[i] < nums[i-1])
           return nums[i];
         }
         return nums[0];
    }

四、70. 爬楼梯 - 力扣（LeetCode） (leetcode-cn.com)

 

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1.  1 阶 + 1 阶
2.  2 阶
示例 2：

输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
1.  1 阶 + 1 阶 + 1 阶
2.  1 阶 + 2 阶
3.  2 阶 + 1 阶

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/climbing-stairs
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

int climbStairs(int n){
    int f[10000];
    f[0] = f[1] = 1;
    for(int i = 2; i<=n;i++){
        f[i] = f[i-1]+f[i-2];
    }
    return f[n];
}

五、509. 斐波那契数 - 力扣（LeetCode） (leetcode-cn.com)

 

斐波那契数，通常用 F(n) 表示，形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1
给你 n ，请计算 F(n) 。

 

示例 1：

输入：2
输出：1
解释：F(2) = F(1) + F(0) = 1 + 0 = 1
示例 2：

输入：3
输出：2
解释：F(3) = F(2) + F(1) = 1 + 1 = 2
示例 3：

输入：4
输出：3
解释：F(4) = F(3) + F(2) = 2 + 1 = 3
 

提示：

0 <= n <= 30

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fibonacci-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

int fib(int n){
    int res=0;
    int ans = 1;
    for(int i = 0;i<n;i++){
        res += ans;
        ans = res-ans;
    }
    return res;
}

六、1137. 第 N 个泰波那契数 - 力扣（LeetCode） (leetcode-cn.com)

解题思路：

1. 因 0 <= n <= 37，则创建长度为 38 的 int 数组 nums

2. 据题意，将 nums[0] = 0，nums[1] = 1，nums[2] = 1

3. 从 3 开始循环至 n（包含 n）

4. 计算出 nums[i] 的结果，结果为索引 i 的前三项之和

5. 最终结果为 nums[n]

class Solution {
    public int tribonacci(int n) {
    int[] m = new int[38];
    m[0] = 0;
    m[1] = 1;
    m[2] = 1;
    for (int i = 3; i <= n; i++) {
    m[i] = m[i - 1] + m[i - 2] + m[i - 3];
    }
    return m[n];
    }
}

用C编写
int tribonacci(int n){
    if(n==0)
    return 0;
    if(n<=2)
    return 1;
    int a = 0,b = 1,c = 1;
    for(int i = 3;i <= n; i++){
        int sum = a+b+c;
        a=b,b=c,c=sum;
    }
    return c;
}

七、2006. 差的绝对值为 K 的数对数目 - 力扣（LeetCode） (leetcode-cn.com)

给你一个整数数组 nums 和一个整数 k ，请你返回数对 (i, j) 的数目，满足 i < j 且 |nums[i] - nums[j]| == k 。

|x| 的值定义为：

如果 x >= 0 ，那么值为 x 。
如果 x < 0 ，那么值为 -x 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/count-number-of-pairs-with-absolute-difference-k
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

int countKDifference(int* nums, int numsSize, int k){
    int ans = 0;
    for(int i = 0;i<numsSize;i++){
        for(int j = i+1;j<numsSize;j++){
            if(abs( nums[i] - nums[j] ) == k)
                ans++;
            }
        }
        return ans;
}

八、LCP 01. 猜数字 - 力扣（LeetCode） (leetcode-cn.com)

小A 和 小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏，请返回 小A 猜对了几次？

输入的guess数组为 小A 每次的猜测，answer数组为 小B 每次的选择。guess和answer的长度都等于3。

guess 的长度 = 3
answer 的长度 = 3
guess 的元素取值为 {1, 2, 3} 之一。
answer 的元素取值为 {1, 2, 3} 之一。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/guess-numbers
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

方法一：
int game(int* guess, int guessSize, int* answer, int answerSize){
    int ans = 0;
    for(int i = 0;i < 3;i++){
        ans += (guess[i]==answer[i])? 1:0;
    }
    return ans;
}
方法二：
int game(int* guess, int guessSize, int* answer, int answerSize){
    int count = 0;
    for(int i=0;i<answerSize;i++){ 
        if(answer[i]==guess[i])
            ++count;
    }
    return count;
}

九、LCP 06. 拿硬币 - 力扣（LeetCode） (leetcode-cn.com)

桌上有 n 堆力扣币，每堆的数量保存在数组 coins 中。我们每次可以选择任意一堆，拿走其中的一枚或者两枚，求拿完所有力扣币的最少次数。

示例 1：

输入：[4,2,1]

输出：4

解释：第一堆力扣币最少需要拿 2 次，第二堆最少需要拿 1 次，第三堆最少需要拿 1 次，总共 4 次即可拿完。

示例 2：

输入：[2,3,10]

输出：8

限制：

1 <= n <= 4
1 <= coins[i] <= 10

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/na-ying-bi
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

方法一：
int minCount(int* coins, int coinsSize){
    int count = 0;
    for(int i = 0;i<coinsSize;i++){
        count += (coins[i]+1)/2;
    }
    return count;
}
方法二：
int minCount(int* coins, int coinsSize){
    int count = 0;
    for(int i = 0; i<coinsSize;i++)
        count +=((coins[i]+1)>>1);
        return count;
}