結果

問題 No.211 素数サイコロと合成数サイコロ (1)
ユーザー yoshikyotoyoshikyoto
提出日時 2015-05-22 22:25:45
言語 Scala(Beta)
(3.4.0)
結果
MLE  
(最新)
AC  
(最初)
実行時間 -
コード長 3,191 bytes
コンパイル時間 13,576 ms
コンパイル使用メモリ 257,828 KB
実行使用メモリ 64,504 KB
最終ジャッジ日時 2023-09-11 11:24:06
合計ジャッジ時間 47,967 ms
ジャッジサーバーID
（参考情報） 		judge15 / judge13
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 976 ms
63,132 KB
testcase_01 AC 987 ms
62,920 KB
testcase_02 AC 974 ms
62,940 KB
testcase_03 AC 988 ms
63,048 KB
testcase_04 AC 986 ms
63,028 KB
testcase_05 AC 983 ms
63,004 KB
testcase_06 AC 993 ms
63,044 KB
testcase_07 AC 974 ms
62,972 KB
testcase_08 AC 978 ms
62,928 KB
testcase_09 AC 978 ms
62,916 KB
testcase_10 AC 987 ms
62,872 KB
testcase_11 AC 977 ms
62,916 KB
testcase_12 AC 983 ms
63,380 KB
testcase_13 AC 993 ms
63,000 KB
testcase_14 AC 985 ms
63,476 KB
testcase_15 AC 988 ms
62,900 KB
testcase_16 MLE -
testcase_17 AC 992 ms
62,948 KB
testcase_18 AC 984 ms
63,320 KB
testcase_19 AC 984 ms
62,988 KB
testcase_20 AC 986 ms
63,328 KB
testcase_21 AC 988 ms
63,152 KB
testcase_22 AC 991 ms
63,056 KB
testcase_23 AC 995 ms
63,072 KB
testcase_24 AC 985 ms
63,168 KB
testcase_25 AC 999 ms
63,364 KB
testcase_26 AC 985 ms
63,136 KB
testcase_27 AC 995 ms
62,992 KB
testcase_28 AC 976 ms
63,120 KB
testcase_29 AC 979 ms
63,104 KB
testcase_30 AC 986 ms
63,324 KB
testcase_31 AC 983 ms
63,068 KB
testcase_32 AC 984 ms
62,916 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

import java.util.Scanner

object Main {
  def main(args: Array[String]): Unit = {
    val sc = new Scanner(System.in)
    val k = sc.nextInt();
    val p: List[Int] = List(2, 3, 5, 7, 11, 13)
    val q: List[Int] = List(4, 6, 8, 9, 10, 12)
    
    var cnt = 0;
    for(i <- p; j <- q) yield {
      if(i * j == k) cnt += 1;
    }
    println(cnt.toDouble / (p.length * q.length).toDouble)
  }
  
  
  /**
   * P16
   */
  def drop[T](n: Int, list: List[T]): List[T] = {
    def f(i: Int)(n: Int, list: List[T]): List[T] = (i, n, list) match {
      case (_, _, Nil) => Nil
      case (1, n, car :: cdr) => f(n)(n, cdr)
      case (i, n, car :: cdr) => car :: f(i-1)(n, cdr)
    }
    f(n)(n, list)
  }
  /*
  def d[T](i: Int, n: Int, list: List[T]): List[T] = (i, n, list) match {
    case (_, _, Nil) => Nil
    case (1, n, car :: cdr) => d(n, n, cdr)
    case (i, n, car :: cdr) => car :: d(i-1, n, cdr)
  }
  */
  
  /**
   * P12
   */
  /*
  def decode[T](list: List[List[T]]): List[T] = list match {
    case Nil => Nil
    case List(n, v) :: cdr => 
      for(i <- 1 to n) yield {v} :: cdr
  }
  */
  
  /**
   * P11
   */
  def encode[T](list: List[T]): List[(Int, T)] = list match {
    case Nil => Nil
    case car :: cdr => {
      val (first, second) = list.span(x => x == car)
      (first.length, car) :: encode(second)
    }
  }
  
  /**
   * P10
   */
  def encodeModified[T](list: List[T]): List[Any] = list match {
    case Nil => Nil
    case first :: second :: cdr if first != second =>
      first :: encodeModified(second :: cdr)
    case car :: cdr => {
      val (first, second) = list.span(x => x == car)
      (first.length, car) :: encodeModified(second)
    }
  }
  
  /**
   * P09
   */
  def pack[T](list: List[T]): List[List[T]] = list match {
    case Nil => Nil
    case car :: cdr => {
      val (first, second) = list.span(x => x == car)
      first :: pack(second)
    }
  }
  
  /**
   * P08
   */
  def compress[T](list: List[T]): List[T] = list match {
    case first :: second :: cdr if first == second => compress(first :: cdr)
    case car :: cdr => car :: compress(cdr)
    case Nil => Nil
  }
  
  /**
   * P07
   */
  def flatten(list: List[Any]): List[Any] = list.flatMap {
      case l: List[_] => flatten(l)
      case elm => List(elm)
  }
  
  /**
   * P06
   */
  def isParindrome[T](list: List[T]): Boolean = list == list.reverse
  
  /**
   * P05
   */
  def reverse[T](list: List[T]): List[T] =
    list.foldLeft(List.empty[T])((x, y) => y :: x)
  
  /**
   * P04
   */
  def length[T](list: List[T]): Int = list match {
    case Nil => 0;
    case car :: cdr => 1 + length(cdr)
  }
  
  /**
   * P03
   */
  def nth[T](n: Int, list: List[T]): T = (n, list) match {
    case (0, car :: cdr) => car
    case (m, car :: cdr) => nth(m-1, cdr)
    case _ => throw new Exception
  }
  
  /**
   * P02
   */
  def penultimate[T](list: List[T]): T = list match {
    case first :: second :: Nil => first
    case car :: cdr => last(cdr)
    case _ => throw new Exception
  }
  
  /**
   * P01
   */
  def last[T](list: List[T]): T = list match {
    case car :: Nil => car
    case car :: cdr => last(cdr)
    case _ => throw new Exception
  }
}
0