DouKaku?beta

Language detail: Scala

Coverage: 89.62%
number of '+' ratings
 contribution for coverage

Unsolved challenges

show all

codes

Feed

Used modules

next >>

手作業Grep (Nested Flatten)

　scalaがまだの様なので。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import    scala.swing.{BorderPanel, Button, ListView, FlowPanel, MainFrame, Menu, MenuBar, MenuItem, ScrollPane, SimpleGUIApplication}
import    scala.swing.event.{ActionEvent, ButtonClicked}

class HandGrepFrame(var lines:List[String]) extends MainFrame {
    
    title = "Hand Grep"
    
    menuBar = new MenuBar
    
    val    menu:Menu = new Menu("file")
    val    quitMenu:MenuItem = new MenuItem("quit")
    
    menu.contents += quitMenu
    menuBar.contents += menu
    
    val    list:ListView[String] = new ListView(lines)
    val    quit:Button = new Button("quit")
    
    contents = new BorderPanel {
        
        import BorderPanel.Position._
        
        layout(new ScrollPane(list)) = Center
        layout(new FlowPanel(FlowPanel.Alignment.Right) { contents += quit }) = South
    }
    
    listenTo(quitMenu, quit)
    reactions += {
        case ActionEvent(`quitMenu`) | ButtonClicked(`quit`) => quitHandler
    }
    
    preferredSize = (600, 480)
    pack
    
    def quitHandler:Unit = {
        list.selection.items.foreach(Console.println)
        System.exit(0)
    }
}

object HandGrep extends SimpleGUIApplication {
    val    lines:List[String] = readLines
    def readLines:List[String] = Console.in.ready match {
            case false => List[String]()
            case _ => Console.readLine :: readLines
        }
    def top = new HandGrepFrame(lines)
}
メソッド数の多い組み込みクラスを列挙 (Nested Flatten)
　scala-library.jarとscala-swing.jarについて調べてみました。Java側のリフレクションを使って調べているので，ソースコード上の値とはずれがあります。

total:  3173
scala.swing.Key:        206
scala.collection.jcl.Buffer$Projection: 166
scala.collection.jcl.ArrayList: 158
scala.collection.jcl.LinkedList:        158
scala.collection.jcl.Buffer$$anon$2:    155
scala.collection.jcl.SortedMap$$anon$1: 153
scala.collection.jcl.TreeMap:   153
scala.collection.jcl.SortedMap$$anon$2: 151
scala.collection.jcl.Buffer$Range:      150
scala.collection.jcl.TreeSet:   146 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import scala.collection.jcl.Conversions
import java.io.File
import java.util.Collections
import java.util.jar.{JarEntry,JarFile}

object MethodCount {
    def getClassInformations(l:List[String]):List[Pair[String,Int]] = {
        def getInfo(n:String):Pair[String,Int] =
            try { (n, Class.forName(n).getDeclaredMethods.size) } catch { case _ => (n, -1) }
        def isClass(n:String):Boolean = n.endsWith(".class") && !n.matches("\\$\\$anonfun\\$")
        def getClassName(n:String):String = n.substring(0, n.length - 6).replace('/', '.')
        def getJarEntries(f:File):List[JarEntry] =
            Conversions.convertList(Collections.list((new JarFile(f)).entries)).toList
        def getFiles(l:List[String]):List[File] =
            l.map(new File(System.getProperty("scala.home"), _)).filter(_.exists)
        getFiles(l).map(getJarEntries).flatten(identity(_)).map(_.getName).filter(isClass).map(getClassName).map(getInfo)
    }
    def main(args:Array[String]):Unit = {
        val l:List[Pair[String,Int]] = getClassInformations(List("lib/scala-library.jar", "lib/scala-swing.jar"))
        Console.printf("total:\t%d\n", l.size)
        l.sort(_._2 > _._2).take(10).foreach((i) => Console.printf("%s:\t%d\n", i._1, i._2))
    }
}
HTTPでGET　その2 (Nested Flatten)

プロパティをいじる方法で、Sourceを使ってみました。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import scala.io.Source

System.setProperty("http.proxyHost","proxy.server.jp")
System.setProperty("http.proxyPort","8080")

println(
  Source.fromURL("http://ja.doukaku.org/feeds/comments/")
        .getLines
        .mkString
       )
printf書式変換 (Nested Flatten)

完成度低めですが、ErlangとCの書式変換など。 はじめ、Erlangで書こうとしたが挫折。 ScalaのExtractorで実装しはじめたものの、 Erlangの書式の柔軟さに負けた感のある今日この頃。

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
// printf書式文字列変換(お題 : http://ja.doukaku.org/259/)
// 
// Erlangの書式文字文字列  <--> C言語の書式文字列
// コマンドラインargs先頭で処理を指定、残りの引数で書式指定
// c2e : C --> Erlang
// e2c : Erlang --> C
// 例)
//    c2e %f  %020d  %.20d %+20.10d  %-20f %-20.10f
//    e2c ~f  ~20.0p ~.20p ~20.10p   ~-20f ~-20.10f
//    e2c ~10s ~-10s ~10.3.+s ~10.10.+s ~10.7.+s
//    ( ~10.3.+s ~10.10.+s ~10.7.+s はCの書式では正確に対応できません )
object Main {
  def main(args : Array[String]) : Unit = {
    args.toList match {
      case "e2c" :: xs =>
        for(x<-xs ; ErlFormatTerm(flag,termF,termP,termPad,termMod,termC) = x ) {
          //println(flag,termF,termP,termPad,termMod,termC)
          print (x + " ---> ")
          val flags = (flag,termPad) match{
            case ("-","" ) => "-"
            case ("-"," ") => "-"
            case ("-","0") => "-"
            case ("" ," ") => " "
            case ("" ,"0") => "0"
            case _ => ""
          }
          
          termC match {
            case "B" if termP=="8"  => println ( CFormatTerm(flags,termF,   "","o") )
            case "B" if termP=="16" => println ( CFormatTerm(flags,termF,   "","x") )
            case "c"                => println ( CFormatTerm(flags,termF,termP,"c") )
            case "s"                => println ( CFormatTerm(flags,termF,termP,"s") )
            case "f"                => println ( CFormatTerm(flags,termF,termP,"f") )
            case "e"                => println ( CFormatTerm(flags,termF,termP,"e") )
            case "g"                => println ( CFormatTerm(flags,termF,termP,"g") )
            //
            case _                  => println ( "未対応" )
          }
        }
      case "c2e" :: xs =>
        for(x<-xs ; CFormatTerm(flags,fieldWidth,precision,specifier) = x ) {
          print (x + " ---> ")
          val pad = flags match{
            case "+" => ""
            case "-" => ""
            case " " => ""
            case "0" => "0"
            case _ => ""
          }
          val flag = flags match{
            case "-" => "-"
            //
            case "+" => ""
            case " " => ""
            case "0" => ""
            case _   => ""
          }
          specifier match{    // F P Pad Mod C
            case "d" | "i" => println ( ErlFormatTerm(flag,fieldWidth,precision,pad,"","p") )
            case "u"       => println ( ErlFormatTerm(flag,fieldWidth,precision,pad,"","p") )
            case "o"       => println ( ErlFormatTerm(flag,fieldWidth,      "8", "","","B") )
            case "x"       => println ( ErlFormatTerm(flag,fieldWidth,     "16", "","","B") )
            case "X"       => println ( ErlFormatTerm(flag,fieldWidth,     "16", "","","B") )
            case "f"       => println ( ErlFormatTerm(flag,fieldWidth,precision, "","","f") )
            case "e" | "E" => println ( ErlFormatTerm(flag,fieldWidth,precision, "","","e") )
            case "a" | "A" => println ( ErlFormatTerm(flag,fieldWidth,precision, "","","p") )
            case "g" | "G" => println ( ErlFormatTerm(flag,fieldWidth,precision, "","","g") )
            case "c"       => println ( ErlFormatTerm(flag,fieldWidth,precision,pad,"","c") )
            case "s"       => println ( ErlFormatTerm(flag,fieldWidth,precision,pad,"","s") )
            case "N"       => println ( ErlFormatTerm(flag,fieldWidth,precision, "","","p") )
            case "p"       => println ( ErlFormatTerm(flag,fieldWidth,     "16","0","","B") )
            //case "%"       => 
            case _         => println ( "未対応" )
          }
       }
       case Nil =>
       case _ =>
    }
    ()
  }
}

object ErlFormatTerm{
  // F.P.PadModC
  def apply(flag :String   ,
            termF:String   , 
            termP:String   , 
            termPad:String , 
            termMod:String , 
            termC:String) : String = {
    val tail = termMod+termC
    (termF,termP,termPad) match {
      // fmt0
      case ("" ,"",_)  => "~"+tail
      //
      // fmt1
      case (f  ,"", "") if f != "" => "~" + flag + f + tail
      // fmt2
      case (f  ,"",pad) if f != "" => "~" + flag + f +"."+pad+ tail
      //
      // fmt3
      case ("" , p,  _) if p != "" => "~."+p + tail
      //
      // fmt4
      case (f  , p, "")            => "~"+ flag + f+"."+p        +tail
      // fmt5
      case (f  , p,pad)            => "~"+ flag + f+"."+p+"."+pad+tail
    }
  }
  //
  def unapply(format:String) : Option[(String,String,String,String,String,String)] ={
    if ( format(0) != '~' ) return None
    val reFmt0 = """~([^.\d])""".r                     // ~s
    val reFmt1 = """~(-?)(\d+)([^.\d])""".r              // ~10s , ~-10s
    val reFmt2 = """~(-?)(\d+)\.(.)([^.\d])""".r         // ~10.+s
    val reFmt3 = """~\.(\d+)([^.\d])""".r              // ~.5s
    val reFmt4 = """~(-?)(\d+)\.(\d+)([^.\d])""".r      // ~-10.5s
    val reFmt5 = """~(-?)(\d+)\.(\d+)\.(.)([^.\d])""".r // ~-10.5.+s
    //
    format match {
      case reFmt0(                    termC)      => Some(""  ,   "","",        "","",termC)
      case reFmt1(flag,termF         ,termC)      => Some(flag,termF,"",        "","",termC)
      case reFmt2(flag,termF,termPad ,termC)      => Some(flag,termF,"",   termPad,"",termC)
      case reFmt3(           termP        ,termC) => Some(""  ,   "","",        "","",termC)
      case reFmt4(flag,termF,termP        ,termC) => Some(flag,termF,termP,     "","",termC)
      case reFmt5(flag,termF,termP,termPad,termC) => Some(flag,termF,termP,termPad,"",termC)
      case _ => None
    }
  }
}

object CFormatTerm{
  // %[flags][fieldWidth][.precision]specifier
  def apply(flags:String     , 
            fieldWidth:String, 
            precision:String , 
            specifier:String ) : String = {
    "%"+flags+fieldWidth + {if(precision!="") "."+ precision else ""} +specifier
  }
  //
  def unapply(format:String) : Option[(String,String,String,String)] ={
    if ( format(0) != '%' ) return None
    //
    val reFmt0 = """%([a-zA-Z])""".r
    val reFmt1 = """%([-+ 0#])([\d*]+)([a-zA-Z])""".r
    val reFmt2 = """%([\d*]+)([a-zA-Z])""".r
    val reFmt3 = """%([-+ 0#])([\d*]+)\.([\d*]+)([a-zA-Z])""".r
    val reFmt4 = """%([\d*]+)\.([\d*]+)([a-zA-Z])""".r
    val reFmt5 = """%\.([\d*]+)([a-zA-Z])""".r
    format match {
      case reFmt0(                           specifier) => Some(   "",        "",       "",specifier)
      case reFmt1(flags,fieldWidth,          specifier) => Some(flags,fieldWidth,       "",specifier)
      case reFmt2(      fieldWidth,          specifier) => Some(   "",fieldWidth,       "",specifier)
      case reFmt3(flags,fieldWidth,precision,specifier) => Some(flags,fieldWidth,precision,specifier)
      case reFmt4(      fieldWidth,precision,specifier) => Some(   "",fieldWidth,precision,specifier)
      case reFmt5(                 precision,specifier) => Some(   "",        "",precision,specifier)
      case _ => None
    }
  }
}
loan patternのサンプル (Nested Flatten)

Java版(#9162)をScalaに移植しました。 これはこれで味わい深いです。 ありがとうございました。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Java版#9162を移植
import java.io._

case class WithResource[T<:Closeable]( resource:T ) {
    def using[F<:Runnable](f:F) : Unit= {
        try {
            f.run();
        } finally {
            resource.close();
        }
    }
}

object Main{
    def main(args:Array[String]) : Unit = {
        val wr = WithResource(  new PrintWriter(
                                new BufferedWriter(
                                new OutputStreamWriter(System.out))))
        wr.using(new Runnable{
                    override def run():Unit = {
                        wr.resource.print("この文字列はflushしないと書き出されない");
                        wr.resource.print("（closeし忘れは良くある間違い）。");
                    } } )
    }
}
複素数 (Nested Flatten)

#8851をパラメタ付に改造してみました。 Complex[Int],Complex[Double]

もう、ぐだぐだ。

制限事項 整数と実数の混合ができない orz

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
// 複素数(お題:http://ja.doukaku.org/247/)
// http://ja.doukaku.org/comment/----/
// snaさん作を改変( : http://ja.doukaku.org/comment/8851/)
// 参考 : http://en.literateprograms.org/Complex_numbers_(Scala)

trait Arithmetic[T<:AnyVal]{
  def unary_+ : T
  def unary_- : T
  def + (that:T):T
  def - (that:T):T
  def * (that:T):T
  def / (that:T):T
  def abs : T
  //
  def lt0 : Boolean  // >   0
  def gt0 : Boolean  // <   0
  def eq0 : Boolean  // ==  0
  //
  def eqp1 : Boolean // ==  1
  def eqm1 : Boolean // == -1
  //
}

case class Complex[ T<%Arithmetic[T] ](real:T, imag:T) {
  // +(a + bi) = (a + bi)
  def unary_+ = this
  
  // -(a + bi) = (-a - bi)
  def unary_- = Complex[T](-real, -imag)
  
  // (a + bi) + (c + di) = (a + c) + (b + d)i
  def + (that: Complex[T]) = Complex(this.real + that.real, this.imag + that.imag)
  
  // (a + bi) - (c + di) = (a - c) + (b - d)i
  def - (that: Complex[T]) = Complex(this.real - that.real, this.imag - that.imag)
  
  // (a + bi) * (c + di) = (ac - bd) + (bc + ad)i
  def * (that: Complex[T]) = {
    val Complex(a, b) = this
    val Complex(c, d) = that
    Complex(a*c - b*d, b*c + a*d)
  }
  
  // (a + bi) / (c + di) = (ac + bd) / (c^2 + d^2) + (bc - ad) / (c^2 + d^2)
  def / (that: Complex[T]) = {
    val Complex(a, b) = this
    val Complex(c, d) = that
    val deno = c*c + d*d
    Complex((a*c + b*d) / deno, (b*c - a*d) / deno)
  }
  
  // Conjugate
  def conjugate() : Complex[T] = Complex(real,-imag)
  
  override def toString = this match {
    case Complex(re, im) if im.eq0            => re.toString
    case Complex(re, im) if re.eq0 && im.eqp1 => "i"
    case Complex(re, im) if re.eq0 && im.eqm1 => "-i"
    case Complex(re, im) if re.eq0            => im.toString + "i"
    case Complex(re, im) if           im.eqp1 => re.toString + " + i"
    case Complex(re, im) if           im.eqm1 => re.toString + " - i"
    case Complex(re, im) if           im.gt0  => re.toString + " + " + im.toString + "i"
    case Complex(re, im) if           im.lt0  => re.toString + " - " + im.abs.toString + "i"
  }

}

object test{
  implicit def int2Arithmeic(n:Int) : Arithmetic[Int] = 
                    new Arithmetic[Int]{
                         def unary_+ : Int  = n.unary_+
                         def unary_- : Int  = n.unary_-
                         def + (that:Int):Int = n+that
                         def - (that:Int):Int = n-that
                         def * (that:Int):Int = n*that
                         def / (that:Int):Int = n/that
                         def abs = Math.abs(n)
                         //
                         def lt0 = n<0
                         def gt0 = n>0
                         def eq0 = n==0
                         //
                         def eqp1 = n==1 
                         def eqm1 = n== -1  }
  
  implicit def double2Arithmeic(n:Double) : Arithmetic[Double] = 
                    new Arithmetic[Double]{
                         def unary_+ : Double  = n.unary_+
                         def unary_- : Double  = n.unary_-
                         def + (that:Double):Double = n+that
                         def - (that:Double):Double = n-that
                         def * (that:Double):Double = n*that
                         def / (that:Double):Double = n/that
                         def abs = Math.abs(n)
                         //
                         def lt0 = n<0
                         def gt0 = n>0
                         def eq0 = n==0
                         //
                         def eqp1 = n==1 
                         def eqm1 = n== -1  }
  
  implicit def int2Complex   (n:Int   ):Complex[Int   ] = Complex(n,0)
  implicit def double2Complex(n:Double):Complex[Double] = Complex(n,0)
  implicit def icomp2dcomp   (z:Complex[Int]):Complex[Double] = Complex(z.real,z.imag)
  
  implicit def dcomp2richer  (z:Complex[Double]) = new Proxy{
       val self=z
       def abs = self match {
         case Complex(re, im) => Math.sqrt(re*re + im*im)
       }
    }
  
  implicit def icomp2richer  (z:Complex[int]) = new Proxy{
       val self=z
       def abs = self match {
         case Complex(re, im) => Math.sqrt(re*re + im*im)
       }
    }
  
  
  def main( args:Array[String] ) : Unit = {
    {
      val i = Complex(0,1)
      println( (3 + i  ) + (4 - i  ) )
      println( (5 - 9*i) - (2 + 6*i) )
      println( (5 + 3*i) * (5 + 8*i) )
      println( (9 - 7*i) / (9 - 3*i) )
      println( (2 + 3*i).abs         )
    }
    
    {
      val i = Complex(0.,1.)
      println( (3. + i  ) + (4. - i  ) )
      println( (5. - 9.*i) - (2. + 6.*i) )
      println( (5. + 3.*i) * (5. + 8.*i) )
      println( (9. - 7.*i) / (9. - 3.*i) )
      println( (2. + 3.*i).abs         )
    }
  }
}
ポリゴンを表示するプログラム (Nested Flatten)

#6023をscalaに移植しました。 またしても、java-->scala移植の暗黒面に・・・

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
import scala.swing._

import javax.media.j3d._
import javax.vecmath._
import com.sun.j3d.utils.universe._
import com.sun.j3d.utils.geometry.ColorCube

@SuppressWarnings(Array("serial"))
object Sample3D {
    def createSceneGraph() :BranchGroup = {
        val objRoot = new BranchGroup();

        val objTrans = new TransformGroup();
        objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
        objRoot.addChild(objTrans);

        val axis = new Transform3D();
        axis.rotZ(Math.Pi / 2);
        val bounds = new BoundingSphere(new Point3d(), 100.0);
        
        var rotator = new RotationInterpolator(
                new Alpha(-1,20 * 4000) , 
                objTrans , 
                axis     , 
                0.0F     , 
                (Math.Pi * 2.0).toFloat);
        rotator.setSchedulingBounds(bounds);
        objRoot.addChild(rotator);

        val objTrans2 = new TransformGroup();
        objTrans2.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
        objTrans.addChild(objTrans2);
        rotator = new RotationInterpolator(new Alpha(-1, 4000), objTrans2);
        rotator.setSchedulingBounds(bounds);
        objRoot.addChild(rotator);

        objTrans2.addChild(new ColorCube(0.4));
        objRoot.compile();
        return objRoot;
    }
}

object Main extends SimpleGUIApplication {
    val config = SimpleUniverse.getPreferredConfiguration();
    val canvas = new Canvas3D(config);
    
    //create frame window
    def top=new MainFrame{
      peer.setBounds(10, 10, 480, 480)
      //caption
      title = "Sample3D with Scala/Java3D"
      
      val contentPane = peer.getContentPane()
      contentPane.setLayout(new java.awt.BorderLayout());
      contentPane.add(canvas,java.awt.BorderLayout.CENTER)
      
    } // end of MainFrame
    
    val scene = Sample3D.createSceneGraph();
    val universe = new SimpleUniverse(canvas);
    universe.getViewingPlatform().setNominalViewingTransform();
    universe.addBranchGraph(scene);
    
}
2次元ランダムウォーク (Nested Flatten)

scala.swingに移植してみました。

GUI以外の変更点 ・saveのprintfのArrayを可変引数に。 ・基本型の名前をscalaっぽく :)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
// 2次元ランダムウォーク(お題:http://ja.doukaku.org/193/)
// scala.swing版
// (lunlumoさん作を改変 http://ja.doukaku.org/comment/7012/)

import swing._
import swing.event._

import  java.awt.Color
import  java.awt.Dimension
import  java.awt.FlowLayout
import  java.awt.Graphics
import  java.awt.Point

import  java.io.BufferedWriter
import  java.io.File
import  java.io.FileOutputStream
import  java.io.OutputStreamWriter
import  java.io.PrintWriter
import  java.util.Random

class RandomWalk(step:Int) {
    private var _trace:List[Point] = null
    private val rand:Random = new Random
    
    def walk:RandomWalk = {
        var p = new Point(0,0)
        trace = (new Range(1,step,1)).map[Point] { i => p = move(p); p }.toList
        this
    }
    
    private def move(p:Point):Point = rand.nextInt(4) match {
        case 0 => new Point(p.x + 1, p.y)
        case 1 => new Point(p.x - 1, p.y)
        case 2 => new Point(p.x, p.y + 1)
        case 3 => new Point(p.x, p.y - 1)
        case _ => p
    }
    
    def trace_=(trace:List[Point]) = { _trace = trace }
    def trace = _trace
}


class RWPanel extends Panel {
    var _trace:List[Point] = null
    
    def trace_=(trace:List[Point]) = { _trace = trace }
    def trace = _trace
    
    override def paint(g:Graphics):Unit = {
        val max:Int = trace.foldLeft(0) { (m,p) => List(p.x,p.y).foldLeft(m) { (m,l) => Math.max(m,Math.abs(l)) } }
        val pitch:Double = peer.getWidth.asInstanceOf[Double] / (max * 2)
        
        def drawLine(c:Point,trace:List[Point]):Unit = {
            trace match {
                case List() => ()
                case (p::rest) => {
                    g.drawLine(
                            (c.x * pitch).asInstanceOf[Int] + peer.getWidth / 2,
                            peer.getWidth / 2 - (c.y * pitch).asInstanceOf[Int],
                            (p.x * pitch).asInstanceOf[Int] + peer.getWidth / 2,
                            peer.getWidth / 2 - (p.y * pitch).asInstanceOf[Int]
                        )
                    drawLine(p,rest)
                }
            }
        }
        
        g.clearRect(0,0,peer.getWidth,peer.getHeight)
        g.setColor(Color.BLACK)
        
        drawLine(new Point(0,0),trace)
    }
}

class Plotter(title:String,step:Int) extends Panel {
    
    var walker = (new RandomWalk(step)).walk
    var _panel:RWPanel = null
    
    def panel_=(panel:RWPanel) = { _panel = panel }
    def panel = _panel
    
    def walk:Unit = {
        walker.walk
        panel.trace = walker.trace
    }
    def do_walk:Unit = {
        walk
        panel.repaint()
    }
    def save:Unit = {
        val fc = new FileChooser()
        
        try {
            if (fc.showSaveDialog( this ) == FileChooser.Result.Approve) {
                val f= fc.peer.getSelectedFile
                val w = new PrintWriter(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(f))))
                
                def writeTrace(trace:List[(int,Point)]):Unit = {
                    trace match {
                        case List() => ()
                        case (i::rest) => {
                            w.printf("%d\t%d\t%d\n",Integer.valueOf(i._1),Integer.valueOf(i._2.x),Integer.valueOf(i._2.y))
                            writeTrace(rest)
                        }
                    }
                }
                
                writeTrace((new Range(1,walker.trace.size,1)).toList.zip(walker.trace))
                w.close
            }
        } catch {
            case e => e.printStackTrace
        }
    }
    def quit:Unit = {
        System.exit(0)
    }
}

object Main extends SimpleGUIApplication{
    var p = new Plotter("random walk",10000)
    val pp = new RWPanel{
      peer.setPreferredSize(new Dimension(300,300))
    }
    p.panel = pp
    
    //create frame window
    def top=new MainFrame{
      peer.setResizable(false)
      //--------------------------------------------------------------
      // caption
      title = "Random walk"
      //--------------------------------------------------------------
      // menu bar
      menuBar = new MenuBar{
        //--------------------------------
        // file menu
        contents += new Menu("file"){
          contents += new MenuItem( Action("save"){p.save} )
          contents += new MenuItem( Action("quit"){p.quit} )
        }// end of file-menu
        //--------------------------------
          
        //--------------------------------
        // file menu
        contents += new Menu("walk"){
          contents += new MenuItem( Action("walk"){p.do_walk} )
        }
      } // enf of menu
      contents = new BorderPanel{
        add(pp,BorderPanel.Position.Center)
        add(new FlowPanel{
              contents += new Button(Action("walk"){ p.do_walk })
              contents += new Button(Action("save"){ p.save })
            }// 
        ,BorderPanel.Position.South)
      } // end of contents(BorderPanel)
    } // end of MainFrame
    p.walk
}
loan patternのサンプル (Nested Flatten)
C#/VB.NETのusingに憧れて作った、Scala用のusing構文です。
IDisposableのような統一的な解放インターフェースが無いので、closeメソッドやdisposeメソッドを持つオブジェクトを対象にします。 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
import java.io._

object UsingSyntax {
  
  trait Disposing[-A] extends (A => Unit)
  
  // closeメソッドを持つオブジェクトの解放方法を定義
  implicit val closeDefinedDisposing = new Disposing[{def close(): Unit}] {
    def apply(target: {def close(): Unit}) = target.close()
  }
  // disposeメソッドを持つオブジェクトの解放方法を定義
  implicit val disposeDefinedDisposing = new Disposing[{def dispose(): Unit}] {
    def apply(target: {def dispose(): Unit}) = target.dispose()
  }
  // 自分で解放方法を指定する場合の変換
  // using (obj) { 処理... } { (_: MyDisposable).myDispose() }
  implicit def functionToDisposing[A](f: A => Any): Disposing[A] =
  new Disposing[A] {
    def apply(target: A): Unit = f(target)
  }
  
  def using[A, R](a: A)(block: A => R)(implicit disposing: Disposing[A]): R = {
    try {
      block(a)
    }
    finally {
      disposing(a)
    }
  }
  
}

object Doukaku258 {
  import UsingSyntax._
  
  def main(args: Array[String]): Unit = {
    
    // ファイルからテキストを読み込んで全部表示
    // 使い終わったらファイルを閉じる
    using (new FileInputStream("test.txt")) { in =>
      using (new InputStreamReader(in, "UTF-8")) { rd =>
        
        val buf = new Array[Char](512)
        var n = 0
        while ({n = rd.read(buf); n > 0}) {
          print(buf.take(n).mkString)
        }
        
        // 処理中に例外が発生してもファイルは閉じる
        throw new Exception()
        
      }
    }
    
  }
  
}
与えられた文字列でピラミッド (Nested Flatten)

文字列をリストに変換せずにやってみた。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
object MojiPira {
  def main(args : Array[String]) : Unit = {
    pyramid(args(0))
  }
  def pyramid(moji:String) = {
    val m    = moji.length
    mojiPira(" "*(m-1),"",moji.reverse){print _}
  }
  def mojiPira(mergin:String,prevPrn:String,s:String)(prn:String=>Unit) : Unit = {
      val prnStr = if (prevPrn=="") ""+s(0) else s(0) + " " + prevPrn
      prn(mergin + prnStr + mergin + "\n")
      if( mergin!="" )
        mojiPira(mergin.substring(1),prnStr,s.substring(1))(prn)
  }
}
loan patternのサンプル (Nested Flatten)

メモリマップをFileダンプにつかってみました。 （バッファをloanする）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
import java.io._
import java.nio._
import java.nio.channels._

object LoanSample{
  def main(args : Array[String]) : Unit = {
    FileLoan.viewFileAsBuffer(args(0)){ byteBuffer =>
        //      "012345678:---
        val maxPos  = byteBuffer.limit()
        var viewLine=""
        println("          0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F")
        for{ i <-0 until byteBuffer.limit() by 16
             j <-0 until 16
             pos = i + j }{
          if(j== 0){
            print(pos.formatted("%08X: "))
            viewLine = ""
          }
          if( pos<byteBuffer.limit() ){
            val b = byteBuffer.get(pos)
            val c = b.toChar
            print( b.formatted("%02X ") )
            viewLine += (if( c.isControl ) "." else ""+c)
          }else{
            print(                                "    "  )
            viewLine += " "
          }
          if(j==15){
            println( viewLine )
            viewLine = ""
          }
        }
        ()
    }
  }
}

object FileLoan{
  def viewFileAsBuffer(fileName:String)(op:ByteBuffer=>Unit) : Unit = {
    var channel:FileChannel = null
    var buffer :ByteBuffer  = null
    try{
      channel = new FileInputStream(fileName).getChannel()
      buffer  = channel.map(FileChannel.MapMode.READ_ONLY , 0 , channel.size())
      op( buffer )
    }catch{
      case e:Exception =>{
          println(channel,buffer)
          println(e)
        }
      case _ =>
    }finally{
      buffer  = null
      channel = null
    }
  }
}

少し、ひねってみました。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import java.net._

object LoanSample {
  def main(args : Array[String]) : Unit = {
    SocketLoan.usingSocketOf(
               ("ja.doukaku.org",80),
               ("http://ja.doukaku.org/",80), //<---勘違い
               ("\\.org",80), // <---たまに、異常なデータ
               ("labs.cybozu.co.jp",80) ){ (serverName,port,sock) =>
        println( sock )
        // ここにいろいろな処理
        // そして、たまに、間違う
        var a = 1/0 // ---> java.lang.ArithmeticException
        // ここにいろいろな処理
        ()
    }
  }
}

object SocketLoan{
  def usingSocketOf(hosts:(String,Int)*)( op:(String,Int,Socket)=>Unit ):Unit={
    for((serverName,port)<-hosts){
      println("using "+ serverName)
      usingSocketOf(serverName,port)(op(serverName,port,_))
      println("used "+ serverName)
    }
  }
  def usingSocketOf(serverName:String,port:Int)(op:Socket=>Unit) : Unit = {
    try{
      println("opening")
      val sock = new Socket(serverName,port)
      println("opened")
      //-------------------------------
      try{
        // loan it
        op(sock)
      }catch{
        case e:Exception => println("err inside loan : "+e)
        case _ =>
      }
      //-------------------------------
      println("closing")
      sock.close()
      println("closed")
    }catch{
      case e:Exception => println("err outside loan"+ e)
      case _ =>
    }
  }
}

妙なところに投稿してしまっていたようです。すみません。 ネットワークプログラムは不慣れなところがありますので、ビシィっと指導してくださいませ。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//loan patternのサンプル
//お題:http://ja.doukaku.org/258/

import java.net._

object LoanSample {
  def main(args : Array[String]) : Unit = {
    SocketLoan.processWith("ja.doukaku.org",80){
      sock=>
        println( sock )
        // ここにいろいろな処理
        // そして、たまに、間違う
        var a = 1/0 // ---> java.lang.ArithmeticException
        // ここにいろいろな処理
        ()
    }
  }
}

object SocketLoan{
  def processWith(serverName:String,port:Int)(op:Socket=>Unit) : Unit = {
    try{
      val sock = new Socket(serverName,port)
      //-------------------------------
      try{
        // loan it
        op(sock)
      }catch{
        case e:Exception => println("err inside loan : "+e)
        case _ =>
      }
      //-------------------------------
      sock.close()
    }catch{
      case e:Exception => println("err outside loan"+ e)
      case _ =>
    }
  }
}
IPv4アドレスのマスクの変換 (Nested Flatten) 
#9133の移植です。
便利なクラスがあるんですねえ。
勉強になりました。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Java版(#9133)の移植です。
import java.net._
import java.math._
import java.io._

object IPNetMask9133 {
  def main(args : Array[String]) : Unit = {
    System.out.println(maskLength(InetAddress.getByName("255.255.255.0")));
    System.out.println(maskLength(InetAddress.getByName("255.255.255.128")));
    System.out.println(maskLength(InetAddress.getByName("255.255.255.255")));
    System.out.println(maskLength(InetAddress.getByName("ffff:ffff:ffff::")));
    System.out.println(getMask(24));
    System.out.println(getMask(25));
    System.out.println(getMask(32));
  }
  
  def maskLength(adrs:InetAddress):Int = {
    val a = new BigInteger(adrs.getAddress());
    if (a.bitCount() != a.bitLength())
       throw new IllegalArgumentException("Illegal mask.")
    //
    return 8 * adrs.getAddress().length - a.bitCount();
  }
  
  def getMask(n:Int) :InetAddress = {
    try {
      val bs = new ByteArrayOutputStream();
      val dos = new DataOutputStream(bs);
      dos.writeInt(-(1 << (32 - n)));
      return InetAddress.getByAddress(bs.toByteArray());
    } catch {
      case e:Exception =>throw new IllegalStateException(e);
    }
  }
}
ストレンジアトラクタの描画 (Nested Flatten)

Java版(匿名 #9024)を移植しました。

Java-->Scala移植には落とし穴がありますね・・・

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
// Java版(匿名 #9024)を移植しました
import java.applet.Applet
import java.awt._
import java.awt.event._

object Main{
    def main( args : Array[String] ) : Unit = {
      try {
        val f = new Frame("Lorenz");
        f.addWindowListener(
                new WindowAdapter() {
                    override def windowClosing(evt:WindowEvent):Unit = {System.exit(0);}
                } );
        val a = new Lorenz()
        
        f.add(a);
        f.setSize(500, 530);
        f.setVisible(true);
        a.init();
        a.start();
        
        ()
      }catch{
        case e:Exception => println(e)
      }
    }
}

object Lorenz{
    private val DT:Double = 0.0005;
    private val SLEEP_TIME:Long = 1;
    private val SCALE:Double = 25;
}

class Lorenz(val p:Double, val r:Double, val b:Double, 
             var xx:Double , 
             var yy:Double , 
             var zz:Double) extends Applet with Runnable {
    //
    var orgX, orgY : Int = _
    var scale : Double = _
    var img : Image = _
    var grap : Graphics = _
    
    var done : Boolean = _

    def this()=this(10.0, 28.0, 8.0/3.0, 10.0, 10.0, 10.0)
    
    def calc():Unit = {
        val dx = (- p * xx + p * yy) * Lorenz.DT
        val dy = (- xx * zz + r * xx - yy) * Lorenz.DT
        val dz = (xx * yy - b * zz) * Lorenz.DT
        xx += dx
        yy += dy
        zz += dz
    }

    override def run():Unit = {
        try {
            while (!done) {
                for (i <- 0 until 10) {
                   calc();
                   grap.setColor(new Color((zz / 50).toFloat, 0.0f,(1.0 - zz / 50).toFloat));
                   grap.drawOval(orgX + (scale * xx).toInt, orgY - (scale * yy).toInt, 1, 1);
                }
                repaint();
                Thread.sleep(Lorenz.SLEEP_TIME);
            }
        } catch {
            case e:InterruptedException => e.printStackTrace();
            case _ =>
        }
    }
    
    override def paint(g:Graphics):Unit =  {
        g.drawImage(img, 0, 0, null);
    }
    
    override def update(g:Graphics):Unit = {
        paint(g);
    }
    
    override def init():Unit = {
        orgX = getWidth() / 2; orgY = getHeight() / 2;
        scale = ( if(orgX < orgY) orgX else orgY) / Lorenz.SCALE;
        img = createImage(getWidth(), getHeight());
        grap = img.getGraphics();
        grap.drawLine(0, orgY, getWidth(), orgY);
        grap.drawLine(orgX, 0, orgX, getHeight());
        new Thread(this).start();
    }
    
    override def destroy():Unit = {
        done = true;
    }
    
}
XMLから情報を取り出す (Nested Flatten)

#796をscalaに移植してみました。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// Java ver.(匿名  #796)をscalaに移植しました。
import org.xml.sax.InputSource
import org.xml.sax.helpers.DefaultHandler
import org.xml.sax.Attributes
import javax.xml.parsers.SAXParser
import javax.xml.parsers.SAXParserFactory

object XMLGet796 extends DefaultHandler{
  val url = "http://ja.doukaku.org/feeds/comments/"
  val text = new StringBuffer()
  def main(args : Array[String]) : Unit = {
    val is = new InputSource(url)
    val saxf = SAXParserFactory.newInstance()
    val p = saxf.newSAXParser()
    p.parse(is, this)
  }
  override def startElement(uri:String,localName:String,qName:String,
                   attributes:Attributes):Unit = {
    text.setLength(0);
  }
  
  override def characters(ch:Array[Char],start:Int,length:Int):Unit = {
    text.append(ch, start, length);
  }
  
  override def endElement(uri:String,localName:String,qName:String):Unit = {
    if ("lastBuildDate" == qName) {
      System.out.println(text)
      text.setLength(0)
    }
  }
}
与えられた文字列でピラミッド (Nested Flatten)

凡庸な解でして・・・

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
object MojiPira {
  def main(args : Array[String]) : Unit = {
    val moji = args(0)
    val m    = moji.length
    
    val fn = (m:Int,x:String) => println( x+" "*( 2*m - 1 - x.length ) )
    mojiPira(m).foreach(fn(m,_))
    
    def mojiPira(n:Int) :List[String] = {
      if( n==1 ){
        return List(moji(0).toString)
      }else{
        val tail = moji(n-1)
        val prev = mojiPira(n-1)
        var now = List(" "*prev.length + tail)
        for(a<-prev) now = now ::: (a + " " + tail)::Nil
        return now
      }
      Nil
    }
    
    ()
  }
}
XMLから情報を取り出す (Nested Flatten)

#1089をScalaに移植してみました。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// Java ver.(tnk #1089)をscalaに移植
import scala.io._

import java.io.InputStreamReader
import java.io.StringReader

import java.net.URL

import javax.xml.xpath.XPath
import javax.xml.xpath.XPathConstants
import javax.xml.xpath.XPathExpressionException
import javax.xml.xpath.XPathFactory
import org.w3c.dom.Node
import org.xml.sax.InputSource

object XMLGet1089 {
  def main(args : Array[String]) : Unit = {
    val url = new URL("http://ja.doukaku.org/feeds/comments/")
    val src = Source.fromURL("http://ja.doukaku.org/feeds/comments/","UTF-8")
    
    // 題意に沿ったもの
    val data = src.getLines.mkString // dataにXMLを文字列として格納
    println( getLastBuildDate(data) )
    
    // より「らしい」方法
    println( getLastBuildDate( new InputSource(url.openStream())) ) // XMLはInputSourceで
    
  }
  
  def getLastBuildDate(data:String):String = {
    return getLastBuildDate( new InputSource(new StringReader(data)) )
  }
  
  def getLastBuildDate(in:InputSource):String = {
    val xpath = XPathFactory.newInstance().newXPath()
    val path = "//lastBuildDate"
    val node = xpath.evaluate(path, in, XPathConstants.NODE).asInstanceOf[Node]
    //
    node.getTextContent();
  }
}
LL Golf Hole 8 - 横向きのピラミッドを作る (Nested Flatten)

出力文字の構造が面白いですね。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
object YokoPira {
  def main(args : Array[String]) : Unit = {
    val n = args(0).toInt
    def yokoPira(n:Int) : (String,String) = {
      if(n==1){
        return ("","*")
      }else{
        val (_,prev) = yokoPira(n-1)
        return ( prev , prev + "\n" + "*"*n )
      }
      ("","")
    }
    val fn = (x:(String,String))=>x._1 + "\n" + x._2.reverse 
    println ( fn(yokoPira(n)))
    ()
  }
}
XMLから情報を取り出す (Nested Flatten) 
Deep searchを使うと、題意にそっていて少し短くなりますね。（重箱の隅）

（XML初心者ですので、ビシバシ指導して下さい。）
1
    println((rss\\"lastBuildDate").text)
next >>

Index

Feed

Other

Link

Pathtraq

loading...
Creative Commons License このサイトの内容は、 クリエイティブ・コモンズ・ライセンスの下でライセンスされています。 [詳細]