（一）编程实现文件合并和去重操作
任务描述

本关任务：编程实现文件合并和去重操作。
相关知识

为了实现文件的合并去重，我们首先要知道文件中都有些什么，将文件内容进行“拆解”，映射（Map）到不同节点；然后在通过归约（Reduce）去除重复部分。

Map过程
用法如下：

重载map函数，直接将输入中的value复制到输出数据的key上
 public static class Map extends Mapper<Object, Text, Text, Text>
 {}

Reduce过程

重载reduce函数，直接将输入中的key复制到输出数据的key上
 public static class Reduce extends Reducer<Text,
 Text, Text, Text>{}

编程要求

对于两个输入文件，即文件A和文件B，请编写MapReduce程序，对两个文件进行合并，并剔除其中重复的内容，得到一个新的输出文件C。

为了完成文件合并去重的任务，你编写的程序要能将含有重复内容的不同文件合并到一个没有重复的整合文件，规则如下：
第一列按学号排列；
学号相同，按x,y,z排列。

测试说明

程序会对你编写的代码进行测试：

输入已经指定了测试文本数据：需要你的程序输出合并去重后的结果。

下面是输入文件和输出文件的一个样例供参考。

输入文件A的样例如下：
20170101 x
20170102 y
20170103 x
20170104 y
20170105 z
20170106 x

输入文件B的样例如下：
20170101 y
20170102 y
20170103 x
20170104 z
20170105 y

根据输入文件A和B合并得到的输出文件C的样例如下：
20170101 x
20170101 y
20170102 y
20170103 x
20170104 y
20170104 z
20170105 y
20170105 z
20170106 x

代码如下：
package com.chenbo.cn.mapreduce;

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.util.GenericOptionsParser;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat; 

public class Merge {

    /**
     * @param args
     * 对A,B两个文件进行合并，并剔除其中重复的内容，得到一个新的输出文件C
     */
    //在这重载map函数，直接将输入中的value复制到输出数据的key上 注意在map方法中要抛出异常：throws IOException,InterruptedException
    public static class Map extends Mapper<Object, Text, Text, Text> {  
        private static Text text = new Text();
        public void map(Object key, Text value, Context content) throws IOException, InterruptedException {  

            text = value;  
            content.write(text, new Text(""));  
        }  
    }  
    //在这重载reduce函数，直接将输入中的key复制到输出数据的key上  注意在reduce方法上要抛出异常：throws IOException,InterruptedException
        public static class Reduce extends Reducer<Text, Text, Text, Text> {  
        public void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {  
            context.write(key, new Text(""));  
        }  
    }

        public static void main(String[] args) throws Exception{

        // TODO Auto-generated method stub
        Configuration conf = new Configuration();
        conf.set("fs.defaultFS","hdfs://192.168.159.130:8020");
        String[] otherArgs = new String[]{"input","output"}; /* 直接设置输入参数 */
       if (otherArgs.length != 2) {
            System.err.println("Usage: wordcount <in> <out>");
            System.exit(2); 
            }
        Job job = Job.getInstance(conf,"Merge and duplicate removal");
        job.setJarByClass(Merge.class);
        job.setMapperClass(Map.class);
        job.setCombinerClass(Reduce.class);
        job.setReducerClass(Reduce.class); 
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
        FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}




（二）编写程序实现对输入文件的排序**
任务描述

本关任务：编写程序实现对输入文件的排序。
相关知识

为了实现文件的整合排序，我们首先要知道文件中都有些什么，将文件内容进行“拆解”，映射（Map）到不同节点；然后在通过归约（Reduce）的过程中进行排序输出。
Map过程

1、 输入多个文件，每个文件中的每行内容均为一个整数；

2、map函数读取输入中的value，将其转化成IntWritable类型，最后作为输出key。
用法如下：
public static class Map extends Mapper<Object, Text, IntWritable, IntWritable>{
    private static IntWritable data = new IntWritable();
    }

Reduce过程

1、reduce函数将map输入的key复制到输出的value上；

2、根据输入的value-list中元素的个数决定key的输出次数,定义一个全局变量line_num来代表key的位次。
用法如下：
  public static class Reduce extends Reducer<IntWritable, IntWritable, IntWritable, IntWritable>{
    private static IntWritable line_num = new IntWritable(1);
    }

返回Partiton ID
1、自定义Partition函数，此函数根据输入数据的最大值和MapReduce框架中Partition的数量获取将输入数据按照大小分块的边界；

2、 根据输入数值和边界的关系返回对应的Partiton ID。
    public static class Partition extends Partitioner<IntWritable, IntWritable>{
    public int getPartition(IntWritable key, IntWritable value, int num_Partition){
    int Maxnumber = 65223;//int型的最大数值
    }
}

编程要求
为了完成合并文件并排序的功能，你编写的程序要能将整合排序后的结果输出，规则如下：

现在有多个输入文件，每个文件中的每行内容均为一个整数。要求读取所有文件中的整数，进行升序排序后，输出到一个新的文件中;
输出的数据格式为每行两个整数，第一个数字为第二个整数的排序位次，第二个整数为原待排列的整数。

测试说明

程序会对你编写的代码进行测试：

下面是输入文件和输出文件的一个样例供参考。

输入文件1的样例如下：

33

37

12

40

输入文件2的样例如下：

4

16

39

5

输入文件3的样例如下：

1

45

25

根据输入文件1、2和3得到的输出文件如下：

1 1

2 4

3 5

4 12

5 16

6 25

7 33

8 37

9 39

10 40

11 45

代码如下：
package com.chenbo.cn.mapreduce;

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Partitioner;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;


public class MergeSort {

    /**
     * @param args
     * 输入多个文件，每个文件中的每行内容均为一个整数
     * 输出到一个新的文件中，输出的数据格式为每行两个整数，第一个数字为第二个整数的排序位次，第二个整数为原待排列的整数
     */
    //map函数读取输入中的value，将其转化成IntWritable类型，最后作为输出key
    public static class Map extends Mapper<Object, Text, IntWritable, IntWritable>{

        private static IntWritable data = new IntWritable();
        public void map(Object key, Text value, Context context) throws IOException,InterruptedException{
            /********** Begin **********/
        String line = value.toString();
        data.set(Integer.parseInt(line));
        context.write(data, new IntWritable(1));
            /********** End **********/

        }
    }

    //reduce函数将map输入的key复制到输出的value上，然后根据输入的value-list中元素的个数决定key的输出次数,定义一个全局变量line_num来代表key的位次
    public static class Reduce extends Reducer<IntWritable, IntWritable, IntWritable, IntWritable>{
        private static IntWritable line_num = new IntWritable(1);

        public void reduce(IntWritable key, Iterable<IntWritable> values, Context context) throws IOException,InterruptedException{
            /********** Begin **********/
           for(IntWritable num : values) {
             context.write(line_num, key);
             line_num = new IntWritable(line_num.get() + 1);
    }
            /********** End **********/
  }
}

    //自定义Partition函数，此函数根据输入数据的最大值和MapReduce框架中Partition的数量获取将输入数据按照大小分块的边界，然后根据输入数值和边界的关系返回对应的Partiton ID
    public static class Partition extends Partitioner<IntWritable, IntWritable>{
        public int getPartition(IntWritable key, IntWritable value, int num_Partition){
            /********** Begin **********/
            int Maxnumber = 65223;//int型的最大数值
            int bound = Maxnumber / num_Partition + 1;
            int Keynumber = key.get();
            for(int i = 0; i < num_Partition; i++){
              if(Keynumber < bound * i && Keynumber >= bound * (i - 1)) {
                return i - 1;
      }
    }
            return -1 ;
            /********** End **********/

        }
    }

    public static void main(String[] args) throws Exception{
        // TODO Auto-generated method stub
        Configuration conf = new Configuration();
        conf.set("fs.defaultFS","hdfs://192.168.159.130:8020");
        String[] otherArgs = new String[]{"input","output"}; /* 直接设置输入参数 */
        if (otherArgs.length != 2) { 
            System.err.println("Usage: wordcount <in> <out>");
            System.exit(2); 
            }
        Job job = Job.getInstance(conf,"Merge and Sort");
        job.setJarByClass(MergeSort.class);
        job.setMapperClass(Map.class);
        job.setReducerClass(Reduce.class);
        job.setPartitionerClass(Partition.class);
        job.setOutputKeyClass(IntWritable.class);
        job.setOutputValueClass(IntWritable.class);
        FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
        FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);

    }
}



（三）对给定的表格进行信息挖掘**
任务描述

本关任务：对给定的表格进行信息挖掘。
相关知识

Map过程
1、 Map将输入文件按照空格分割成child和parent，然后正序输出一次作为右表，反序输出一次作为左表，需要注意的是在输出的value中必须加上左右表区别标志；

2、在Map阶段，将父子关系与相反的子父关系，同时在各个value前补上前缀-与+标识此key-value中的value是正序还是逆序产生的，之后进入context
public static class Map extends Mapper<Object, Text, Text, Text>{
   public void map(Object key, Text value, Context context) throws IOException,InterruptedException{
                String child_name = new String();
                String parent_name = new String();
    }
  }

Reduce过程
public static class Reduce extends Reducer<Text, Text, Text, Text>{
    public void reduce(Text key, Iterable<Text> values,Context context) throws IOException,InterruptedException{
                if(time == 0){   //输出表头
                    context.write(new Text("grand_child"), new Text("grand_parent"));
                    time++;
                }
    }
 }

编程要求

为了完成信息挖掘的任务，你编写的程序要能挖掘父子辈关系，给出祖孙辈关系的表格。规则如下：
孙子在前，祖父在后
孙子相同，祖父的名字按照A-Z排列

测试说明

程序会对你编写的代码进行测试：

下面给出一个child-parent的表格，要求挖掘其中的父子辈关系，给出祖孙辈关系的表格。
输入文件内容如下：

child parent

Steven Lucy

Steven Jack

Jone Lucy

Jone Jack

Lucy Mary

Lucy Frank

Jack Alice

Jack Jesse

David Alice

David Jesse

Philip David

Philip Alma

Mark David

Mark Alma

输出文件内容如下：

grandchild grandparent

Steven Alice

Steven Jesse

Jone Alice

Jone Jesse

Steven Mary

Steven Frank

Jone Mary

Jone Frank

Philip Alice

Philip Jesse

Mark Alice

Mark Jesse

代码如下：
package com.chenbo.cn.mapreduce;

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

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;

public class simple_data_mining {
    public static int time = 0;

    /**
     * @param args
     * 输入一个child-parent的表格
     * 输出一个体现grandchild-grandparent关系的表格 
     */
    //Map将输入文件按照空格分割成child和parent，然后正序输出一次作为右表，反序输出一次作为左表，需要注意的是在输出的value中必须加上左右表区别标志
    public static class Map extends Mapper<Object, Text, Text, Text>{
        public void map(Object key, Text value, Context context) throws IOException,InterruptedException{
            /********** Begin **********/
             String line = value.toString();
             String[] childAndParent = line.split(" ");
             List<String> list = new ArrayList<>(2);
              for (String childOrParent : childAndParent) {
                 if (!"".equals(childOrParent)) {
                     list.add(childOrParent);
                  } 
              } 
              if (!"child".equals(list.get(0))) {
                  String childName = list.get(0);
                  String parentName = list.get(1);
                  String relationType = "1";
                  context.write(new Text(parentName), new Text(relationType + "+"
                        + childName + "+" + parentName));
                  relationType = "2";
                  context.write(new Text(childName), new Text(relationType + "+"
                        + childName + "+" + parentName));
              }

            /********** End **********/
        }
    }

    public static class Reduce extends Reducer<Text, Text, Text, Text>{
        public void reduce(Text key, Iterable<Text> values,Context context) throws IOException,InterruptedException{
                /********** Begin **********/

                //输出表头
               if (time == 0) {
                context.write(new Text("grandchild"), new Text("grandparent"));
                time++;
            }

            //获取value-list中value的child
            List<String> grandChild = new ArrayList<>();
            //获取value-list中value的parent
            List<String> grandParent = new ArrayList<>();
                //左表，取出child放入grand_child
            for (Text text : values) {
                String s = text.toString();
                String[] relation = s.split("\\+");
                String relationType = relation[0];
                String childName = relation[1];
                String parentName = relation[2];
                if ("1".equals(relationType)) {
                    grandChild.add(childName);
                } else {
                    grandParent.add(parentName);
                }
            }

                //右表，取出parent放入grand_parent
               int grandParentNum = grandParent.size();
               int grandChildNum = grandChild.size();
               if (grandParentNum != 0 && grandChildNum != 0) {
                for (int m = 0; m < grandChildNum; m++) {
                    for (int n = 0; n < grandParentNum; n++) {
                        //输出结果
                    context.write(new Text(grandChild.get(m)), new Text(
                                grandParent.get(n)));
                    }
                }
            }

                /********** End **********/

        } 
    }
    public static void main(String[] args) throws Exception{
        // TODO Auto-generated method stub
        Configuration conf = new Configuration();
        conf.set("fs.defaultFS","hdfs://192.168.159.130:8020");
        String[] otherArgs = new String[]{"input","output"}; /* 直接设置输入参数 */
        if (otherArgs.length != 2) {
            System.err.println("Usage: wordcount <in> <out>");
            System.exit(2); 
            }
        Job job = Job.getInstance(conf,"Single table join");
        job.setJarByClass(simple_data_mining.class);
        job.setMapperClass(Map.class);
        job.setReducerClass(Reduce.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
        FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}




问题：
（一）编程实现文件合并和去重操作
出现了以下问题：
Permission denied: user=David, access=WRITE, inode="/user/David":chenbo:supe

解决方法：更改权限
[chenbo@hadoop hadoop]$ hadoop fs -chown -R David /

（二）编写程序实现对输入文件的排序
出现了以下问题：
Permission denied: user=David, access=WRITE, inode="/user/David":chenbo:supe

解决方法：更改权限
[chenbo@hadoop hadoop]$ hadoop fs -chown -R David /

（三）对给定的表格进行信息挖掘
1、问题：
Permission denied: user=David, access=WRITE, inode="/user/David":chenbo:supe

解决方法：更改权限
[chenbo@hadoop hadoop]$ hadoop fs -chown -R David /

2、问题：
java.lang.Exception: java.lang.IndexOutOfBoundsException: Index: 1, Size: 1

解决方法：索引超出范围，文件每行以空格隔开，不是\t

需求描述
（一）pyspark交互式编程

本作业提供分析数据data.txt，该数据集包含了某大学计算机系的成绩，数据格式如下所示：


			
Tom,DataBase,80

			
Tom,Algorithm,50

			
Tom,DataStructure,60

			
Jim,DataBase,90

			
Jim,Algorithm,60

			
Jim,DataStructure,80

			
……
			
		
请根据给定的实验数据，在pyspark中通过编程来计算以下内容：

（1）该系总共有多少学生；

（2）该系共开设了多少门课程；

（3）Tom同学的总成绩平均分是多少；

（4）求每名同学的选修的课程门数；

（5）该系DataBase课程共有多少人选修；

（6）各门课程的平均分是多少；

（7）使用累加器计算共有多少人选了DataBase这门课。

（二）编写独立应用程序实现数据去重

对于两个输入文件A和B，编写Spark独立应用程序，对两个文件进行合并，并剔除其中重复的内容，得到一个新文件C。本文给出门课的成绩（A.txt、B.txt）下面是输入文件和输出文件的一个样例，供参考。

输入文件A的样例如下：

20200101    x

20200102    y

20200103    x

20200104    y

20200105    z

20200106    z

输入文件B的样例如下：

20200101    y

20200102    y

20200103    x

20200104    z

20200105    y

根据输入的文件A和B合并得到的输出文件C的样例如下：

20200101    x

20200101    y

20200102    y

20200103    x

20200104    y

20200104    z

20200105    y

20200105    z

20200106    z

（三）编写独立应用程序实现求平均值问题

每个输入文件表示班级学生某个学科的成绩，每行内容由两个字段组成，第一个是学生名字，第二个是学生的成绩；编写Spark独立应用程序求出所有学生的平均成绩，并输出到一个新文件中。本文给出门课的成绩（Algorithm.txt、Database.txt、Python.txt），下面是输入文件和输出文件的一个样例，供参考。

Algorithm成绩：

小明 92

小红 87

小新 82

小丽 90

Database成绩：

小明 95

小红 81

小新 89

小丽 85

Python成绩：

小明 82

小红 83

小新 94

小丽 91

平均成绩如下：

    (小红,83.67)

    (小新,88.33)

    (小明,89.67)

    (小丽,88.67)

 

2.环境介绍

Spark概述：

Apache Spark是一个闪电般快速的实时处理框架。它进行内存计算以实时分析数据。由于 Apache Hadoop MapReduce 仅执行批处理并且缺乏实时处理功能，因此它开始出现。因此，引入了Apache Spark，因为它可以实时执行流处理，也可以处理批处理。

除了实时和批处理之外，Apache Spark还支持交互式查询和迭代算法。Apache Spark有自己的集群管理器，可以托管其应用程序。它利用Apache Hadoop进行存储和处理。它使用 HDFS （Hadoop分布式文件系统）进行存储，它也可以在 YARN 上运行Spark应用程序。

PySpark概述：

Apache Spark是用 Scala编程语言 编写的。为了用Spark支持Python，Apache Spark社区发布了一个工具PySpark。使用PySpark，您也可以使用Python编程语言中的 RDD 。正是由于一个名为 Py4j 的库，他们才能实现这一目标。

PySpark提供了 PySpark Shell ，它将Python API链接到spark核心并初始化Spark上下文。今天，大多数数据科学家和分析专家都使用Python，因为它具有丰富的库集。将Python与Spark集成对他们来说是一个福音。

操作系统：Ubuntu16.04

Spark版本：2.4.0

Python版本：3.4.3

3.数据来源描述

本实验提供的分析数据data.txt，该数据集包含了某大学计算机系的成绩，数据来源于学校教务系统后台数据库中学生所修课程以及成绩的存储数据，导出的数据通过python转换为txt文本格式的数据。对于文件A和B，数据主要来源于表格中的数据转化为txt格式。对于Algorithm.txt、Database.txt、Python.txt等文本数据，来源于通过网络爬虫工具在各大网络平台中收集获取。

4.数据上传及上传结果查看

实验数据准备：

1、将数据文件复制到/usr/local/spark/sparksqldata/目录下文件夹共享-r复制目录



5、数据处理过程描述

（一）pyspark交互式编程

输入pyspark开启spark


2、加载data.txt文件



3、查看数据共有多少行



4、去重查看数据的行数，发现于总行数不一致，所以文件存在重复的数据据



5、此时要将数据过滤得到一个没有重复的数据集，用于后面的数据的获取，避免重复数据对结果的影响



6、完成各项需求

（1）该系总共有多少学生；

a)按",“拆分数据，取每行数据的第一列

b)去掉重复的数据



（2）该系共开设了多少门课程；

a)拆分数据取每行第二列的元素

b)去除重复



（3）Tom同学的总成绩平均分是多少；

a)拆分数据后取名字为Tom的行

b)取得所有成绩

c) 计算出课程数量

d)求总成绩

e) 求得平均成绩



（4）求每名同学的选修的课程门数；

a)拆分数据后取每行的第一列并组成（姓名，1）

b) 学生姓名获得每名学生所选的课程数

c) 打印结果



（5）该系DataBase课程共有多少人选修；

a)取得课程为"DataBase"的学生姓名

b)去掉重复的学生

c)计算选修该课程的学生数量



（6）各门课程的平均分是多少；

a) 取得第二列和第三列数据，并且将第三列改为（成绩，1）

b) 按课程名求得课程总成绩以及选修课程的人数

c)求得各门课程的平均分



（7）使用累加器计算共有多少人选了DataBase这门课。

a)取课程名为"DataBase"的行

b)定义一个从0开始的累加器

c) 遍历res，每遍历一条数据累加器+1



（二）编写独立应用程序实现数据去重

假设/usr/local/spark/sparksqldata/目录是当前目录

1.在当前目录下创建一个merge.py的文件，用于编写程序代码



2.编写程序实现数据去重，并写入新文件



3.运行程序代码后会在当前目录下生成一个新文件夹，新文件夹内有重新写入的文件



4.查看经过去重后新写入的文件内容



 

（三）编写独立应用程序实现求平均值问题

假设/usr/local/spark/sparksqldata/目录是当前目录

1.在当前目录下创建一个avgScore.py的文件，用于编写程序代码



2.编写程序求得各同学得平均成绩



 3.运行程序后会在当前目录下生成一个新的文件夹，文件夹下存放着程序运行得结果



4.查看结果



 

6、经验总结

RDD 其实就是分布式的元素集合，在 Spark 中，所有对数据的操作无非是创建RDD、转换现有RDD、调用RDD操作进行求值。在这一切的背后，Spark 会自动将 RDD 中的数据分发到集群并行执行操作。

我认为在Spark编程中，如果我们在概念以及底层的原理上没有理解的话，只能停留在看懂代码的层面而不能真正实现自己的编写，在编写上就会有一定的难度。所以要争取通过大量的实践来提升自己的编程思维、形成编程能力。

通过此次实验，我逐步了解到大数据技术在不断地发展进步，大数据时代已全面开启。然而大数据技术是一个庞杂的知识体系，Spark作为基于内存的分布式计算框架，只是其中一种代表性技术。所以除了学习Spark以外，非常有必要建立对大数据技术体系的整体性认识，了解Spark和其他大数据技术之间的相互关系。从而不断扩展自己对于大数据技术的知识面，在以后的工作学习中能更好更深入的了解和发展。

MapReduce编程初级实践
1.通过实验掌握基本的MapReduce编程方法；

2.掌握用MapReduce解决一些常见的数据处理问题，包括数据去重、数据排序和数据挖掘等。
1.编程实现文件合并和去重操作
参考  MapReduce编程初级实践

记住要让A.txt和B.txt都放在 usr/local/hadoop/input 里面，然后确保 usr/local/hadoop 下面没有output这个文件

如下图所示：



1.上传文件到hadoop
hadoop fs -put scr dst
2.复制文件到hadoop
hadoop fs -copyFromLocal -f scr dst
3.删除hadoop的某个文件
hadoop fs -rm file
4.删除hadoop的某个文件及里面的文件和文件夹（递归删除）
hadoop fs -rm -r file

2. 编写程序实现对输入文件的排序
参考 MapReduce编程初级实践

记住要让1.txt和2.txt都放在 usr/local/hadoop/input 里面，然后确保 usr/local/hadoop 下面没有 output 这个文件
此处省略图片

图
3. 对给定的表格进行信息挖掘
参考  Hadoop实验——MapReduce编程

记住要让child-parent.txt都放在 usr/local/hadoop/input3 里面，然后确保 usr/local/hadoop 下面没有 output3 这个文件

此处也有图

图

题目：有1、2、3、4四个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？

程序分析：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去 掉不满足条件的排列。

程序源代码：

for i in range(1,5):

 for j in range(1,5):

  for k in range(1,5):

   if(i!=k) and (i!=j) and (j!=k):

    print(i*100+j*10+k)

 

题目：一个整数，它加上100和加上268后都是一个完全平方数，请问该数是多少？

程序分析：在10000以内判断，将该数加上100后再开方，加上268后再开方，如果开方后的结果满足如下条件，即是结果。请看具体分析：

程序源代码：

for i in range(10000):

 x=int(math.sqrt(i+100))

 y=int(math.sqrt(i+268))

 if(x*x==i+100)and (y*y==i+268):

  print (i)



 

题目：输入三个整数x,y,z，请把这三个数由小到大输出。

程序分析：我们想办法把最小的数放到x上，先将x与y进行比较，如果x>y则将x与y的值进行交换，然后再用x与z进行比较，如果x>z则将x与z的值进行交换，这样能使x最小。

程序源代码：

1=[]

for i in range(3):

 x=int(raw_input("integer:\n"))

 1.append(x) #append() 方法向列表的尾部添加一个新的元素

 1.sort() #sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数

print(1)