カテゴリー: Scala

import scala.util.control.Breaks

object Main {
  def main(args: Array[String]): Unit = {
    val b1 = new Breaks

    val msg: java.util.Hashtable[String, String] = new java.util.Hashtable[String, String]
    msg.put("monument", "2つの数字は")
    msg.put("answer", "答えは? ")
    msg.put("good", " 正解！\n\n")
    msg.put("no", " 残念！\n\n")
    msg.put("cond", "%d と %d の、")

    val jk: Array[Jyouken] = new Array[Jyouken](4)
    jk(0) = new Jyouken("+", 1, 1)
    jk(1) = new Jyouken("-", 1, 1)
    jk(2) = new Jyouken("*", 1, 1)
    jk(3) = new Jyouken("/", 1, 1)
    val kekka = Array(0,0)

    b1.breakable {
      while (true) {
        for (i <- 1 to 8) {
          val env: Env = new Env(msg, jk((i - 1) / 2), kekka)
          env.read.eval.print
          if (kekka(1) >= 3) b1.break()
        }
        printf("レベルアップします！\n\n")
        jk.foreach(x => x.levelup)
      }
    }
    printf("正解数 %5d, 誤回答　%5d", kekka(0), kekka(1))
  }
}

import java.util
import java.util.{Random, Scanner}

class Env(var msg:util.Hashtable[String, String],val jk:Jyouken, var kekka:Array[Int]){
  private val scanner = new Scanner(System.in)
  private var x :Int = 0
  private var y :Int = 0
  private var z :Int = 0
  private var rVal: Boolean = false

  def read: Env = {
    val w1 = jk.getitibanme * 10
    val w2 = jk.getnibanme * 10
    val keisan =
      jk.en match {
        case "+" => "足し算 "
        case "-" => "引き算 "
        case "*" => "掛け算 "
        case "/" => "割り算 "
      }
    printf("%s", keisan)
    printf(this.msg.get("monument"))
    val rnd2: Random = new Random()
    y = rnd2.nextInt(w2)
    val rnd: Random = new Random
    x = rnd.nextInt(w1)
    if (jk.en == "/"){
      if (x == 0 || y == 0) {
        x += 1; y += 1
      }
    }

    if (jk.en == "-" || jk.en == "/"){
      if (y > x){
        val work = x; x = y; y = work
      }
    }
    printf("%3d, %3d の", x, y)
    this
  }

  def eval: Env = {
    printf(this.msg.get("answer"))
    z = scanner.nextInt()
    rVal =
      jk.en match {
        case "+" => if (z == x + y) true else false
        case "-" => if (z == x - y) true else false
        case "*" => if (z == x * y) true else false
        case "/" => if (z == x / y) true else false
      }
    this
  }

  def print:Env = {
    printf(this.msg.get("cond"), x, y)
    val siki =
      jk.en match {
        case "+" => "和は"
        case "-" => "差は"
        case "*" => "積は"
        case "/" => "商は"
      }
    printf("%s %3d", siki, z)

    if (rVal) {
      printf(this.msg.get("good"))
      kekka(0) += 1
    } else {
      printf(this.msg.get("no"))
      kekka(1) += 1
    }
    this
  }
}

class Jyouken(val en:String, val iti: Int, val ni: Int){
  private val enzan: String = en
  private var itibanme: Int = iti
  private var nibanme: Int = ni

  def levelup: Jyouken = {
    if (enzan == "+" || enzan == "-" || enzan == "/") {
      itibanme += 1; nibanme += 1
    } else {
      itibanme += 1; nibanme = 1
    }
    this
  }
  def getitibanme: Int = itibanme
  def getnibanme: Int = nibanme
}

import java.util.Random

object Main {
  def main(args: Array[String]): Unit = {
    val msg: java.util.Hashtable[String, String] = new java.util.Hashtable[String, String]
    //val msg = collection.mutable.HashMap.empty[String, String]
    //msg.put("yama","山は")
    msg.put("you", "あなた")
    msg.put("comp", "コンピュータ")
    msg.put("took", "%sが,山 %d から%d個取った\n")
    msg.put("take", "石を取って!(1〜%d) > ")
    msg.put("cond", "現在の石の数: %d, %d, %d\n\n")
    msg.put("win", "%sの勝ち\n")
    val rnd: Random = new Random
    val bVal: Boolean = rnd.nextBoolean
    val env: Env = new Env(Array[Int](2, 4, 5), bVal, msg)
    env.print
    System.out.printf("%sが先攻\n", if (bVal) {
      msg.get("you")
    }
    else {
      msg.get("comp")
    })
    while (env.num(0) > 0 || env.num(1) > 0 || env.num(2) > 0) {
      env.read
      env.eval
      env.print
    }
    System.out.printf(msg.get("win"), if (env.turn) {
      msg.get("you")
    }
    else {
      msg.get("comp")
    })
  }
}

import java.util
import java.util.{Random, Scanner}
import scala.util.control.Breaks

class Env(var num: Array[Int], var turn: Boolean, var msg:util.Hashtable[String, String]) {
  this.msg = msg
  private val scanner = new Scanner(System.in)
  private var x: Int = -1
  private var y: Int = -1

  def read: Env = {
    val b1 = new Breaks
    if (!this.turn) {
      this
    } else {
      b1.breakable {
        while (true) {
          System.out.printf("山は?(1~3) > ")
          this.y = scanner.nextInt() - 1
          System.out.printf(this.msg.get("take"), if (this.num(this.y) > 3) 3
          else this.num(this.y))
          this.x = scanner.nextInt
          if (this.x > 0 && this.x <= this.num(this.y))
             b1.break()
        }
      }
      this
    }
  }

  def eval: Env = {
    val b1 = new Breaks
    if (!this.turn) {
      b1.breakable {
        while (true) {
          val rnd2: Random =new Random()
          this.y = rnd2.nextInt(3)
          val rnd: Random = new Random
          this.x = rnd.nextInt(3) + 1
          if (this.x <= this.num(this.y))
            b1.break()
        }
      }
    }
    this.num(this.y) -= this.x
    this.turn = !this.turn
    this
  }

  def print: Env = {
    if (this.turn && !(this.y == -1)) System.out.printf(this.msg.get("took"), this.msg.get("comp"), this.y + 1, this.x)
    System.out.printf(this.msg.get("cond"), this.num(0),this.num(1), this.num(2))
    this
  }
}