Latest comments for language 'Scala' on doukaku.org

sna's comment on 疑似並行処理

極力シンプルにと言うことでspawn。
yieldが予約語だったことを忘れてて少し悩んだ。

import scala.concurrent.ops._

object TwoThread extends Application {
  spawn { ('a' to 'j').foreach{ x => print(x + " "); Thread.`yield` } }
  spawn { (  1 to 10 ).foreach{ x => print(x + " "); Thread.`yield` } }
}

[ Scala ] [ download code ] ]

sna's comment on '('と')'の対応

'('と')'の対応 (Nested Flatten)

1引数関数は()の代わりに{}を使用可、多引数関数はFunction.curriedでカリー化して呼び出せる。ifはパターンマッチ、whileは末尾再起で代替可能。

引数を持つメソッドが宣言できないためmainメソッドに渡されるargsを取れないので、標準入力から入力します。

object ParenthesesChecker extends Application {
  
  {
    def cons[A] = Function.curried{Stream.cons[A] _}
    
    def lines: Stream[String] = cons[String]{readLine}{lines}
    val src = lines.takeWhile{_ != null}.mkString.elements
    
    var count = 0
    val OPEN_CHAR = 40.toChar
    val CLOSE_CHAR = 41.toChar
    def loop: Unit = src.hasNext match {
      case true => src.next match {
        case 40               => count += 1; loop
        case 41 if count == 0 => println{false}
        case 41               => count -= 1; loop
        case _ => loop
      }
      case false => println{count == 0}
    }
    loop
  }
  
}

[ Scala ] [ download code ] ]

sna's comment on 漢数字で九九の表

漢数字で九九の表 (Nested Flatten)

表示用の漢数字は無限リストで。
乗算は数値を使わずリストで表現。

object MultiplicationTable {
  
  def main(args: Array[String]) {
    
    val kns = "〇一二三四五六七八九".map(_.toString).toList
    lazy val knns: Stream[String] =
      kns.toStream append knns.tail.flatMap{ knn => kns.map(knn + _) }
    val fknns = knns.map{ knnn =>
      knnn.replaceAll("^.$", "　").replaceAll("[^　]+", "") + knnn }
    
    lazy val ds: Stream[List[Unit]] =
      Stream.cons(List(()), ds.map(() :: _)) take kns.tail.length
    val dds = ds.toList.map{ d => ds.toList.map(_.flatMap{ v => d }) }
    
    dds foreach { dd =>
      dd foreach { d =>
        print(" " + fknns(d.length))
      }
      println
    }
    
  }
  
}

[ Scala ] [ download code ] ]

nido's comment on 漢数字で九九の表

漢数字で九九の表 (Nested Flatten)

Scalaの勉強始めたので習作です。

object Kuku {
  def main(args: Array[String]) = {
    val kansuji = "〇一二三四五六七八九".toCharArray.map{_.toString}
    for (y <- kansuji if (y != kansuji.first)) {
      for (x <- kansuji if (x != kansuji.first)) {
        val mul = kansuji.indexOf(x) * kansuji.indexOf(y)
        if (mul >= kansuji.size) {
          print (kansuji(mul / kansuji.size) + kansuji(mul % kansuji.size) + "\t")
        } else {
          print (kansuji(mul) + "\t")
        }
      }
      println
    }
  }
}

[ Scala ] [ download code ] ]

匿名's comment on ミリ秒まで含んだ時刻文字列

ミリ秒まで含んだ時刻文字列 (Nested Flatten)

”DD”は”ｄｄ”でないと表示がおかしくなりませんか？

takeo's comment on タブ区切りデータの処理

タブ区切りデータの処理 (Nested Flatten)

あまりScalaらしくありませんが...。

object Tsv {
  
  def tsv(text:String) : Unit = {
    import scala.io.Source
    val lines = Source.fromString(text).getLines
    print(lines.next)
    val data = lines.map({s:String => s.split("\t")})
    val lst = List.fromIterator(data).sort({(a:Array[String], b:Array[String]) => Integer.parseInt(a(0)) < Integer.parseInt(b(0))})
    for (line <- lst) {print(line(0) + "\t" + line(1) + "\t" + line(2) + "\t" + line(3))}
  }
  
  def main(args : Array[String]) : Unit = {
    val testData = "ID\tSurname\tForename\tAge\n1\tSato\tHanako\t17\n0\tSuzuki\tTaro\t18\n"
    tsv(testData)
  }
}

[ Scala ] [ download code ] ]

lunlumo's comment on 変数の初期値

変数の初期値 (Nested Flatten)

　scalaの場合変数宣言時に値を設定する必要があるので，未初期化時に値を設定するやり方は用意されていません。Option型は用意されているので，Noneが設定されている場合に限り値を設定する処理を参考までに挙げておきます。

class DefinedOr[T] {
    var    _v:Option[T] = None
    def this(n:T) = { this(); this.v = n }
    def v:Option[T] = _v
    def v_=(v:T) = { _v = Some(v) }
    def ||=(n:T) = { v = v match { case None => n; case Some(x) => x } }
}
object Main {
    def main(args:Array[String]) = {
        var    d:DefinedOr[Int] = new DefinedOr
        println(d.v)
        d ||= 0
        println(d.v)
        d ||= 1
        println(d.v)
        d = new DefinedOr(2)
        println(d.v)
        d ||= 0
        println(d.v)
    }
}

[ Scala ] [ download code ] ]

lunlumo's comment on 2^i * 3^j * 5^k なる整数

2^i * 3^j * 5^k なる整数 (Nested Flatten)

　#7638と#7671のやり方で。

import    scala.collection.immutable.SortedSet
import    scala.collection.immutable.TreeSet
abstract class CHammingNumbers {
    def take(n:Int):List[Int]
}
class CHammingNumbersG extends CHammingNumbers {
    def next(s:List[Int],h:List[Int]):Tuple2[List[Int],List[Int]] = {
        val    m:List[Int] = s.zip(List(2,3,5)).map { v => h.apply(v._1)*v._2 }
        val    n:Int = m.sort { (a,b) => a < b }.head
        (s.zip(m).map { v => (v._2 == n) match { case true => v._1 + 1; case _ => v._1 } },h+n)
    }
    def take(n:Int,s:List[Int],h:List[Int]):Tuple2[List[Int],List[Int]] = n match {
            case 0 => (s,h)
            case _ => next(s,h) match { case v => take(n-1,v._1,v._2) }
        }
    def take(n:Int):List[Int] = take(n-1,List(0,0,0),List(1))._2
}
class CHammingNumbersS extends CHammingNumbers {
    def next(c:SortedSet[Int]):Tuple2[Int,SortedSet[Int]] = (c.firstKey,(TreeSet(c.firstKey*2,c.firstKey*3,c.firstKey*5)++(c-c.firstKey)))
    def take(n:Int,c:SortedSet[Int]):List[Int] = n match {
            case 0 => List()
            case _ => next(c) match { case v => v._1::take(n-1,v._2) }
        }
    def take(n:Int):List[Int] = take(n,TreeSet(1))
}
object HammingNumbers {
    def main(args:Array[String]):Unit = {
        try {
            val    n:Int = args.length match {
                case 1 => args(0).toInt
                case _ => 100
            }
            List(new CHammingNumbersG,new CHammingNumbersS).foreach { h => println(h.take(n).mkString("\n")) }
        } catch {
            case e => e.printStackTrace
        }
    }
}

[ Scala ] [ download code ] ]

lunlumo's comment on 2^i * 3^j * 5^k なる整数

2^i * 3^j * 5^k なる整数 (Nested Flatten)

　Streamを使って書いてみました。

object HammingNumbers {
    def from(n:Int):Stream[Int] = Stream.cons(n,from(n+1))
    def hammings(s:Stream[Int]):Stream[Int] = {
        def divide(n:Int,b:Int):Int = (n % b == 0) match {
                case false => n
                case _ => divide(n/b,b)
            }
        Stream.cons(s.head,hammings(s.tail.filter { n => List(2,3,5).foldLeft(n) { (v,b) => divide(v,b) } == 1 }))
    }
    def hammings():Stream[Int] = hammings(from(1))
    def main(args:Array[String]):Unit = {
        try {
            val    n:Int = args.length match {
                case 1 => args(0).toInt
                case _ => 100
            }
            println(hammings().take(n).mkString("\n"))
        } catch {
            case e => e.printStackTrace
        }
    }
}

[ Scala ] [ download code ] ]

lunlumo's comment on 2^i * 3^j * 5^k なる整数

2^i * 3^j * 5^k なる整数 (Nested Flatten)

　[1..100]>>=penさんの投稿を参考に書いてみました。

class CHummingNumbers {
    def next(c:Int):Int = (BigInt(30).pow(c) % c).intValue match {
            case 0 => c
            case _ => next(c+1)
        }
    def take(n:Int,c:Int):List[Int] = n match {
            case 0 => List()
            case _ => next(c) match { case v => v::take(n-1,v+1) }
        }
    def take(n:Int):List[Int] = take(n,1)
}
object HummingNumbers {
    def main(args:Array[String]):Unit = {
        try {
            val    n:Int = args.length match {
                case 1 => args(0).toInt
                case _ => 100
            }
            println((new CHummingNumbers).take(n).mkString("\n"))
        } catch {
            case e => e.printStackTrace
        }
    }
}

[ Scala ] [ download code ] ]

lunlumo's comment on LL Golf Hole 9 - トラックバックを打つ

LL Golf Hole 9 - トラックバックを打つ (Nested Flatten)

　scalaで。

import    java.io._
import    java.net._
val    c = (new URL("http://ll.jus.or.jp/2008/blog/archives/38/trackback")).openConnection.asInstanceOf[HttpURLConnection]
c.setRequestMethod("POST")
c.setDoOutput(true)
val    o = new OutputStreamWriter(c.getOutputStream)
o.write("title=LL+Golf+Hole+9&excerpt=trackback+from+LL+Golf+Hole+9.&url=http://ja.doukaku.org/207/&blog_name=LL+Golf+Hole+9")
o.flush
o.close
val    i = new BufferedReader(new InputStreamReader(c.getInputStream))
while (i.ready) {
    println(i.readLine)
}
c.disconnect

[ Scala ] [ download code ] ]

lunlumo's comment on 与えられた並べ替えを実現するあみだくじの生成

与えられた並べ替えを実現するあみだくじの生成 (Nested Flatten)

　ソートを掛ける方法で。

class CGhostLeg(g:List[Int]) {
    val    s:List[Int] = g.sort { (a,b) => a < b }
    var    p:List[List[Boolean]] = List()
    def create:CGhostLeg = {
        def _calc(c:List[Int],r:Tuple2[List[Int],List[Boolean]]):Tuple2[List[Int],List[Boolean]] = c match {
                case List() => r
                case h::List() => (r._1+h,r._2)
                case h::t => h.compare(t.head) match {
                        case p if p > 0 => _calc(c.slice(2).asInstanceOf[List[Int]],(r._1+c.apply(1)+h,r._2+true++(t match { case h::List() => List(); case _ => List(false) })))
                        case _ => _calc(t,(r._1+h,r._2+false))
                    }
                case _ => r
            }
        def _step(c:List[Int]):Unit = {
            val    n = _calc(c,(List(),List()))
            p = n._2::p
            if (!n._1.zip(s).filter { d => d._1 != d._2 }.isEmpty) _step(n._1)
        }
        _step(g)
        this
    }
    def print:Unit = {
        def _join(d:String,l:List[String]):String = l.head + l.tail.foldLeft("") { (s,e) => s + d + e }
        println(_join(" ",s.map { e => e.toString }))
        p.foreach { l =>
            println(_join("|",""::(l.map { e => e match { case true => "-"; case _ => " " } })+""))
        }
        println(_join(" ",g.map { e => e.toString }))
    }
}

object GhostLeg {
    def main(args:Array[String]):Unit = {
        try {
            var    g:List[Int] = args.length match {
                case 0 => List(3,5,2,4,0,1)
                case _ => args.toList.map { s => s.toInt }
            }
            (new CGhostLeg(g)).create.print
        } catch {
            case e => e.printStackTrace
        }
    }
}

[ Scala ] [ download code ] ]

lunlumo's comment on 魔方分割数

魔方分割数 (Nested Flatten)

　Pentium1.6GHzの端末で17分少し掛かりました。

import    java.text.SimpleDateFormat
import    java.util.Calendar

class CMagicNumber(n:Int) {
    val    m:Int = n * n
    val    a:Int = n * (n * n + 1) / 2
    def calc:Int = {
        def _calc(p:Int,c:Int,s:Int,r:List[Int],g:Int):Int = r match {
                case List() => g + 1
                case _ => c match {
                        case 0 => _calc(r.head,1,r.head,r.tail, g)
                        case _ => r.filter { d => d > p }.foldLeft(g) { (g,d) =>
                                ((c == n - 1) && (s + d == a)) match {
                                    case true => _calc(0,0,0,r.filter { e => e != d },g)
                                    case _ => (d + s >= a) match {
                                            case true => g
                                            case _ => _calc(d,c + 1,s + d,r.filter { e => e != d },g)
                                        }
                                }
                            }
                    }
            }
        _calc(0,0,0,(1 to m).toList,0)
    }
}
object MagicNumber {
    def printTime:Unit = println((new SimpleDateFormat("yyyy/MM/dd HH:mm:ss")).format(Calendar.getInstance.getTime))
    def main(args:Array[String]):Unit = {
        try {
            printTime
            printf("result:%d\n",(new CMagicNumber(args.length match { case 1 => args(0).toInt; case _ => 5 })).calc)
            printTime
        } catch {
            case e => e.printStackTrace
        }
    }
}

[ Scala ] [ download code ] ]

lunlumo's comment on 文字列型日時ののN秒後時間取得

文字列型日時ののN秒後時間取得 (Nested Flatten)

　Javaと余り変わりませんがscala版を。

import    java.text.DateFormat
import    java.text.ParseException
import    java.text.SimpleDateFormat
import    java.util.Calendar

object DateEx {
    val    formatter:DateFormat = new SimpleDateFormat("yyyyMMddHHmmss")
    def DateEx(date:String,diff:Int):String = {
        val    calendar:Calendar = Calendar.getInstance
        calendar.setTime(formatter.parse(date))
        DateEx(calendar,diff)
    }
    def DateEx(diff:Int):String = DateEx(Calendar.getInstance,diff)
    def DateEx(calendar:Calendar,diff:Int):String = {
        calendar.add(Calendar.SECOND,diff)
        formatter.format(calendar.getTime)
    }
    def main(args:Array[String]):Unit = {
        try {
            args.length match {
                case 2 => println(DateEx(args(0),args(1).toInt))
                case 1 => println(DateEx(args(0).toInt))
                case _ => println(DateEx("20080827235925",40))
            }
        } catch {
            case ex:ParseException => println("invalid date format.")
            case ex => ex.printStackTrace
        }
    }
}

[ Scala ] [ download code ] ]

lunlumo's comment on tailの実装

tailの実装 (Nested Flatten)

　オプションの処理にかなり場所をとられてしまっていますが...。

import    java.io.FileNotFoundException
import    java.io.File
import    java.io.FileInputStream
import    scala.collection.mutable.HashMap

class InvalidArgumentException extends Exception {}

class GetOpt(f:String) {
    var    _params:List[Tuple2[String,Boolean]] = null
    var    _opt:HashMap[Any,Any] = null
    var    _rest:Array[String] = null
    
    _params = f.toList.foldLeft(List[Tuple2[String,Boolean]]()) { (l,c) =>
        c match {
            case ':' => l match {
                case List() => throw new InvalidArgumentException
                case h::r => (h._1,true)::r
            }
            case k => (k.toString,false)::l
        }
    }.reverse
    
    def parse(a:Array[String]):GetOpt = {
        def _parse(o:HashMap[Any,Any],l:List[String]):Tuple2[HashMap[Any,Any],List[String]] = l match {
            case List() => (o,List())
            case h::r => h.toList match {
                case '-'::k => {
                    _params.find { e => e._1 == new String(k.toArray) } match {
                        case Some(Tuple2(_,true)) => {
                            if (r.size == 0) throw new InvalidArgumentException
                            o.update(new String(k.toArray),r.head)
                            _parse(o,r.tail)
                        }
                        case Some(Tuple2(_,false)) => {
                            o.update(new String(k.toArray),true)
                            _parse(o,r)
                        }
                        case _ => throw new InvalidArgumentException
                    }
                }
                case _ => (o,l)
            }
        }
        _parse(new HashMap[Any,Any],a.toList) match {
            case Tuple2(o,r) => { _opt = o; _rest = r.toArray }
        }
        this
    }
    
    def getopt(k:String):Any = _opt.isDefinedAt(k) match {
        case true => _opt.apply(k)
        case _ => false
    }
    
    def rest:Array[String] = _rest
}

class CTail(n:Int,f:Boolean,i:File) {
    
    val    s:FileInputStream = new FileInputStream(i)
    
    def this(o:GetOpt) =this(o.getopt("n") match { case Some(false) => 10; case n => n.asInstanceOf[String].toInt },o.getopt("f").asInstanceOf[Boolean],new File(o.rest.apply(0)))
    
    def tailn:Unit = {
        
        val    BUF_SIZE:Int = 4096
        val    e:Long = i.length
        
        def _tailn(p:Long,n:Int,b:Array[Byte]):Array[Byte] = {
            var    t:Array[Byte] = null
            var    l:Int = n
            (p > BUF_SIZE) match {
                case true => {
                    t = new Array[Byte](BUF_SIZE)
                    s.getChannel.position(p - BUF_SIZE)
                    s.read(t,0,BUF_SIZE)
                }
                case _ => {
                    t = new Array[Byte](p.toInt)
                    s.read(t,0,p.toInt)
                }
            }
            t = t.reverse.takeWhile { c => if (c == '\n') l = l - 1; (l > 0) }.reverse
            ((p <= BUF_SIZE) || (l == 0)) match {
                case true => t ++ b
                case _ => _tailn(p - BUF_SIZE, l, t ++ b)
            }
        }
        
        print(new String(_tailn(e, n, new Array[Byte](0))))
        s.getChannel.position(e)
    }
    
    def tailf:Unit = {
        def _tailf(b:List[Byte]):List[Byte] = {
            val    c:Int = s.read
            (c >= 0) match {
                case true => _tailf(b + c.toByte)
                case _ => b
            }
        }
        print(new String(_tailf(List[Byte]()).toArray))
        Thread.sleep(100)
        tailf
    }
    
    def tail:CTail = {
        tailn
        if (f) tailf
        this
    }
    
    def close:Unit = s.close
}

object Tail {
    def main(args:Array[String]):Unit = {
        try {
            val    o:GetOpt = new GetOpt("n:f").parse(args)
            (new CTail(o)).tail.close
        } catch {
            case e:InvalidArgumentException => println("usage: scala Tail [-n <number of lines>] [-f] file")
            case e:FileNotFoundException => print("file not found.")
            case e:Exception => e.printStackTrace
        }
    }
}

[ Scala ] [ download code ] ]

lunlumo's comment on LL Golf Hole 7 - バイト数を読みやすくする

LL Golf Hole 7 - バイト数を読みやすくする (Nested Flatten)

scalaで書く甲斐の無い感じのソースですが...。

1	val v=args(0);val w=(v.size-1)/3;printf("%.1f%c",v.toDouble/Math.pow(1000,w)," kMGTPEZY"(w))

[ Scala ] [ download code ] ]

lunlumo's comment on LL Golf Hole 8 - 横向きのピラミッドを作る

LL Golf Hole 8 - 横向きのピラミッドを作る (Nested Flatten)

インタプリタ起動もできるのですねぇ...。知りませんでした。

1	val n=readInt;for(i<-(-n+1 to n-1))println(""(n-i.abs))

[ Scala ] [ download code ] ]

keisuken's comment on LL Golf Hole 6 - 10進数を2進数に基数変換する

LL Golf Hole 6 - 10進数を2進数に基数変換する (Nested Flatten)

効率無視、副作用なし、ユーティリティメソッドを使わないを目標に作っています。
scala h6.scala 1234 などで動作させます。

1 2	def b(i:Int,s:String):String=if(i>0) b(i/2,""+(i%2)+s) else s println(b(args(0).toInt,""))

[ Scala ] [ download code ] ]

keisuken's comment on LL Golf Hole 1 - tinyurl.comを使ってURLを短縮する

LL Golf Hole 1 - tinyurl.comを使ってURLを短縮する (Nested Flatten)

かなり無駄なバージョン。
GETですけどAPIを使わずにTinyURLを取得して、Regexで抜き出してます。
scala h13.scala で動かします。

import io._
val url="http://ll.jus.or.jp/2008/info/xgihyo"
val t=new StringBuilder;for(c<-Source.fromURL("http://tinyurl.com/create.php?url="+url))t.append(c);
val r="""(?is).*characters:\s+<blockquote><b>([^\s]*)</b><br>.*</blockquote>.*""".r
t.toString match{case r(tu)=>println(tu) case _ =>}

[ Scala ] [ download code ] ]

keisuken's comment on LL Golf Hole 7 - バイト数を読みやすくする

LL Golf Hole 7 - バイト数を読みやすくする (Nested Flatten)

サンプルと同じく1000で単位を揃えています。
いつものごとくひねりはありません。再帰呼出でループを表現しています。
あまり大きな数になると表示がおかしくなります:-)。
scala h7.scala 1234.5 で動作させます。

val b=args(0).toDouble
val u=" kMGTPEZY"
def p(d:Double,c:Int){if(d<1000D||c==(u.length-1))printf("%.1f%c",d,u(c))else p(d/1000D,c+1)}
p(b,0)

[ Scala ] [ download code ] ]