倒排序
輸入：
id1 spark hadoop
id2 scala spark
id3 java hadoop spark
id4 scala java
id5 the spark
id6 the hadoop and spark
id7 hadoop Flink storm spark
輸出：
Flink id7
scala id2 id4
spark id1 id2 id3 id5 id6 id7
hadoop id1 id3 id6 id7
java id3 id4
and id6
storm id7
the id5 id6
程式碼（Scala版）：

package com.dt.spark.cores.scala



import org.apache.spark.{SparkContext, SparkConf}

import scala.collection.mutable



object InvertedIndex {
def main (args: Array[String]) {

val conf = new SparkConf().setAppName("inverted index").setMaster("local")
val sc = new SparkContext(conf)

val data = sc.textFile
 
("E:\\workspases\\data\\invertedIndex.txt")

val keydata = data.map(line => line.split("\t")).map(linetemp =>(linetemp(0),linetemp(1)))
val inverting = keydata.flatMap(file =>{
val list = new mutable.LinkedHashMap[String,String]()
val words = file._2.split(" ").iterator
while (words.hasNext)
{
list.put
 
(words.next(),file._1)
}
list
})
inverting.reduceByKey(_+" "+_).map(pari=>pari._1+"\t"+pari._2).foreach(println)
sc.stop()
}
}

中位數

package com.dt.spark.cores.scala

import org.apache.spark.{SparkContext, SparkConf}



object Median {

def main (args: Array[String]) {

val conf = new SparkConf().setAppName("Median").setMaster("local")
val sc = new SparkContext(conf)

val data = sc.textFile("E:\\workspases\\data\\Median.txt")

val words = data.flatMap(_.split(" ")).map(word => word.toInt)
val number = words.map(word =>(word/4,word)).sortByKey()
val pariCount = words.map(word => (word/4,1)).reduceByKey(_+_).sortByKey()
val count = words.count().toInt
var mid =0
if(count%2 != 0)
{
mid = count/2+1
}else
{
mid = count/2
}

var temp =0
var temp1= 0
var index = 0
val tongNumber = pariCount.count().toInt

var foundIt = false
for(i <- 0 to tongNumber-1 if !foundIt)
{
temp = temp + pariCount.collectAsMap()(i)
temp1 = temp - pariCount.collectAsMap()(i)
if(temp >= mid)
{
index = i
foundIt = true
}
}
val tonginneroffset = mid - temp1

val median = number.filter(_._1==index).takeOrdered(tonginneroffset)
sc.setLogLevel("ERROR")
println(median(tonginneroffset-1)._2)
sc.stop()

}
}

CountOnce
問題描述：
假設HDFS只儲存一個標號為ID的Block，每份資料儲存2個備份，這樣就有2個機器儲存了相同的資料。其中ID是小於10億的整數。若有一個數據塊丟失，則需要找到哪個是丟失的資料塊。
在某個時間，如果得到一個數據塊ID的列表，能否快速地找到這個表中僅出現一次的ID？即快速找出出現故障的資料塊的ID。
問題闡述：已知一個數組，陣列中只有一個數據是出現一遍的，其他資料都是出現兩遍，將出現一次的資料找出。
輸入：
5
3
2
2
3
5
7
6
6
9
9
10
11
16
11
10
16

輸出：
7

程式碼：

package com.dt.spark.cores.scala

import org.apache.spark.{SparkContext, SparkConf}


object CountOnce {

def main (args: Array[String]) {
val conf = new SparkConf().setAppName("CountOnce").setMaster("local")
val sc = new SparkContext(conf)

val data = sc.textFile("E:\\workspases\\data\\CountOnce.txt")
val word = data.map(line => line.toInt)
val result =word.reduce(_^_)
println(result)
}
}