数组移动跳跃

/*
我的想法，每次记录该位置的值加上下标是否能小于0或者大于数组长度，
和值在数组内的时候，将这个和值作为下一个计算的数组下标，同时将上一个计算过的数组值赋值MAX_value，
当这个下标下的数组值等于MAX的时候，跳出循环，表明不能跳出数组
*/

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        String str = input.nextLine();
        //取出数组
        String[] str1 = str.substring(1,str.length()-1).split(",");
        //赋值给整型数组
        int[] arr = new int[str1.length];
        for(int i = 0;i<str1.length;i++)
            arr[i] = Integer.parseInt(str1[i]);
        
        int index = 0;//记录下标
        while(index<arr.length){
            if(arr[index]!=Integer.MAX_VALUE){
                if(arr[index]+index<0||arr[index]+index>=arr.length){//数组越界了
                    System.out.println(true);
                    return;
                }else{//数组还没有越界
                    int temp = arr[index];//先把这个值保存一下
                    arr[index] = Integer.MAX_VALUE;//将这个访问过的值标记起来
                    index = temp+index;//下一个坐标等于下标与对应的数组值的和
                }
            }else{
                System.out.println(false);
                return;
            }
        }
        
        
    }
}

import java.util.*;
import java.io.*;

public class Main{
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = br.readLine();
        String[] strs = str.substring(1, str.length()-1).split(",");
        br.close();
 
        int[] arr = new int[strs.length];
        for (int i = 0; i < strs.length; i++){
            arr[i] = Integer.parseInt(strs[i]);
        }
        boolean flag = true;
        Map<Integer,Integer> map = new HashMap<>();
        int i = 0;
        int temp = arr[0];
        i += temp;
        map.put(0,1);
        map.put(i,1);
        while(i >= 0 && i < arr.length){
            temp = arr[i];
            i = i + temp;
            if(map.get(i) == null){
                map.put(i,1);
            }else{
                flag = false;
                break;
            }
        }
        System.out.println(flag);
    }
}

import java.util.LinkedList;

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String[] strings = sc.nextLine().replace("[", "").replace("]", "").split(",");
        int[] ints = new int[strings.length];
        for(int i = 0; i < ints.length; ++i){
            ints[i] = Integer.parseInt(strings[i].trim());
        }
          boolean a=true;
        if(ints.length==1){
            if (ints[0] == 0) {
                 a=false;
            }
        }else{
        LinkedList<Integer> ints1=new LinkedList<>();
        int i=0;
        while (i>=0&&i<ints.length){
            if(ints1.contains(i)){
                a= false;
                break;
            }else {
                ints1.add(i);
                i=i+ints[i];
            }
        }
        }
         System.out.println(a);
    }
}

//关键点一: 处理入参，这里是直接输入一个字符串(表示数组)，需要进行拆分转化为数组
//关键点二: 越界的条件是当前元素下标加上元素值，如果小于0或者大于等于数组长度，就越界，返回true; 
//         永不越界条件是当前元素下标加上元素值之后，跳转到之前已经访问过的元素下标，构成死循环，返回false
//辅助: 构建一个辅助数组，用于标记已经访问过的元素      
import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String[] strings = sc.nextLine().replace("[", "").replace("]", "").split(",");
        int[] nums = new int[strings.length];
        for(int i = 0; i < nums.length; ++i){
            nums[i] = Integer.parseInt(strings[i].trim());
        }
        System.out.print(process(nums));
    }
    
    public static boolean process(int[] nums){
        if(nums == null || nums.length == 0)
            return false;
        //使用一个额外的数组记录当前元素是否已经被访问过，如果是就返回false
        int[] temp = new int[nums.length];
        for(int i = 0; i < nums.length;){
            if(temp[i] == 1)
                return false;
            int index = i + nums[i];
            if(index < 0 || index >= nums.length)
                return true;
            temp[i] = 1;
            i = index;
        }
        return true;
    }
}

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        String[] strNumber = str.substring(1, str.length() - 1).split(",");
        int[] number = new int[strNumber.length];
        for (int i = 0; i < strNumber.length; i++) {
            number[i] = Integer.parseInt(strNumber[i]);
        }
        int index = 0, count = 0;
        while (count <= number.length) {
            count++;
            index += number[index];
            if (index < 0 || index >= number.length) {
                System.out.println("true");
                return;
            }
        }
        System.out.println("false");
    }
}