java算法编程题：list集合取数

一、现有一个list集合，list里存有10个数，设置一个起始点，一个间隔数，总共取几个数，如已取到的数就跳过，循环取。
例如：list[1,2,3,4,5,6,7,8,9,10]，起始点是1（该数算第一个取数），间隔数为2，总共取10个数。第一个值为1，第二值为4，第三个值为7，第四个值为10，第五个值为3，第六个为6，第七个数为9，第八个值为2，第九个值为5，第十个值为8
二、现有一个list集合，list里存有10个数，设置一个起始点，一个步长数，总共取几个数，如已取到的数就删除，循环取。
例如：list[1,2,3,4,5,6,7,8,9,10]，起始点是1（该数算第一个取数），步长数为2，总共取10个数。第一个值为1，第二值为3，第三个值为5，第四个值为7，第五个值为9，第六个为2，第七个数为6，第八个值为10，第九个值为8，第十个值为4

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.Scanner;

/**
 * 1.现有一个list集合，list里存有10个数，设置一个起始点，一个间隔数，总共取几个数，如已取到的数就跳过，循环取。
 * 示例：
 * list[1,2,3,4,5,6,7,8,9,10]，起始点是1（该数算第一个取数），间隔数为2，总共取8个数。
 * 第一个值为1，第二值为4，第三个值为7，第四个值为10，第五个值为3，第六个为6，第七个数为9，第八个值为2
 * 
 * 2.现有一个list集合，list里存有10个数，设置一个起始点，一个步长数，总共取几个数，如已取到的数就删除，循环取。
 * 示例：
 * list[1,2,3,4,5,6,7,8,9,10]，起始点是1（该数算第一个取数），步长数为2，总共取8个数。
 * 第一个值为1，第二值为3，第三个值为5，第四个值为7，第五个值为9，第六个为2，第七个数为6，第八个值为10
 * 
 * @author zql
 *
 */
public class Test {
	
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		List<Integer> list2 = new ArrayList<Integer>();
		Random r = new Random();
		int temp = 0;
		int[] oriArr = new int[10];
		for (int i = 0; i < 10; i++) {
			temp = r.nextInt(100);
			oriArr[i] = temp;
			list.add(temp);
			list2.add(temp);
		}
		Scanner in = new Scanner(System.in);
		System.out.println("请输入起始点：");
		int start = in.nextInt();
		while(start == 0) {
			System.out.println("起始点不能为0，请重新输入：");
			start = in.nextInt();
		};
		System.out.println("请输入间隔（步长）数：");
		int poor = in.nextInt();
		System.out.println("总共取几个数（1-10）：");
		int count = in.nextInt();
		while(!(count > 0 && count < 11)) {
			System.out.println("请重新输入总共取几个数（1-10）：");
			count = in.nextInt();
		};
		
		System.out.println("原集合：" + Arrays.toString(oriArr));	
		System.out.println("题1取值：" + Arrays.toString(skipGetValue(start, poor, count, list)));
		System.out.println("题2取值：" + Arrays.toString(delGetValue(start, poor, count, list2)));
		in.close();
	}

	/**
	 * @param start 起始点
	 * @param poor 间隔数
	 * @param count 总共取几个数
	 * @param list list集合
	 * @return
	 */
	public static int[] skipGetValue(int start, int poor, int count, List<Integer> list) {
		int size = list.size();
		if (start < 0) {
			// 当起始点小于0并且取模等于0，实际上等价于起始点为1；当起始点小于0并且取模不等于0，
			// 实际上等价于起始点为取模值加上集合大小再加上1，举个例子，当起始点为-2时，实际起始
			// 点应该为9，计算过程：-2 + 10 + 1
			start = start % size == 0 ? 1 : (start % size + size +1);
		} else if (start > 0) {
			// 当起始点大于0并且取模等于0，实际上等价于起始点为集合的大小
			start = start % size == 0 ? size : (start % size);
		}
		int[] result = new int[count];
		int rL = count;
		boolean bl = true;
		int poors = poor;
		while (count > 0) {
			for (int i = 0; i < size; i++) {
				if (!bl && count != 0) {
					poors--;
					// list.get(i) != null跳过取到的数
					if (poors < 0 && list.get(i) != null) {
						poors = poor;
						result[rL - count] = list.get(i);
						list.set(i, null);
						count--;
					}
					// 起始点
				} else if (i == start - 1 && bl) {
					result[rL - count] = list.get(i);
					// 已取到的数设为null
					list.set(i, null);
					count--;
					bl = false;
				}
			}
		}
		return result;
	}
	
	/**
	 * @param start 起始点
	 * @param len 步长数
	 * @param count 总共取几个数
	 * @param list list集合
	 * @return
	 */
	public static int[] delGetValue(int start, int len, int count, List<Integer> list) {
		if (start < 0) {
			// 当起始点小于0并且取模等于0，实际上等价于起始点为1；当起始点小于0并且取模不等于0，
			// 实际上等价于起始点为取模值加上集合大小再加上1，举个例子，当起始点为-2时，实际起始
			// 点应该为9，计算过程：-2 + 10 + 1
			start = start % list.size() == 0 ? 1 : (start % list.size() + list.size() +1);
		}
		int[] result = new int[count];
		int index = 0;
		while (list.size() > 0) {
			if (index == count) {
	            break;
	        }
			start = start % list.size() == 0 ? list.size() : (start % list.size());
			start--;
			
			result[index++] = list.get(start);
            list.remove(start);
            
            // 被除数不能为0，如果不加判断，当list.size()等于0时，会抛出 java.lang.ArithmeticException: / by zero异常
            if (list.size() > 0) {
            	start = (start + len) % list.size();
            }
		}
		return result;
	}
}