快学scala第十五章习题答案

合集下载

快速入门Scala编程语言

快速入门Scala编程语言Scala编程语言是一种多范式编程语言，结合了面向对象编程和函数式编程的特点。

它的语法简洁优雅，适合用于大规模的软件开发项目。

本文将带你快速了解Scala编程语言。

一、Scala的基本语法1. 变量和常量：在Scala中，使用关键字`var`来声明一个可变的变量，使用关键字`val`来声明一个不可变的常量。

例如，`var x = 10`声明一个可变变量x，`val y = 5`声明一个不可变常量y。

2. 数据类型：Scala拥有丰富的数据类型，包括整数类型、浮点数类型、布尔类型、字符类型等。

例如，`Int`表示整数类型，`Double`表示浮点数类型，`Boolean`表示布尔类型，`Char`表示字符类型。

3. 控制流语句：Scala支持常见的控制流语句，如条件判断和循环。

例如，`if-else`语句用于条件判断，`for`循环用于迭代执行操作。

4. 函数：在Scala中，函数是一等公民，可以作为值进行传递和操作。

函数的定义使用关键字`def`，例如`def add(x: Int, y: Int): Int = x + y`定义了一个接受两个整数参数并返回它们的和的函数。

5. 类和对象：Scala是一种面向对象的语言，每个值都是一个对象。

类用于定义对象的蓝图，对象是类的实例。

通过使用`class`关键字定义类，使用`new`关键字来创建对象。

二、函数式编程特性Scala内置了许多函数式编程特性，使得函数的组合和操作更加简洁和灵活。

1. 高阶函数：Scala中的函数可以作为值进行传递和操作，因此可以使用函数作为参数或返回值。

这种函数接受其他函数作为参数或将函数作为返回值的函数称为高阶函数。

高阶函数可以极大地简化代码的编写和理解。

2. 不可变性：Scala鼓励使用不可变的数据结构和变量，在处理数据时避免副作用和数据竞争的发生。

不可变性使得代码更加安全和易于调试。

3. 模式匹配：模式匹配是一种强大的功能，用于根据数据的结构和属性进行分支处理。

百度答案

以上为参考答案，其他符合逻辑的方案可酌情给分
********************************** 测验结束 **********************************
}
}
int main() {
char a[100] = "abc"; int cnt[256] ;
foo(a, cnt);
return 0;
}
第二题算法与程序设计（40分）
1. 假设我们有rand(s, t)函数，可以返回[s,t]之间的随机小数。请问如何利用该函数在一个半径为R的圆内随机n个点，并给出相应的时间复杂度分析。（15分）
依次类推，第n-2个query被抽中的概率为m/(n-2)*(n-2)/(n-1)*(n-1)/n=m/n。
即：每一个query被抽中的概率均为m/n。
给分标准：
说出方法即可给分，错误的方法给0-5分，正确的方法给10分。
如果有相应的概率分析也加分，方法错误分析也错误给5分，方法错误分析正确给10分，方法正确分析也正确给15分。
参考答案：
假设一个边长为R的正方形把圆包住，那么可以调用rand(s, t)函数两次得到正方形内的随机点(x, y)。留下在圆内的随机点即可,这样可以保证随即概率相等。时间复杂度可以按照圆和正方形的面积比得到:
O(n*(πR^2)/R^2 )=O(n* π)
给分标准:
说出了错误的随机方法可适当给分，给出正确方法给10分，分析了时间复杂度和概率的再给5分。
参考答案：
虽然客户端的ID太多，无法放入到内存中，但是1分钟内请求服务器的ID却不会太多。可以根据这个条件进行设计。

快学Scala习题解答—第三章数组相关操作

快学Scala习题解答—第三章数组相关操作3 数组相关操作3.1 编写⼀段代码。

将a设置为⼀个n个随机整数的数组，要求随机数介于0(包括)和n(不包括)之间random和yield的使⽤Scala代码1. import scala.math.random2.3. def randomArray(n:Int)={4. for(i <- 0 until n) yield (random * n).toInt5. }6.7. println(randomArray(10).mkString(","))3.2 编写⼀个循环，将整数数组中相邻的元素置换。

⽐如,Array(1,2,3,4,5)经过置换后变为Array(2,1,4,3,5)对数组⽅法的使⽤Scala代码1. def reorderArray(arr:Array[Int]):Array[Int]={2. val t = arr.toBuffer3. for(i <- 1 until (t.length,2);tmp = t(i);j <- i - 1 until i){4. t(i) = t(j)5. t(j) = tmp6. }7. t.toArray8. }9.10. println(reorderArray(Array(1,2,3,4,5)).mkString(","))3.3 反复前⼀个练习，只是这⼀次⽣成⼀个新的值交换过的数组。

⽤for/yieldScala代码1. def reorderArray(arr:Array[Int]):Array[Int]={2. (for(i <- 0 until (arr.length,2)) yield if (i + 1 < arr.length) Array(arr(i + 1),arr(i)) else Array(arr(i))).flatten.toArray3. }4.5. println(reorderArray(Array(1,2,3,4,5)).mkString(","))3.4 给定⼀个整数数组，产⽣⼀个新的数组，包括元数组中的全部正值，以原有顺序排列，之后的元素是全部零或负值。

cSTL容器适配器习题答案

cSTL容器适配器习题答案1．概念填空题1.1STL是泛型程序设计的一个良好的范例。

标准C++类库包含的组件既支持面向对象程序设计的设计与编程，又支持泛型程序设计设计。

标准组件对两种设计方法的支持赋予了C++类库复合或双重特性。

1.2构建STL的框架最关键的4个组件是容器、迭代器、算法和函数对象这里算法处于核心地位，迭代器如同算法和容器之间的桥梁，算法通过迭代器从容器中获取元素，然后将获取的元素传递给特定的函数对象进行的操作，最后将处理后的结果储存到容器中。

1.3在C++标准库中包括7种基本容器：向量、双端队列、列表、集合、多重集合、映射和多重映射等。

这7种容器可以分为2种基本类型：顺序和关联1.43种STL容器适配器是栈、队列和优先级队列2．简答题2.1简述STL中迭代子与C++指针的关系与异同点。

2.2在C++标准模板库中，2种容器类型是什么？5种主要迭代器是什么？3种容器适配器是什么？STL算法通过什么来间接访问容器元素？2.3什么是函数对象它的作用是什么，通常用在什么地方如何使用？3．编程题3.1在C++标准模板库中，栈类(tack)的成员函数tack::puh()在栈顶端添加元素，tack：pop()从非空栈的栈顶端中删除一个元素，tack：empty()判断栈是否为空，tack：：top()返回非空栈的栈顶元素，tack::ize()返回栈中元素的个数，请构造一个int类型的栈，然后对这个栈调用以上几个函数，体会栈这种数据结构的特点及其成员函数的用法。

#include#include#includeuingnamepacetd;intmain(){inti,a[5]={2,3,5,7,11};tack>ta_vec;for(i=0;i<5;i++){cout<cout<cout<while(!ta_vec.empty()){cout<cout<3.2实际应用中，双端队列比普通队列更加常用。

scala课后习题答案

scala课后习题答案Scala课后习题答案Scala是一种多范式编程语言，它结合了面向对象编程和函数式编程的特性。

在学习Scala的过程中，做课后习题是非常重要的，它可以帮助我们巩固所学的知识，提高编程能力。

下面我们来看一些常见的Scala课后习题及其答案。

1. 编写一个函数，计算给定数组的平均值。

```scaladef average(arr: Array[Int]): Double = {if (arr.isEmpty) 0else arr.sum.toDouble / arr.length}```2. 编写一个函数，将给定的字符串列表连接成一个字符串。

```scaladef concatStrings(strings: List[String]): String = {strings.mkString}```3. 编写一个函数，找出给定数组中的最大值和最小值。

```scaladef findMaxAndMin(arr: Array[Int]): (Int, Int) = {(arr.max, arr.min)}```4. 编写一个函数，将给定的整数列表按照奇偶分成两个列表。

```scaladef splitOddEven(nums: List[Int]): (List[Int], List[Int]) = {nums.partition(_ % 2 == 0)}```5. 编写一个递归函数，计算给定数字的阶乘。

```scaladef factorial(n: Int): Int = {if (n <= 1) 1else n * factorial(n - 1)}```以上是一些常见的Scala课后习题及其答案，通过做这些习题可以帮助我们更好地理解和掌握Scala编程语言。

希望大家在学习Scala的过程中能够多加练习，不断提升自己的编程能力。

快学scala第十章习题答案

11 特质11.1 java.awt.Rectangle类有两个很有用的方法translate和grow,但可惜的是像java.awt.geom.Ellipse2D这样的类没有。

在Scala中，你可以解决掉这个问题。

定义一个RenctangleLike特质,加入具体的translate和grow方法。

提供任何你需要用来实现的抽象方法,以便你可以像如下代码这样混入该特质:val egg = new java.awt.geom.Ellipse2D.Double(5,10,20,30) with RectangleLikeegg.translate(10,-10)egg.grow(10,20)使用自身类型使得trait可以操作x,yimport java.awt.geom.Ellipse2Dtrait RectangleLike{this:Ellipse2D.Double=>def translate(x:Double,y:Double){this.x = xthis.y = y}def grow(x:Double,y:Double){this.x += xthis.y += y}}object Test extends App{val egg = new Ellipse2D.Double(5,10,20,30) with RectangleLikeprintln("x = " + egg.getX + " y = " + egg.getY)egg.translate(10,-10)println("x = " + egg.getX + " y = " + egg.getY)egg.grow(10,20)println("x = " + egg.getX + " y = " + egg.getY)}11.2 通过把scala.math.Ordered[Point]混入java.awt.Point的方式，定义OrderedPoint类。

c++教材全部参考答案

(1) x=1，a=15，b=18，c=21(2) y=0，a=15，b=18，c=21
(3) x=1，a=15，b=18，c=22(4) y=1，a=15，b=18，c=21
2_15
(1) x=7（实型），a=7（整型）(2) x=7.873，a=7（整型）
(3) x=7（实型），y=7.873，a=7（整型）(4) x=7.5，a=25（整型），b=7（整型）
[返回]
第三章练习题P.6
3_1
c1=‘’’，c2=‘a’，c3=‘’’
3_2
10099
a
3_3
c1=‘a’，c2=‘b’，c3=‘c’
3_4
29183123
3_5
256400100
3_6
3333
[返回]
第四章练习题P.60
4_1
C++语句分为：说明语句、控制语句、函数调用语句、表达式语句、空语句和复合语句（也称块语句）六类。C++的基本程序结构分为：顺序结构、选择结构和循环结构三种。
合法的有：32767（整型）、35u（无符号整型）、3L（长整型）、0.0086e-32（实型）、‘\87’（字符型）、”Computer System”（字符串）、”a”（字符串）、’a’（字符型）、-0（整型）、+0（整型）、.5（实型）、-.567（实型）
2_2
定义：以英文字母、下划线开始的，由字母、下划线和数字组成的字符序列。
4_2
#include<iostream.h>
void main()
{int a,b,c;
cin>>a>>b;
a>b?(c=a):(c=b);

快学scala第十三章习题答案

val prices = List(5.0,20.0,9.95)
val quantities = List(10,2,1)
println((prices zip quantities) map { Function.tupled(_ * _) })
14.8编写一个函数。将Double数组转换成二维数组。传入列数作为参数。举例来说，Array(1,2,3,4,5,6)和三列，返回Array(Array(1,2,3),Array(4,5,6))。用grouped方法。
14.3编写一个函数，从一个整型链表中去除所有的零值。
def removeZero(nums : List[Int]):List[Int]={
nums.filter(_ != 0)
}
println(removeZero(List(3,5,0,2,7,0)))
14.4编写一个函数，接受一个字符串的集合，以及一个从字符串到整数值的映射。返回整型的集合，其值为能和集合中某个字符串相对应的映射的值。举例来说，给定Array("Tom","Fred","Harry")和Map("Tom"->3,"Dick"->4,"Harry"->5)，返回Array(3,5)。提示：用flatMap将get返回的Option值组合在一起
为什么这样做得不到正确答案？如果他用如下方式实现呢：
import scala.collection.JavaConversions.asScalaConcurrentMap
val frequencies:scala.collection.mutable.ConcurrentMap[Char,Int] = newjava.util.concurrent.ConcurrentHashMap[Char,Int]

快学scala第五章习题答案

6 类6.1 改进5.1节的Counter类,让它不要在Int.MaxValue时变成负数6.2 编写一个BankAccount类，加入deposit和withdraw方法，和一个只读的balance属性6.3 编写一个Time类，加入只读属性hours和minutes，和一个检查某一时刻是否早于另一时刻的方法before(other:Time):Boolean。

Time对象应该以new Time(hrs,min)方式构建。

其中hrs以军用时间格式呈现(介于0和23之间)6.4 重新实现前一个类中的Time类，将内部呈现改成午夜起的分钟数(介于0到24*60-1之间)。

不要改变公有接口。

也就是说，客户端代码不应因你的修改而受影响6.5 创建一个Student类，加入可读写的JavaBeans属性name(类型为String)和id(类型为Long)。

有哪些方法被生产？(用javap查看。

)你可以在Scala中调用JavaBeans的getter和setter方法吗？应该这样做吗？javap -c Student 后显示如下6.6 在5.2节的Person类中提供一个主构造器,将负年龄转换为06.7 编写一个Person类，其主构造器接受一个字符串，该字符串包含名字，空格和姓，如new Person("Fred Smith")。

提供只读属性firstName和lastName。

主构造器参数应该是var,val还是普通参数？为什么？必须为val。

如果为var，则对应的此字符串有get和set方法，而Person中的firstName和lastName为只读的,所以不能重复赋值。

如果为var则会重复赋值而报错6.8 创建一个Car类，以只读属性对应制造商，型号名称，型号年份以及一个可读写的属性用于车牌。

提供四组构造器。

每个构造器fc都要求制造商和型号为必填。

型号年份和车牌可选，如果未填，则型号年份为-1，车牌为空串。

《Scala编程》课程作业

《Scala编程》课程作业第⼀题、百元喝酒作业要求：每瓶啤酒2元，3个空酒瓶或者5个瓶盖可换1瓶啤酒。

100元最多可喝多少瓶啤酒？（不允许借啤酒）思路：利⽤递归算法，⼀次性买完，然后递归算出瓶盖和空瓶能换的啤酒数/*** @author DOUBLEXI* @date 2021/8/17 15:33* @description** 作业要求：每瓶啤酒2元，3个空酒瓶或者5个瓶盖可换1瓶啤酒。

100元最多可喝多少瓶啤酒？* （不允许借啤酒）思路：利⽤递归算法，⼀次性买完，然后递归算出瓶盖和空瓶能换的啤酒数*/object HundredBeer {/*** @param sumBeers 啤酒总数* @param bottle 剩余空瓶⼦数量* @param cap 剩余啤酒盖数量* @return 返回总啤酒总数*/def beer(sumBeers: Int, bottle: Int, cap: Int): Int = {println(s"啤酒总数：$sumBeers，剩余空瓶⼦：$bottle，剩余啤酒盖：$cap")// 递归边界条件if (bottle < 3 && cap < 5) return sumBeersvar b1 = bottle / 3 // 现有空瓶⼦能够兑换的啤酒数var b2 = bottle % 3 // 空瓶⼦兑换啤酒后，剩余的空瓶⼦var c1 = cap / 5 // 现有啤酒盖能够兑换的啤酒数var c2 = cap % 5 // 啤酒盖兑换啤酒后，剩余的空瓶⼦/*上⾯⼀顿兑换操作后，啤酒总数为：b1 + c1 + sumBeers剩余的空瓶⼦总数为：b1 + c1 + b2剩余的啤酒盖总数为：b1 + c1 + c2继续递归兑换*/beer(b1 + c1 + sumBeers, b1 + c1 + b2, b1 + c1 + c2)}def main(args: Array[String]): Unit = {var sumBeers: Int = 100 / 2 // 初始化啤酒总数var bottle, cap : Int = sumBeers // 初始化空瓶⼦数=啤酒盖数=啤酒总数val beers = beer(sumBeers, bottle, cap) // 递归求能够喝到的啤酒总数println(s"100元最多可以喝$beers 瓶啤酒")}}运⾏结果如下：第⼆题、⼈机猜拳1.1 作业需求1. 选取对战⾓⾊2. 开始对战，⽤户出拳，与对⼿进⾏⽐较，提⽰胜负信息3. 猜拳结束算分，平局都加⼀分，获胜加⼆分，失败不加分4 . 循环对战，当输⼊“n”时，终⽌对战，并显⽰对战结果5. 游戏结束后显⽰得分如下图所⽰：1.2 作业分析分析业务逻辑，抽象出类、类的属性和⽅法，如下：1. 创建⽤户类User，定义类的属性（name，score）和类的⽅法（showFist())2. 创建计算机类Computer，定义类的属性（name，score）和类的⽅法（showFist())3. 实现计算机随机出拳4. 创建游戏类Game，定义类的属性（甲⽅玩家、⼄⽅玩家、对战次数）5. 编写初始化⽅法、游戏开始⽅法1、编写⽤户类User/*** @author DOUBLEXI* @date 2021/8/17 16:45* @description*//*** ⽤户类User* @param name ⽤户名* @param score ⽤户得分*/class User(var name: String, var score: Int) {var draw: Int = 0 // 平局数var defeat: Int = 0 // 败局数var victory: Int = 0 // 胜局数// 让⽤户⾃⼰出拳，输⼊1.剪⼑ 2.⽯头 3.布def showFist(): Int = {var fist = scala.io.StdIn.readInt()while (fist != 1 && fist != 2 && fist != 3) {println("输⼊不合法，请重新输⼊")fist = scala.io.StdIn.readInt()}return fist}}2、编写电脑类Computer/*** @author DOUBLEXI* @date 2021/8/17 17:09* @description*//*** 电脑类* @param name 电脑名字*/class Computer(var name: String, var score: Int) {var draw: Int = 0 // 电脑平局数var defeat: Int = 0 // 电脑败局数var victory: Int = 0 // 电脑胜局数/*** 随机出拳，1-3* @return 返回⼀个1-3的数字*/def showFist(): Int = {scala.util.Random.nextInt(3) + 1}}3、编写游戏类Game/*** @author DOUBLEXI* @date 2021/8/17 17:11* @description*//*** 游戏类*/class Game {var user: User = _ // 定义玩家var computer: Computer = _ // 定义电脑var battleNum: Int = _ // 定义对战次数/*** 游戏初始化⽅法*/def gameInit(): Unit = {val motd ="""------------------欢迎进⼊游戏世界-----------------****************************************************猜拳开始*******************************************************""".stripMarginprintln(motd) // 打印游戏欢迎信息println("请选择对战⾓⾊：(1.刘备 2.关⽻ 3.张飞)") // ⽤户选择电脑的⾓⾊var roleNum = scala.io.StdIn.readInt()while (roleNum != 1 && roleNum != 2 && roleNum != 3) {println("没有这个选项，请重新输⼊！")roleNum = scala.io.StdIn.readInt()}val battleRole = roleNum match {case 1 => "刘备"case 2 => "关⽻"case 3 => "张飞"}println(s"你选择了与${battleRole}对战")user = new User("游客", 0) // 初始化玩家信息computer = new Computer(s"$battleRole", 0) // 初始化电脑信息battleNum = 0 // 初始化对战信息}/*** 游戏主程，游戏开始⽅法* 循环对战，直到输⼊n终⽌*/def startGame(): Unit = {var isExist = falsevar isStartNext: Char = 'y'// 循环对战while (!isExist) {battleNum += 1; // 对战次数+1// 玩家出拳println("请出拳！1.剪⼑ 2.⽯头 3.布")var userFist = user.showFist()userFist match {case 1 => println("你出拳：剪⼑")case 2 => println("你出拳：⽯头")case 3 => println("你出拳：布")}// 电脑出拳println(s"${}出拳！")var computerFist = computer.showFist()computerFist match {case 1 => println(s"${}出拳：剪⼑")case 2 => println(s"${}出拳：⽯头")case 3 => println(s"${}出拳：布")}// 调⽤judge⽅法，判断胜负judge(userFist, computerFist)// 根据⽤户输⼊判断是否开启下⼀轮游戏，n退出println("是否开始下⼀轮(y / n)")isStartNext = scala.io.StdIn.readChar()while (isStartNext != 'n' && isStartNext != 'N' && isStartNext != 'Y' && isStartNext != 'y') { println("您的输⼊不正确，请重新输⼊！")isStartNext = scala.io.StdIn.readChar()}if (isStartNext =='n'|| isStartNext == 'N') isExist = true}println("退出游戏！")// 打印得分成绩echoResult}* 判断猜拳胜负* @param userFist ⽤户出拳* @param computerFist 电脑出拳*/def judge(userFist: Int, computerFist: Int): Unit = {val judgeNum = userFist match {case 1 => if (computerFist == 1) 0 else if (computerFist == 2) -1 else 1case 2 => if (computerFist == 1) 1 else if (computerFist == 2) 0 else -1case 3 => if (computerFist == 1) -1 else if (computerFist == 2) 1 else 0}if (judgeNum == 0) {println("结果：和局！下次继续努⼒！")user.score += 1user.draw += 1computer.score += 1computer.draw += 1} else if (judgeNum == 1) {println("结果：恭喜，你赢啦！")user.score += 2user.victory += 1computer.defeat += 1} else {println("结果：你输了，下次继续努⼒！")user.defeat += 1computer.victory += 1}}/*** 打印得分成绩*/def echoResult(): Unit = {println("---------------------------------------------------------")println(s"${} VS ${}")println(s"对战次数${battleNum}次")println()println()println("姓名\t等分\t胜局\t和局\t负局")println(s"${}\t${user.score}\t\t${user.victory}\t\t${user.draw}\t\t${user.defeat}")println(s"${}\t${computer.score}\t\t${computer.victory}\t\t${computer.draw}\t\t${computer.defeat}") }}/*** 游戏主程⼊⼝*/object Game {def main(args: Array[String]): Unit = {val game = new Game // 定义⼀个游戏对象game.gameInit() // 游戏初始化println("要开始么？y/n")var isStart = scala.io.StdIn.readChar()while (isStart != 'Y' && isStart != 'y' && isStart != 'n' && isStart != 'N') {println("没有这个选项，请重新输⼊！")isStart = scala.io.StdIn.readChar()}// 开始游戏if (isStart == 'Y' || isStart == 'y') game.startGame}}运⾏结果如下：不合法输⼊：打印得分：第三题、⽤户位置时长统计现有如下数据需要处理：字段：⽤户ID，位置ID，开始时间，停留时长（分钟）4⾏样例数据：UserA,LocationA,8,60UserA,LocationA,9,60UserB,LocationB,10,60UserB,LocationB,11,80样例数据中的数据含义是：⽤户UserA，在LocationA位置，从8点开始，停留了60钟处理要求：1、对同⼀个⽤户，在同⼀个位置，连续的多条记录进⾏合并2、合并原则：开始时间取最早时间，停留时长累计求和答：算法如下：1、定义⼀个样例类，⽤于存储每个⽤户的浏览数据* 定义⼀个样例类：装载⽤户时长数据* @param userName ⽤户名* @param location ⽤户位置* @param startTime ⽤户开始浏览时间* @param duration ⽤户本次浏览时长*/case class UserInfo(userName:String, location:String, startTime:Int, duration:Int)2、在object主程序⾥，定义⼀个列表，⽤于存储各个⽤户的浏览信息。

1+x初级云计算习题库(附参考答案)

1+x初级云计算习题库（附参考答案）一、单选题（共50题，每题1分，共50分）1、下列选项当中,哪个是Nova创建安全组命令A、nova swap-createB、nova save-createC、nova flavor-createD、nova secgroup-create正确答案：D2、以下Cinder命令可以创建云硬盘的是?A、cinder volume createB、cinder volume-createC、cinder createD、cinder-create正确答案：C3、以下neutron命令中可以查询网络的列表信息的是?A、neutron agent-listB、neutron net-listC、neutron compute-listD、neutron network-list正确答案：B4、下列选项当中,查看磁盘空间占用应该使用下面那个命令?()A、dpB、ddC、dfD、du正确答案：C5、减少应用程序中频繁扩展的最简单方法是什么?例如,如果某个应用程序显示它在一小时内多次放大和缩小,那么您将如何减少看到的“上下”次数?A、通过主动循环设置计划时间以进行缩放,这样就不会一直出现。

B、增加冷却时间计时器,以便按比例缩小要求触发器的变化阈值更大。

C、更新CloudWatch以使用FIFO终止策略,仅终止按比例缩小的最早实例。

D、这些都不能改善问题。

正确答案：C6、下面关于ADocker Image说法错误的是?A、镜像是一个只读模板B、由Dockerfile文本描述镜像的内容C、镜像定义类似面向用户的类D、构建一个镜像实际就是安装.配置和运行的过程正确答案：C7、分布式系统由多台计算机组成,它们在地域上是.A、独立的B、聚合的C、分散的D、互联的正确答案：C8、下面关于Docker网络none模式说法错误的是?A、使用none模式,容器拥有自己的Network NamespaceB、容器没有网卡.IP.路由等信息C、可以直接使用宿主机的IP地址与外界通信D、容器只有lo回环网络,没有其他网卡正确答案：C9、Nginx使用的是什么模型?A、epollB、PerlC、RailsD、Perlbal正确答案：A10、下列选项当中,哪个是Neutron查询网络服务列表信息命令A、neutron network-showB、neutron network-listC、neutron agent-showD、neutron agent-list正确答案：D11、以下哪项需要自定义 CloudWatch 指标进行监控?A、内存使用B、CPU 使用C、磁盘读取操作D、网络正确答案：A12、SQL线程通过读取______文件中的日志,并解析成具体操作,来实现主从的操作一致,最终达到数据一致。

快学scala第七章习题答案

8 包和引入8.1 编写示例程序，展示为什么package com.horstmann.impatient不同于package compackage horstmannpackage impatient8.2 编写一段让你的Scala朋友们感到困惑的代码，使用一个不在顶部的com包这样可以吗？8.3 编写一个包random,加入函数nextInt():Int,nextDouble():Double,setSeed(seed:Int):Unit。

生成随机数的算法采用线性同余生成器:后值= (前值* a + b)mod 2^n其中,a = 1664525,b=1013904223,n = 32,前值的初始值为seed8.4 在你看来Scala的设计者为什么要提供package object语法而不是简单的让你将函数和变量添加到包中呢？JVM不支持。

8.5 private[com] def giveRaise(rate:Double)的含义是什么？有用吗？除了com包可访问，其他包都不能访问。

8.6 编写一段程序,将Java哈希映射中的所有元素拷贝到Scala哈希映射。

用引入语句重命名这两个类。

8.7 在前一个练习中，将所有引入语句移动到尽可能小的作用域里8.8 以下代码的作用是什么？这是个好主意吗？import java._import javax._导入java和javax下的所有类。

而java和javax下是没有类的。

所以此代码无用8.9 编写一段程序，引入ng.System类，从系统属性读取用户名，从Console对象读取一个密码,如果密码不是"secret"，则在标准错误流中打印一个消息；如果密码是"secret"，则在标准输出流中打印一个问候消息。

不要使用任何其他引入，也不要使用任何限定词(带句点的那种)8.10 除了StringBuilder,还有哪些ng的成员是被scala包覆盖的？直接比对ng下的类和scala包下的类即可。

快学scala第四章习题答案

StringOps中的zip定义如下
abstract def zip[B](that: GenIterable[B]): StringOps[(A, B)]
GenIterable是可遍历对象需要包含的trait，对于String来说，它是可遍历的。但是它的遍历是遍历单个字母。所以拉链就针对每个字母来进行。
(values.count(_ < v),values.count(_ == v),values.count(_ > v))
}
5.10当你将两个字符串拉链在一起，比如"Hello".zip("World")，会是什么结果？想出一个讲得通的用例
scala> "Hello".zip("World")
res0: scala.collection.immutable.IndexedSeq[(Char, Char)] = Vector((H,W), (e,o), (l,r), (l,l), (o,d))
当然使用Scala的方法啦。参考第9章
首先，创建一个文件myfile.txt。输入如下内容
test test ttt test ttt t test sss s
Scala代码如下
importscala.io.Source
importscala.collection.mutable.HashMap
//val source = Source.fromFile("myfile.txt")
5.5重复前一个练习，这次使用java.util.TreeMap并使之适用于Scala API
主要涉及java与scala的转换类的使用
importscala.io.Source

《C++程序设计》课后习题参考答案

《C++程序设计》课后习题参考答案C+＋作为一种广泛使用的编程语言，其课后习题对于学习者巩固知识、提高编程能力具有重要意义。

以下是对一些常见课后习题的参考答案。

一、基础概念题1、简述 C+＋中变量的定义和声明的区别。

变量的定义会为变量分配存储空间，并且可以进行初始化操作。

而变量的声明只是告诉编译器变量的存在以及其类型，但不会为其分配存储空间。

例如：｀｀｀cppint a ＝ 5; ／／这是变量的定义，为 a 分配空间并初始化为 5extern int b; ／／这是变量的声明，说明 b 是一个在其他地方定义的整数变量｀｀｀2、解释 C+＋中指针和引用的区别。

指针是一个变量，它存储了另一个变量的地址。

可以通过解引用指针来访问指向的变量。

引用则是给一个已存在的变量起了一个别名，对引用的操作实际上就是对被引用的变量的操作。

指针可以为空，引用不能为空且必须在定义时初始化。

例如：｀｀｀cppint p ＝ NULL; ／／合法的指针，可为空int& r ＝ a; ／／引用必须初始化｀｀｀二、程序结构题1、编写一个 C+＋程序，计算 1 到 100 的整数之和。

｀｀｀cppinclude ＜iostream>int main(）｛int sum ＝ 0;for （int i ＝ 1; i ＜＝ 100; i+＋）｛sum ＋＝ i;｝std:：cout ＜＜＂1 到 100 的整数之和为：＂＜＜ sum ＜＜ std:：endl;return 0;｝｀｀｀2、用 C+＋实现一个函数，判断一个整数是否为素数。

｀｀｀cppinclude ＜iostream>bool isPrime(int num) ｛if （num ＜ 2) ｛return false;｝for （int i ＝ 2; i i ＜＝ num; i+＋）｛if （num ％ i ＝＝ 0) ｛return false;｝｝return true;｝int main(）｛int num;std:：cout ＜＜＂请输入一个整数：＂；std:：cin ＞＞ num;if （isPrime(num)）｛std:：cout ＜＜ num ＜＜＂是素数" ＜＜ std:：endl;｝ else ｛std:：cout ＜＜ num ＜＜＂不是素数" ＜＜ std:：endl;｝return 0;｝｀｀｀三、数组与字符串题1、编写一个 C+＋程序，将一个整数数组中的元素逆序排列。

快学Scala课后习题答案

快学Scala课后习题答案分享⼀个之前做快学Scala的课后习题(2-21章节，19⽆)的Github链接，我把习题的⽂字写在了每个回答的注释上⾯，这样⽅便⼤家对照着看，省的回过头去对照着pdf看了，如果有做的不对的地⽅希望⼤家给予指正。

举⼀个第⼆章节的例⼦，抛砖引⽟:object charpter02 {/** 2.1* ⼀个数字如果为正数，则它的signum为1;* 如果是负数,则signum为-1;* 如果为0,则signum为0.编写⼀个函数来计算这个值* */def signum(x: Int): Int = {if (x > 0) { 1 }else if (x < 0) { -1 }else { 0 }}def signum(x: Int): Int = if (x > 0) 1 else if (x < 0) -1 else 0;def signum(x: Int) = { if (x > 0) 1 else if (x < 0) -1 else 0 }def signum(x: Int) = if (x > 0) 1 else if (x < 0) -1 else 0/** 2.2* ⼀个空的块表达式{}的值是什么？类型是什么？* */// def checkEmptyBlockType() = {// println({});// println({}.getClass())// }def checkEmptyBlockType { println({}); println({}.getClass()) }/** 2.3* 指出在Scala中何种情况下赋值语句x=y=1是合法的。

* (提⽰：给x找个合适的类型定义)*/def checkAssignLegal { var x: Unit = () println("x's type is: " + x.getClass) var y = 1 x = y = 1}/** 2.4* 针对下列Java循环编写⼀个Scala版本:* for(int i=10;i>=0;i–) System.out.println(i);*/def ScalaForeach { // 1.to(10).reverse.foreach { (i: Int) => Predef.println(i) } // 1.to(10).reverse.foreach { i => Predef println i } // 1.to(10).reverse.foreach { i => println(i) } // 1.to(10).reverse foreach { println _ } (1 to 10 reverse) foreach println}/** 2.5* 编写⼀个过程countdown(n:Int)，打印从n到0的数字*/def countdown(n: Int) { n match { case n if n >= 0 => { (0 to n reverse) foreach println } case n if n < 0 => { n to 0 foreach println } }}/** 2.6* 编写⼀个for循环,计算字符串中所有字母的Unicode代码的乘积。

Scala小练习

Scala⼩练习1、**[primary]**关于和Scala进⾏交互的基本⽅式REPL(Read-Eval-Print Loop)说法错误的是? CA、R 读取（read）B、E 求值（evaluate）C、P 解析（Parse）D、L 循环（Loop）2、**[primary]**不属于Scala7种数值类型的是? DA、CharB、IntC、FloatD、LongLong3、**[primary]**如果需要使⽤scala库中的sqrt函数,如sqrt(2)，下列引⽤包的⽅式错误的是? BA、import scala.math._B、import sqrtC、import math._D、import math.sqrt4、**[primary]**Scala关于变量定义、赋值，错误的是？BA、val a = 3B、val a:String = 3C、var b:Int = 3 ; b = 6D、var b = "Hello World!" ; b = "123"5、**[primary]**在Scala中如何获取字符串“Hello”的⾸字符和尾字符？BA、"Hello"(0)，"Hello"(5)B、"Hello".take(1)，"Hello".reverse(0)C、"Hello"(1)，"Hello"(5)D、"Hello".take(0)， "Hello".takeRight(1)6、**[primary]**下⾯输出与其他不⼀致的是？DA、println("Hello World")B、print("Hello World\n")C、printf("Hello %s", "World\n")D、val w = "World" ; println("Hello $w") s"${变量}"7、**[primary]**关于函数def sum(args:Int*) = {var r = 0 ; for(arg <- args) r += arg ; r}}输出结果不⼀致的是？DA、sum(1,2,3)B、sum(6)C、sum(2,4)D、sum(1,1,1,2)8、**[primary]**下列表达式不是过程( 我们将函数的返回类型为Unit的函数称之为过程)的是？CA、def foo(num:Int) = {println(num * 2)}B、def foo() {println("Hello World")}C、def foo(num:Int) = {num * 2}D、def foo():Unit = {println("Hello World")}9、**[primary]**下列数组定义与其他不⼀致的是(⾥⾯的默认值不同)？DA、val a = Array[Int](0, 0)B、val a = Array(0, 0)C、val a = new Array[Int](2)D、val a = Array[Int](1, 1)10、**[primary]**下列关于数组缓冲val b = ArrayBuffer[Int]()操作结果的注释说明错误的是？CA、b += 1 // b 等于 ArrayBuffer(1)B、b += (1,2,3) // b 等于 ArrayBuffer(1,2,3)C、b += Array(1,2) // b 等于 ArrayBuffer(1,2)D、b += (1,2,3,4,5);b.trimEnd(3) // b 等于 ArrayBuffer(1,2)11、**[primary]**关于数组的常⽤算法，下列说法错误的是？BA、Array(1,7,2,9).sum // 等于 19B、Array(1,7,2,9).sorted // 等于 Array(9,7,2,1) 从⼩到⼤C、Array("one","two","three").max // 等于 "two"D、Array("one","two","three").mkString("-") // 等于 "one-two-three"12、**[primary]**关于元组 Tuple 说法错误的是？DA、元组的可以包含不同类型的元素B、元组是不可变的C、访问元组第⼀个元素的⽅式为 pair._1D、元组最多只有2个元素13、**[primary]**对于函数结果说法错误的是？Ddef getGoodsPrice(goods:String) = {val prices = Map(“book” -> 5, “pen” -> 2, “sticker” -> 1)prices.getOrElse(goods, 0)}A、getGoodsPrice("book") // 等于 5B、getGoodsPrice("pen") // 等于 2C、getGoodsPrice("sticker") // 等于 1D、getGoodsPrice("sock") // 等于 “sock” 应该返回为014、**[primary]**对于元组val t = (1, 3.14, "Fred")说法错误的是？AA、t_1等于 1 应该是 t._1B、t 的类型为 Tuple3[Int, Double, ng.String]C、val (first, second, _) = t // second 等于 3.14D、t._0⽆法访问，会抛出异常15、**[primary]**对于拉链操作val t1 = Array(1, 3); val t2 = Array(2,4) ; t1.zip(t2)返回结果正确的是类似Python？CA、（1,2,3,4)B、（(1,3),(2,4))C、（(1,2),(3,4))D、（(1,4),(3,4))16、**[intermediate]**Scala允许你⽤数字去乘字符串—去REPL中试⼀下"crazy"*3。

Scala面试题汇总

Scala⾯试题汇总scala常见笔试题(囊括了scala的精髓)scala最近⼏年很⽕，主要是因为其在⼤数据领域的应⽤。

下⾯这些⾯试题，基本上是scala函数式编程的精髓。

Q1 var，val和def三个关键字之间的区别？答：var是变量声明关键字，类似于Java中的变量，变量值可以更改，但是变量类型不能更改。

val常量声明关键字。

def关键字⽤于创建⽅法（注意⽅法和函数的区别）还有⼀个lazy val（惰性val）声明，意思是当需要计算时才使⽤，避免重复计算Q2 trait（特质）和abstract class（抽象类）的区别？答：（1）⼀个类只能集成⼀个抽象类，但是可以通过with关键字继承多个特质；（2）抽象类有带参数的构造函数，特质不⾏（如 trait t（i：Int）{} ，这种声明是错误的）Q3 object和class的区别？答：object是类的单例对象，开发⼈员⽆需⽤new关键字实例化。

如果对象的名称和类名相同，这个对象就是伴⽣对象（深⼊了解请参考问题Q7）Q4 case class （样本类）是什么？答：样本类是⼀种不可变且可分解类的语法糖，这个语法糖的意思⼤概是在构建时，⾃动实现⼀些功能。

样本类具有以下特性：（1）⾃动添加与类名⼀致的构造函数（这个就是前⾯提到的伴⽣对象，通过apply⽅法实现），即构造对象时，不需要new；（2）样本类中的参数默认添加val关键字，即参数不能修改；（3）默认实现了toString，equals，hashcode，copy等⽅法；（4）样本类可以通过==⽐较两个对象，并且不在构造⽅法中定义的属性不会⽤在⽐较上。

Q5 Java和Scala 异步计算的区别？答：这⾥作者的意思是他⼤概也不清楚，请阅读这个 really clean and simple answer on StackOverflow，我个⼈理解还不到位后续补上。

Q6 unapply 和apply⽅法的区别，以及各⾃使⽤场景？答：先讲⼀个概念——提取器，它实现了构造器相反的效果，构造器从给定的参数创建⼀个对象，然⽽提取器却从对象中提取出构造该对象的参数，scala标准库预定义了⼀些提取器，如上⾯提到的样本类中，会⾃动创建⼀个伴⽣对象（包含apply和unapply⽅法）。