生成一个数组

Question

要求：
1.数组长度：100*3//100条长度为3的int型数组
2.每个元素在（-20，20）之间，随机
3.每组的3个元素不能重复或者互为相反数，比如1，1，2和1，-1，2是不被允许的
4，100组数据里任意两组不能重复或者完全取反，比如不能同时出现两组数据都是“ 1，2，3”，有1 2 3的话就不能同时出现-1 -2 -3。
就这样

Answer 1

http://topic.csdn.net/u/20100507/13/dcfbbc2f-c4f3-4e52-a30a-f1b195b6d40b.html
整个大算法都能出来了，就是这个数组，没有特别明确的思路

Answer 2

写个类，里面就一个数组，重写equals，用集合保存，保存期间根据contains判断是否重复，不重复往里面插入，再随便拿100个出来问题是怎么才方便生成的都放到那个类里面，而且是符合LZ的要求的

Answer 3

哦，再不行，直接来个set，直接生成直接往里面插，不过可能生成的时间要长一点，等生成完了100个，再把每个对象生成一个数组

Answer 4

set 效率也不高
这里最好还是自己写算法
直接用API怕是很慢

Answer 5

呵呵 上个月的时候写分割字符串的时候我还写了一堆equals呢
结果一个split就解决了
新手的悲哀啊

Answer 6

用ArrayList试了下，原先使用set，想少个判断，后来由于不敢确定set排序规则，改成List,多了一个判断，一个排序。    public static void main(String[] args) {        List<List<Integer>> list1 = new ArrayList<List<Integer>>();
        int[][] arr = new int[100][3];
        Random r = new Random();
        while (list1.size()<100) {
            List<Integer> list2 = new ArrayList<Integer>();
            List<Integer> list3 = new ArrayList<Integer>();
            while (list2.size()<3) {
                int i = r.nextInt(21);
                if (r.nextBoolean()) {
                    i = -i;
                }
                if (!list2.contains(-i) && !list2.contains(i)) {
                    list2.add(i);
                    list3.add(-i);
                }
            }
            Collections.sort(list2);
            Collections.sort(list3);
            if (!list1.contains(list3) && !list1.contains(list2)) {
                list1.add(list2);
            }             
        }        for (int i = 0; i < list1.size(); i++) {
            List<Integer> lt = list1.get(i);
            for (int j = 0; j < lt.size(); j++) {
                arr[i][j] = lt.get(j);
            }
        }
        
        
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }

Answer 7

查了下，set应该可以，hashset中，相同的值，排序是一样的，那样可以省略点判断
    public static void main(String[] args) {        Set<Set<Integer>> set1 = new HashSet<Set<Integer>>();
        int[][] arr = new int[100][3];
        Random r = new Random();
        while (set1.size()<100) {
            Set<Integer> set2 = new HashSet<Integer>();
            Set<Integer> set3 = new HashSet<Integer>();
            while (set2.size()<3) {
                int i = r.nextInt(21);
                if (r.nextBoolean()) {
                    i = -i;
                }
                if (!set2.contains(-i)) {
                    set2.add(i);
                    set3.add(-i);
                }
            }            if (!set1.contains(set3)) {
                set1.add(set2);
            }             
        }        int idx1=0;
        for (Set<Integer> lt:  set1) {
            int idx2=0;
            for (Integer val:lt) {
                arr[idx1][idx2] = val;
                idx2++;
            }
            idx1++;
        }
        
        
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }

Answer 8

刚才开会去了
和同事讨论了半天这个问题
如果弄伪随机的话就可以比较快的构造了
上边用 set  进行去重也是可以
不过Java api 的效率一般是比较低的