1.给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−231,  231 − 1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。

示例 1：

输入：x = 123
输出：321

class Solution {

    public int reverse(int x) {

        int res = 0;

        while(x!=0) {

            //每次取末尾数字

            int tmp = x%10;

            //判断是否 大于 最大32位整数

            if (res>214748364 || (res==214748364 && tmp>7)) {

                return 0;

            }

            //判断是否 小于 最小32位整数

            if (res<-214748364 || (res==-214748364 && tmp<-8)) {

                return 0;

            }

            res = res*10 + tmp;

            x /= 10;

        }

        return res;

    }

}          

循环的判断条件应该是while(x!=0)，无论正数还是负数，按照上面不断的/10这样的操作，最后都会变成0，所以判断终止条件就是!=0
 

假设有1147483649这个数字，它是小于最大的32位整数2147483647的，但是将这个数字反转过来后就变成了9463847411，这就比最大的32位整数还要大了，这样的数字是没法存到int里面的，所以肯定要返回0(溢出了)。
甚至，我们还需要提前判断
2.

给你一个下标从 0 开始的整数数组 enemyEnergies ，它表示一个下标从 0 开始的敌人能量数组。

同时给你一个整数 currentEnergy ，它表示你一开始拥有的能量值总量。

你一开始的分数为 0 ，且一开始所有的敌人都未标记。

你可以通过以下操作 之一 任意次（也可以 0 次）来得分：

• 选择一个 未标记 且满足 currentEnergy >= enemyEnergies[i] 的敌人 i 。在这个操作中：
  • 你会获得 1 分。
  • 你的能量值减少 enemyEnergies[i] ，也就是说 currentEnergy = currentEnergy - enemyEnergies[i] 。
• 如果你目前 至少 有 1 分，你可以选择一个 未标记 的敌人 i 。在这个操作中：
  • 你的能量值增加 enemyEnergies[i] ，也就是说 currentEnergy = currentEnergy + enemyEnergies[i] 。
  • 敌人 i 被标记 。

请你返回通过以上操作，最多 可以获得多少分。

示例 1：

输入：enemyEnergies = [3,2,2], currentEnergy = 2

输出：3

解释：

通过以下操作可以得到最大得分 3 分：

• 对敌人 1 使用第一种操作：points 增加 1 ，currentEnergy 减少 2 。所以 points = 1 且 currentEnergy = 0 。
• 对敌人 0 使用第二种操作：currentEnergy 增加 3 ，敌人 0 被标记。所以 points = 1 ，currentEnergy = 3 ，被标记的敌人包括 [0] 。
• 对敌人 2 使用第一种操作：points 增加 1 ，currentEnergy 减少 2 。所以 points = 2 且 currentEnergy = 1 ，被标记的敌人包括[0] 。
• 对敌人 2 使用第二种操作：currentEnergy 增加 2 ，敌人 2 被标记。所以 points = 2 ，currentEnergy = 3 且被标记的敌人包括 [0, 2] 。
• 对敌人 1 使用第一种操作：points 增加 1 ，currentEnergy 减少 2 。所以 points = 3 ，currentEnergy = 1 ，被标记的敌人包括 [0, 2] 。

  class Solution {

  public:

      long long maximumPoints(vector<int>& enemyEnergies, int currentEnergy) {

          int mn = ranges::min(enemyEnergies);

          if (currentEnergy < mn) {

              return 0;

          }

          long long s = reduce(enemyEnergies.begin(), enemyEnergies.end(), 0LL);

          return (currentEnergy + s - mn) / mn;

      }

  };

  设 enemyEnergies 中的最小值为 mn，元素和为 s。

  如果 currentEnergy<mn，那么操作一无法执行，无法得到任何分数，所以也无法执行操作二，返回 0。

  否则，操作顺序如下：

  对 mn 执行操作一，得到 1 分。
  对除了 mn 以外的敌人执行操作二，得到 s−mn 的能量。
  对 mn 执行操作一，直到能量不足。
  也可以理解为，先得到 s−mn 的能量，再不断对 mn 执行操作一，所以得分为

• （currentEnergy+s-mn)/mn
  3.
   

  给你一个整数数组 nums 和一个链表的头节点 head。从链表中移除所有存在于 nums 中的节点后，返回修改后的链表的头节点。

  示例 1：

  输入： nums = [1,2,3], head = [1,2,3,4,5]

  输出： [4,5]

  解释：

  

  移除数值为 1, 2 和 3 的节点。

  示例 2：

  输入： nums = [1], head = [1,2,1,2,1,2]

  输出： [2,2,2]

  解释：

  

  移除数值为 1 的节点。
   

  class Solution {

  public:

      ListNode* modifiedList(vector<int>& nums, ListNode* head) {

          unordered_set<int> st(nums.begin(), nums.end());

• //这行代码创建了一个名为st的unordered_set（无序集合）。unordered_set是C++标准库中的一种容器，它存储唯一的元素，且元素的顺序不重要（无序）。这里使用了一个迭代器区间nums.begin()到nums.end()来初始化unordered_set。这意味着，st将包含nums中所有不重复的整数元素。

          ListNode dummy(0, head);

• //这行代码创建了一个名为dummy的链表节点对象。链表节点在C++中通常用来构建链表数据结构。dummy节点的构造函数参数是(0, head)，这意味着它是一个带有两个参数的构造函数：第一个参数是一个整数0，第二个参数是一个指向链表头节点的指针head（假设head是已经定义的某个节点指针）。

          ListNode* cur = &dummy;

          while (cur->next) {

              if (st.contains(cur->next->val)) {

                  cur->next = cur->next->next; // 删除

              } else {

                  cur = cur->next; // 向后移动

              }

          }

          return dummy.next;

      }

  };

java总结
 

final 关键字可用于修饰类、变量和方法 ， 用于表示它修饰的类、方法和变量不可改变。 final 修饰变量时，表示该变量一旦获得了初始值就不可被改变.

final 既可以修饰成员变量， 也可以修饰局部变量、形参。 final 修饰的变量不可被改变， 一旦获得了初始值 ， 该 final 变量的值就不能被重新赋值。

变量

成员变量

对于 final 修饰的成员变量而言，一旦有了初始值，就不能被重新赋值，如果既没有在定义成员变量时指定初始值，也没有在初始化块、构造器中为成员变量指定初始值，

那么这些成员变量的值将一直是系统默认分配的 0、‘\uOOOO' 、 false 或 null ， 这些成员变量也就完全失去了存在的意义。

因此 Java 语 法规定 : final 修饰的成员变量必须由程序员显式地指定初始值。

归纳起来， final 修饰的类变量、实例变量能指定初始值的地方如下。

类变量 : 必须在静态初始化块中指定初始值或声明该类变量时指定初始值，而且只能在两个地方的其中之一指定。

实例变量:必须在非静态初始化块、声明该实例变量或构造器中指定初始值， 而且只能在三个 地方的其中之一指定。

局部变量

系统不会对局部变量进行初始化，局部变量必须由程序员显式初始化 。

因此使用 自final修饰局部变量时，既可以在定义时指定默认值，也可以不指定默认值。

如果 final 修饰的局部变量在定义时没有指定默认值，则可以在后面代码中对该 final 变量赋初始值， 但只能一次 ，不能重复赋值;

如果 final 修饰的局部变量在定义时己经指定默认值，则后面代码中不能在对该变量赋值

pub1ic c1ass Test
{
pub1ic void test(final int a ) 
{//不能对 fina1 修饰的形参赋值，下面语句非法a = 5;
}
pub1ic static void main(String[] args) 
{
//定义final局部变量时指定默认值,str 变量无法重新赋值
final String str = "hello" ; 
//下面赋值语句非法
str = " Java"; 
//定义final局部变量时没有指定默认值,d变量可被赋值一次
final double d ; 
//第一次赋初始值成功
d = 5.6; 
//对final变量重复赋值,下面语句非法
d = 3.4; 
}
}

引用变量

使用 final 修饰基本类型变量时，不能对基本类型变量重新赋值，因此基本类型变量不能被改变。 但对于引用类型变量而言 ，它保存的仅仅是一个引用，fina l 只保证这个引用类型变量所引用的地址不 会改变。

pub1ic c1ass Test
{
pub1ic static void main(String[] args)
{
//final修饰数组变量,iArr是一个引用变量
fina1 int[] iArr = {5,6,12,9}; 
//对数组元素进行排序，合法
Arrays.sort(iArr);  
//对数组元素赋值，合法
iArr[2] = - 8 ;  
//下面语句对 iArr 重新赋值，非法
iArr = null; 
//final修饰 Person变量，p 是一个引用变量
final Persoηp =new Person(45) ; 
//改变 Person对象的age实例变量，合法
p.setAge(23) ; 
//下面语句对 p 重新赋值，非法p = null; }}

使用 final 修饰的引用类型变量不能被重新赋值，但可以改变引用类型变 量所引用对象的内容 .

例如上面iArr 变量所引用的数组对象， final修饰后的 iArr变量不能被重新赋值， 但iArr所引用数组的数组元素可以被改变.

与此类似的是,p变量也使用了 fina l 修饰，表明 p 变量不能被重新赋值 , 但p变量所引用 Person 对象的成员变量的值可以被改变。

方法

final 修饰的方法不可被重写 ，如果出于某些原因，不希望子类重写父类的某个方法，则可以使用final修饰该方法。

public class Test
{
public final void test(){} 
}
class Sub extends Test
{
//下面方法定义将出现编译错误，不能重写 final 方法
public void test() {} 
}

用final 修饰一个 private访问权限的方法，依然可以在其子类中定义与该方法具有相同方法名、相同形参列表、相同返回值类型的方法，等同于重新写了个方法。此外被final修饰的方法可以进行重载。

类

final修饰的类不可以有子类.