从标准输入中输入两组整数(每行不超过20个整数，每组整数中元素不重复)，求两组整数的异或集（合并两组整数，去掉在两组整数中都出现的整数后形成的集合）和交集（在两组整数中都出现的整数形成的集合），并按从

### 回答1：
小到大的顺序输出结果。

首先，我们需要将输入的两组整数存储到两个集合中，可以使用Python中的set数据类型。然后，我们可以使用set的交集和对称差集操作来求出两组整数的交集和异或集。

具体实现如下：

# 读入两组整数
set1 = set(map(int, input().split()))
set2 = set(map(int, input().split()))

# 求交集
intersection = sorted(list(set1 & set2))

# 求异或集
symmetric_difference = sorted(list(set1 ^ set2))

# 输出结果
print(" ".join(map(str, symmetric_difference)))
print(" ".join(map(str, intersection)))

其中，`set1 & set2`表示求两个集合的交集，`set1 ^ set2`表示求两个集合的对称差集（即异或集）。最后，我们将结果按从小到大的顺序输出即可。

### 回答2：
题目要求我们从标准输入中输入两组整数，每组整数不超过20个，且每个元素不重复。然后要求我们计算这两组整数的异或集和交集，并按从小到大的顺序输出结果。

首先，我们需要从标准输入中读取两行整数，然后将它们存储为两个集合(set)。我们可以使用C++ STL中的set来完成这个任务，因为set可以自动去重，而且可以直接对集合进行异或和交运算。

具体的过程如下：

1. 首先要包含相关的头文件：

#include <iostream>
#include <set>
using namespace std;

2. 然后定义两个set：

set<int> a, b;

3. 接下来从标准输入中读取两行整数，并将它们存储在a和b中：

int x;
while (cin >> x)
    a.insert(x);
while (cin >> x)
    b.insert(x);

4. 然后计算异或集和交集：

set<int> ans_xor, ans_and;
for (int x : a)
    if (!b.count(x))
        ans_xor.insert(x);
for (int x : b)
    if (!a.count(x))
        ans_xor.insert(x);
for (int x : a)
    if (b.count(x))
        ans_and.insert(x);

在这里，我们使用了set的count函数来判断一个元素是否在集合中出现过。

5. 最后将结果输出并按从小到大的顺序输出：

for (int x : ans_xor)
    cout << x << " ";
cout << endl;
for (int x : ans_and)
    cout << x << " ";
cout << endl;

完整代码如下：

### 回答3：
题意理解：

假设我们从标准输入中输入了两组整数，每行不超过20个整数，且每组整数中的元素不重复。我们需要从这两组整数中分别求出异或集和交集，并按从小到大的顺序排序输出结果。

异或集定义为，合并两组整数，去掉在两组整数中都出现的整数后，形成的集合。例如，如果第一组整数为{1, 2, 3}，第二组整数为{2, 3, 4}，则异或集为{1, 4}。

交集定义为，两组整数中都出现的整数所组成的集合。例如，如果第一组整数为{1, 2, 3}，第二组整数为{2, 3, 4}，则交集为{2, 3}。

回答：

题目要求我们实现输入两个不超过20个整数的集合，输出它们的异或集和交集。下面我们分别介绍如何实现这两个操作。

1. 异或集

异或集的实现非常简单，我们只需要将两个集合合并，并去掉那些在两个集合中都出现的元素，即可得到异或集。

我们可以使用集合(Set)来存储这些元素，因为Set会自动去重。具体实现步骤如下：

1) 从标准输入中读入两个集合，分别存储为set1, set2。

2) 声明一个新的集合xor_set。

3) 遍历set1中的每个元素，如果不在set2中出现，则将其添加到xor_set集合中。

4) 遍历set2中的每个元素，如果不在set1中出现，则将其添加到xor_set集合中。

5) 输出xor_set集合中的元素，这就是两个集合的异或集。

以下是Java代码实现：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        // 读入两个集合
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> set2 = new HashSet<>();
        String[] line1 = input.nextLine().split(" ");
        String[] line2 = input.nextLine().split(" ");
        for (int i = 0; i < line1.length; i++) {
            set1.add(Integer.parseInt(line1[i]));
        }
        for (int i = 0; i < line2.length; i++) {
            set2.add(Integer.parseInt(line2[i]));
        }

        // 计算异或集
        Set<Integer> xor_set = new HashSet<>();
        for (int x : set1) {
            if (!set2.contains(x)) {
                xor_set.add(x);
            }
        }
        for (int x : set2) {
            if (!set1.contains(x)) {
                xor_set.add(x);
            }
        }

        // 输出结果
        List<Integer> xor_list = new ArrayList<>(xor_set);
        Collections.sort(xor_list);
        for (int x : xor_list) {
            System.out.print(x + " ");
        }
        System.out.println();
    }
}

2. 交集

交集的实现也很简单，我们只需要遍历其中一个集合，检查其中的元素是否也在另一个集合中出现，如果是则把它加入到交集中。同样地，我们也可以使用Set来存储交集元素，因为Set会自动去重。具体实现步骤如下：

1) 从标准输入中读入两个集合，分别存储为set1, set2。

2) 声明一个新的集合intersection。

3) 遍历set1中的每个元素，如果也在set2中出现，则将其添加到intersection集合中。

4) 输出intersection集合中的元素，这就是两个集合的交集。

以下是Java代码实现：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        // 读入两个集合
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> set2 = new HashSet<>();
        String[] line1 = input.nextLine().split(" ");
        String[] line2 = input.nextLine().split(" ");
        for (int i = 0; i < line1.length; i++) {
            set1.add(Integer.parseInt(line1[i]));
        }
        for (int i = 0; i < line2.length; i++) {
            set2.add(Integer.parseInt(line2[i]));
        }

        // 计算交集
        Set<Integer> intersection = new HashSet<>();
        for (int x : set1) {
            if (set2.contains(x)) {
                intersection.add(x);
            }
        }

        // 输出结果
        List<Integer> inter_list = new ArrayList<>(intersection);
        Collections.sort(inter_list);
        for (int x : inter_list) {
            System.out.print(x + " ");
        }
        System.out.println();
    }
}

最后，我们需要按从小到大的顺序输出结果。为了实现这个功能，我们可以将所有元素存储到一个List中，并对这个List进行排序，然后输出排序后的结果。

完整的Java代码如下：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        // 读入两个集合
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> set2 = new HashSet<>();
        String[] line1 = input.nextLine().split(" ");
        String[] line2 = input.nextLine().split(" ");
        for (int i = 0; i < line1.length; i++) {
            set1.add(Integer.parseInt(line1[i]));
        }
        for (int i = 0; i < line2.length; i++) {
            set2.add(Integer.parseInt(line2[i]));
        }

        // 计算异或集
        Set<Integer> xor_set = new HashSet<>();
        for (int x : set1) {
            if (!set2.contains(x)) {
                xor_set.add(x);
            }
        }
        for (int x : set2) {
            if (!set1.contains(x)) {
                xor_set.add(x);
            }
        }

        // 输出异或集
        List<Integer> xor_list = new ArrayList<>(xor_set);
        Collections.sort(xor_list);
        for (int x : xor_list) {
            System.out.print(x + " ");
        }
        System.out.println();

        // 计算交集
        Set<Integer> intersection = new HashSet<>();
        for (int x : set1) {
            if (set2.contains(x)) {
                intersection.add(x);
            }
        }

        // 输出交集
        List<Integer> inter_list = new ArrayList<>(intersection);
        Collections.sort(inter_list);
        for (int x : inter_list) {
            System.out.print(x + " ");
        }
        System.out.println();
    }
}