Scala第2章 控制结构和函数(编程题)

简介: Scala第2章 控制结构和函数(编程题)

7-10 h0053. 求一元二次方程的根


利用公式x1 = (-b + sqrt(b* b-4* a* c))/(2* a), x2 = (-b - sqrt(b* b-4* a* c))/(2* a)求一元二次方程ax^2 + bx + c =0的根,其中a不等于0。


输入格式:


第一行是待解方程的数目n。


其余n行每行含三个浮点数a, b, c(它们之间用空格隔开),分别表示方程ax^2 + bx + c =0的系数。


输出格式:


输出共有n行,每行是一个方程的根:


若是两个实根,则输出:x1=...;x2 = ...

若两个实根相等,则输出:x1=x2=...

若是两个虚根,则输出:x1=实部+虚部i; x2=实部-虚部i

所有实数部分要求精确到小数点后5位,数字、符号之间没有空格。


x1和x2的顺序:x1的实部>Re的实部||(x1的实部==x2的实部&&x1的虚部>=x2的虚部)


输入样例:


1. 3
2. 1.0 3.0 1.0
3. 2.0 -4.0 2.0
4. 1.0 2.0 8.0


输出样例:


在这里给出相应的输出。例如:


1. x1=-0.38197;x2=-2.61803
2. x1=x2=1.00000
3. x1=-1.00000+2.64575i;x2=-1.00000-2.64575i


import scala.io.StdIn
import math.sqrt
object Main {
  def main(args: Array[String]): Unit = {
      var n = StdIn.readInt();
      for (i <- 1 to n) {
          var l = StdIn.readLine();
          var s = l.split(" ");
          var a = s(0).toDouble;
          var b = s(1).toDouble;
          var c = s(2).toDouble;
//           println(a+" "+b+" "+c);
          var part1 : Double = (0 - b) / (2 * a);
//           println(part1);
          var pd = b * b - 4 * a * c;
          if (pd > 0) {
              var part2 : Double = sqrt(pd) / (2 * a);
              printf("x1=%.5f;x2=%.5f\n" ,part1+part2 ,part1-part2);
          }
          else if(pd == 0) {
              printf("x1=x2=%.5f\n",part1);
          }
          else {
              var part2 : Double = sqrt(-pd) / (2 * a);
              printf("x1=%.5f+%.5fi;x2=%.5f%.5fi\n",part1,part2,part1,-part2);
          }
      }
  }
}


7-12 h0016.精准运动


小明 正在学习建模。她对带有活动部件的模型很感兴趣。作为她的第一个任务,她制作了一个大小2×n的矩形盒子,其中包含两个平行的导轨和每个导轨上的矩形条。短条的尺寸1×a,长条的尺寸 1×b. 长杆的两端各有一个塞子,而短的总是在这两个塞子之间。



303d7a370a131d14f8bbe9d7b2529a7d.jpg



只要短杆位于挡块之间,杆就可以沿着导轨移动,一次一根杆。所以,小明在每个矩形条移动选择其中一个条并移动它,而另一个保持在原位。最初,两个条都与盒子的一侧对齐,小明希望它们以尽可能少的移动到另一侧对齐。为了实现目标,他最少需要移动多少次?


输入格式:


输入在一行中给出3个整数a、b和c(1<=a


输出格式:


对每一组输入,在一行中输出小明最少需要移动的次数。


输入样例:


1. 1 3 6
2. 2 4 9


输出样例:


1. 5
2. 7


import scala.io.StdIn
object Main{
    def main(args: Array[String]): Unit={
        while(true){
            var l = StdIn.readLine();
            var s = l.split(" ");
            var a = s(0).toInt;
            var b = s(1).toInt;
            var c = s(2).toInt;
            var ans : Int = 0;
                var x : Int = a;
                var y : Int = b;
                var z : Int = b - a;
                while(x < c || y < c) {
                    if (x < c) {
                        x += z;
                        ans += 1;
                    }
                    if (y < c) {
                        y += z;
                        ans += 1;
                    }
                }
            println(ans)
        }
    }
}


7-13 h0010.sum


本题目要求读入1个整数n,然后输出1~n之间所有整数的和。


输入格式:


输入在一行中给出1个绝对值不超过10000的整数n。


输出格式:


对每一组输入,在一行中输出1~n之间所有整数的和。


输入样例:


-3
3


输出样例:


方法一:


import scala.io.StdIn
object Main {
    def main(args: Array[String]): Unit = {
        while(true){
            var n : Int = StdIn.readInt()
          var s : Int = 0
          if(n < 1){
              for(i<- Range(n,2)) s += i
              println(s)
          }
            else {
                for (i <- 1 to n) s += i
                println(s)
            }
        }
  }
}


方法二:

x > 0 1~x  (1+x)*x/2

x <0 -x~1 -((1+x)*x/2 - 1)


import scala.io.StdIn
object Main {
    def main(args:Array[String]):Unit={
        while(true) {
            var sum : Int = 0
            var x = StdIn.readInt()
            if (x >= 0)
                sum = (x + 1) * x / 2
            else if(x < 0) {
                x = -x
                sum = -((x + 1) * x / 2) + 1
            }
            println(sum)
        }
    }
}


7-14 h0080. 菱形


输入一个奇数n,输出一个由‘*’构成的n阶空心菱形。


输入格式:


一个奇数n。


输出格式:


输出一个由‘*’构成的n阶实心菱形。


具体格式参照输出样例。


输入样例:


5



输出样例:


1.   *
2. * *
3. *   *
4.  * * 
5.   *


法一:



import scala.io.StdIn
object Main{
  def main(args: Array[String]): Unit = {
    //打印空心菱形:  空心正三角形+空心倒三角形 = 空心菱形
      var n : Int = StdIn.readInt()
    //空心正三角形
//     6      ==12
//    5 7     ==12
//   4   8    ==12
//  3     9   ==12
// 2       10 ==12
//1         11==12
// 2       10 ==12
//  3      9  ==12
//   4    8   ==12
//    5  7    ==12
//     6      ==12
//每一个数字代表每个*号在所在行的列号
//由于菱形是对称的,所以先考虑上半部分
//通过观察上半部分为6行11列
//左半部分第1行为6、第2行为5、..............、第6行为1;由此可知外循环应使用for(i <- 6 to (1,-1))
//用i代表行号,j代表列号;当i=j或者j=12-i时该位置的应输出*号,其他位置输出空格。
      for (i <- n / 2 + 1 to (1 ,-1)) {
          for (j <- 1 to n) {
              if (i == j || j == n + 1 -i) {
                  print("*")
              }
              else {
                  print(" ")
              }
          }
          println()
      }
    //倒三角形
      for (i <- 2 to n / 2 + 1) {
          for (j <- 1 to n) {
              if (i == j || j == n + 1 -i) {
                  print("*")
              }
              else print(" ")
          }
          println()
      }
  }
}


法二:


import scala.io.StdIn
object Main{
  def main(args: Array[String]): Unit = {
      var n = StdIn.readInt()
      var a = n / 2
      //棱形的上半部分
      for (i <- 1 to n / 2 + 1) {
          //输出*号前面的空行
          for (j <- 1 to a) print(" ")
          //输出星号
          for (j <- 1 to 2 * i - 1) {
              if (j == 1 || j == 2 * i - 1) print("*")
              else print(" ")
          }
          //输出*号后面的空行
          for (j <- 1 to a) print(" ")
          println()
          a -= 1
      }
      //菱形的下半部分
      a = 1
      for (i <- n / 2 to (1, -1)) {
          //输出*号前面的空行
          for (j <- 1 to a) print(" ")
          //输出星号
          for (j <- 1 to 2 * i - 1) {
              if (j == 1 || j == 2 * i - 1) print("*")
              else print(" ")
          }
          //输出*号后面的空行
          for (j <- 1 to a) print(" ")
          println()
          a += 1
      }
  }
}


7-16 h0157. 斐波那契数


给你一个整数n,求出它的斐波那契数是多少?


输入格式:


在一行中给出1个不超过30的正整数n。


输出格式:


在一行中输出斐波那契数的值。


输入样例:


5


输出样例:


1 1 2 3 5 


法一:


import scala.io.StdIn
object Main {
  def main(args: Array[String]): Unit = {
      var n = StdIn.readInt()
      def f(x: Int):Int= {
          if (x == 1) 1
          else if (x == 2) 1
          else f(x - 1) + f(x - 2)
      }
      var flag : Int = 0
      for (i <- 1 to n) {
          print(f(i) + " ")
      }
  }
}


法二:


import scala.io.StdIn;
import scala.collection.mutable.ArrayBuffer     //ArrayBuffer包使数组可变
object Main {                           //类
def main(args: Array[String]): Unit = {         //main方法
        var n = StdIn.readInt();
        def dg(n: Int): Array[Int] = {                  //类型为Int
            def func(n: Int): Int = {                       //定义方法
                if (n<=2) 1; 
                else func(n - 1) + func(n - 2);  //特征<=2,输出均为1,>2为(n-1)+(n-2)
            }
//             println(func(1))                         //检查特例值数据
            val array = new ArrayBuffer[Int];               //new一个对象
            for (i <- 1 to n) {                         //确定i的取值范围
                array.append(func(i));                  //往buffer里添加func产生的数据
            }
            array.toArray;                      //toArray
        }
        dg(n).foreach(x => print(s"$x "));           //遍历输出
    }
}


7-17 h0158. 猴子吃桃子问题


有一堆桃子,猴子第一天吃了其中的一半,并再多吃了一个!以后每天猴子都吃其中的一半,然后再多吃一个。当到第n天时,想再吃时(还没吃),发现只有1个桃子了。问题:最初共多少个桃子?


输入格式:


在一行中给出1个不超过30的正整数n。


输出格式:


在一行中输出最初的桃子个数。


输入样例:


10


输出样例:


桃子=1534


法一:


import scala.io.StdIn
object Main {
    def main(args: Array[String]): Unit = {
        var n = StdIn.readInt();
        val num = f(1,1,n);
        print("桃子="+num);
    }
    def f(a : Int ,d : Int ,n : Int): Int = {
        var ans = (a + 1) * 2;
        var dcnt = d + 1;
        if(dcnt == n) return ans;
        else f(ans ,dcnt ,n);
    }
}


法二:


import scala.io.StdIn
object Main {
    def main(args: Array[String]): Unit = {
        var n = StdIn.readInt()
        var sum : Int = 1
        for (i <- 1 to n - 1) {
            sum = (sum + 1) * 2
        }
        println("桃子=" + sum)
    }
}


目录
相关文章
|
5月前
|
分布式计算 Scala Spark
Scala【集合常用方法和函数操作(下)】
Scala【集合常用方法和函数操作(下)】
|
5月前
|
分布式计算 Scala Spark
Scala 【集合常用方法和函数操作-上】
Scala 【集合常用方法和函数操作-上】
|
1天前
|
缓存 分布式计算 大数据
大数据-90 Spark 集群 RDD 编程-高阶 RDD容错机制、RDD的分区、自定义分区器(Scala编写)、RDD创建方式(一)
大数据-90 Spark 集群 RDD 编程-高阶 RDD容错机制、RDD的分区、自定义分区器(Scala编写)、RDD创建方式(一)
10 0
|
1天前
|
分布式计算 算法 大数据
大数据-90 Spark 集群 RDD 编程-高阶 RDD容错机制、RDD的分区、自定义分区器(Scala编写)、RDD创建方式(二)
大数据-90 Spark 集群 RDD 编程-高阶 RDD容错机制、RDD的分区、自定义分区器(Scala编写)、RDD创建方式(二)
9 0
|
3月前
|
Scala 开发者
Scala中的模式匹配与高阶函数:探索强大的编程范式
【7月更文挑战第11天】Scala中的模式匹配和高阶函数是两种极其强大的特性,它们不仅提升了代码的表达力和可读性,还使得开发者能够编写出更加灵活和可重用的解决方案。通过
|
5月前
|
安全 编译器 Scala
何时需要指定泛型:Scala编程指南
本文是Scala编程指南,介绍了何时需要指定泛型类型参数。泛型提供代码重用和类型安全性,但在编译器无法推断类型、需要提高代码清晰度、调用泛型方法或创建泛型集合时,应明确指定类型参数。通过示例展示了泛型在避免类型错误和增强编译时检查方面的作用,强调了理解泛型使用时机对编写高效Scala代码的重要性。
38 1
何时需要指定泛型:Scala编程指南
|
5月前
|
编译器 Scala
认识scala中的函数
认识scala中的函数
47 5
|
5月前
|
Scala
Scala函数和方法
Scala函数和方法
33 1
|
机器学习/深度学习 分布式计算 Java
Scala方法和函数
Scala方法和函数
97 0
|
Java Shell API
Scala和Kotlin脚本编程
Scala和Kotlin作为运行在JVM上的编程语言,解决了Java的很多痛点。今天我们来聊聊如何将Scala和Kotlin作为脚本语言使用(Java不支持以脚本形式运行哦)。
86 0