Erlangリンク

すごいサイト見つけた
早速読もう
Learn you some Erlang for great good!¶

Erlang公式

Erlangメモ

2進数
2#1010(10)

16進数
-16#EA(-234)

ASCII
$a(97)
$A(65)
$\n(改行 10)

浮動小数点
17.368 -56.654 1.234E-10

表記	説明	データ型
+	単項+	整数|浮動小数点
-	単項-	整数|浮動小数点
*	乗算	整数|浮動小数点
/	浮動小数点除算	整数|浮動小数点
div	整数除算	整数
rem	整数剰余	整数
+	加算	整数|浮動小数点
-	減算	整数|浮動小数点

アトム
比較のみ、英小文字で始める[a-z]([a-z][0-9]@._)*
または単一引用符で囲む

ブール
true
false

演算子	説明
and	両方の引数がtrueの場合に限りtrueを返す
andalso	andのショートカット評価
or	いずれか一方の引数がtrueの場合にtrueを返す
orelse	orのショートカット評価
xor	排他的論理和
not	単項否定演算子

組(タプル)
波カッコ{...}で囲み、コンマで区切る
組のサイズを返す
tuple_size(組)
要素を取り出す
element(1からのインデックス,組)
要素を設定する
setelement(1からのインデックス,組,値)

リスト
角カッコ[...]で囲み、コンマで区切る
コンス
[Head|Tail]
連結
++
引き算
--

リスト内包
NewList = [Expression || GeneratorExp1, GeneratorExp2, ..., GeneratorExpN, Condition1, Condition2,... ConditionN]


比較演算子

演算子	説明
==	等しい
/=	等しくない
=:=	完全に等しい
=/=	完全に等しくない
=<	等しいかまたは小さい
<	小さい
>=	等しいか大きい
>	大きい

変数
[A-Z][a-zA-Z0-9_]

パターンマッチング
ワイルドカード
_


関数
関数名(引数) ->
文;
関数名(_) ->
文.

ガード
f(N) when N > 100 -> true;
f(_) -> false.


関数呼び出し
モジュール名:関数名

無名関数
fun(args) ->
state;
end


レコード
-record(レコード名, {名前=(初期値),...}).


シェルについて

起動
erl

ドット、終止符をつける

help().

コンパイル
c(ファイル名).

終了
q().


その他
ファイルの先頭に書くこと

-module(modulename).
-compile(export_all).

BIF(Built-in function)

Common Lispリンク

Lisp Works
http://www.lispworks.com/documentation/common-lisp.html

http://ancient.s6.xrea.com/lisp/cookbook.html

http://lisperati.com/logo.html

Common Lisp関連書籍

Land of Lisp
オライリーだけど表紙が地球上の生物じゃないと言うことで話題の本

Let Over Lambda
最高に脳みそが刺激される本

実践Common Lisp
内容はcommon lispだけど「実践」と謳ってあるだけあって非常に実践的
common lispで実践したい人向け

実用Common Lisp
「実用」と言っていますが実用とは思えなかった内容でしたが

On Lisp
とにかくマクロ
マクロを使うためにはどうすればいいか
あとは良いプログラムを書くための心得のようなものも
ポールグレアムの暑苦しさが伝わってきます
スタートアップ企業で成功するような人はこんな感じの人が多いんでしょうね
こんな感じの人じゃないとスタートアップ企業で成功できないんだろうな

ANSI Common Lisp
ポールグレアム著と言うことで買いました
たったそれだけ、多分hyperspecで事足りる

COMMON LISP第二版
個人的にはhyperspecでいいんじゃないかなと思っていますが
所有しているとご利益がありそうなので購入しました

初めての人のためのLISP
実用と言うよりは啓蒙
非常にlispらしい、c言語とかjavaから入ってきた人にはなんじゃこりゃ的な内容で素晴らしい
良くも悪くもlispらしい本だと思います
他の言語ではこういう話の本は書きにくいだろうな


schemeだけどほぼ共通ととらえていいと思う
計算機プログラムの構造と解釈

あなたの人生の物語感想

テッド・チャン

あなたの人生の物語

とにかく聖書、キリスト系の話といった印象

全体的に面白みにかけている、マジメな人だなって印象かな

個人的にはもっとふざけててもいいのにと思う

ディックみたいにノリノリでワルノリで書いてもそっちの方が面白いと思う人には少し退屈ではないでしょうか

バビロンの塔

途中の塔を登っていく過程は面白かったですね

太陽を下に見下ろしてさらに登っていく様、星がぶつかりそうなところもよかった

ただ、結局地上に戻ってくる終わらせ方なんだなとすこしがっかりしました

ゼロで割る

あなたの人生の物語

これ結局なんだったんだろうか

地球人、人類は逐次的解釈で他に逐次的に解釈しない生命がいると言いたいんだなと

まあそんな生命がいてもいいんじゃないかという点すごくなっとくいく

強烈に特異な発想かと言われるとどうも

七十二文字

理解できなかったです

人類科学の進化

同上

地獄とは神の不在なり

顔の美醜について

Goまとめ

http://tour.golang.org/
一通り見た感想

1.import "fmt"が汎用言語を強く意識させてます

7.引数の型、戻り値の型を後ろに書くパターンの良さが？

8.7.は引数の型がまとめられる利点なのかな

9.複数戻り値ね、タプル的なものは用意しないのね

10.Named resultsの良さがわからない

11.12.変数宣言はこんなものか、色々用意されていますね

15.Constantsは好みじゃないのよ、C#のプロパティがいいね

18.Forか、これだと自分でeachとか定義しないといけないのね

22.if内でのみ利用可能な変数はいいね

33.なぜかNilが登場、Nilに反応するあたり

34.Rangeか

43.closureはいいね

後半よくわからないし、並列辺りもほとんど読み飛ばしました

全体的な印象としては糖衣構文満載、ただし抑えるべき基本はしっかり抑えている印象ですね
Cの後継としては非常によくできていると思います
使ってみたいですね

妄想について

HaskellかCommon Lispを使う仕事ってないのかな
なんかざっくりしたイメージだけで言ってますが楽しそうなんだけどな
とか言って期待しすぎちゃって実際就いてみたらつまらなくてHaskellやCommon Lispのことが嫌いになったりしてね
データベースとかSQLとかサーバーの設定とかインストールとか実行環境の互換性とかそういった煩わしいものがなくてHaskellやCommon Lispでかっこいいプログラムを作ることに集中できるような仕事ってないもんかね
って言うか要はとにかく粋なプログラムを書きたい、書けるようになりたいのだけど
粋なプログラムの定義ができてなくてイマイチですが

Haskellでcode jamに挑戦 2013予選C

予選C
実際調べてみたら、1e14までなら対象の数が数十個なので一旦数十個見つけ出してあとは入力範囲内にその数十個からあるだけ数えるでLarge input 1は解けました

が、Large input 2は対象の数が多すぎて1e100ってどうやって調べるかまったく見当もつかない状態でギブアップです



これも本番時はどうしてもIntとIntegerとFloatingの変換でうまく動かず
と言うか、動く以前にコンパイルすら通すことができず断念


予選Bといい、予選CといいHaskellってまったくいいところなしのクソクズ言語だなって思ってしまいましたが、翌日落ち着いて改めて取り組んでみたらサクサク進んだと言うかやっぱりいい言語なんじゃないかなと言ったところが最終的な結論でしょうか

1e100の入力はどうやってやるか不明のままです

--digitcp c = any (\i -> i == c) ['0'..'9']

pow base n = foldl (*) 1 (take n $ repeat base)

--rInt s = read (takeWhile digitcp s) :: Integer
rInt s = read s :: Integer

check lower upper = let lowersqrt = (ceiling . sqrt)
   uppersqrt = (truncate . sqrt)
   rr = [(lowersqrt (lower::Double))..(uppersqrt (upper::Double))]
   tostr = map show
   z arr = zip (tostr arr) ((map reverse . tostr) arr)
   filterpalindrome arr = (map (rInt . fst) . filter (\(a, b) -> a == b) . z) arr
   in
   (map (rInt . fst) . filter (\(a, b) -> a == b) . z) (map (\x -> x * x) $ filterpalindrome rr)
   --(length . filter (\(a, b) -> a == b) . z) (map (\x -> x * x) $ filterpalindrome rr)

start = check (pow 10 14) (pow 10 15)
st n = check (pow 10 n) (pow 10 (n + 1))
format n m = "Case #" ++ show n ++ ": " ++ show m

parserec _ [] = []
parserec n lines = let lower = (rInt . head . words . head) lines
         upper = (rInt . last . words . head) lines
         in
         (format (n + 1) (check (fromIntegral lower) (fromIntegral upper))) : (parserec (n + 1) . tail) lines

parserec_large1 _ _ [] = []
parserec_large1 n res lines = let lower = (rInt . head . words . head) lines
      upper = (rInt . last . words . head) lines
      in
      ((format (n + 1) . length . filter (\i -> and [(i >= lower), (i <= upper)])) res) : (parserec_large1 (n + 1) res . tail) lines

parse lines = let t = (rInt . head) lines
    in
    (parserec 0 . tail) lines

parse_large1 lines = let t = (rInt . head) lines
    res = check 1 (pow 10 14)
    in
    (parserec_large1 0 res . tail) lines

main = do cs <- getContents
   (putStr . unlines . parse_large1 . lines) cs

Haskellでcode jamに挑戦 2013予選B

予選B
とりあえず入力に近づくように刈れるだけ刈ってみる
縦横m*n回できるかぎり入力のように刈ってみて入力と比較して結局一緒になっているかどうかで可能かどうか判定

特に困るところはなくsmallもlargeも解けた




と言いたいところなんですけど、どっか間違えていてなぜかincorrect判定
で直せない、直す気力がなかったです
アルゴリズム的には絶対合っている自信があったので次の日再度プログラム組んでみたらやっぱり正解でした
と言うことで公式記録としては点数として残りませんでした

やっぱり本番だろうと動揺せずに冷静に取り組めるようになるためにも練習とか大事だなと思いましたね
って言うかこの時点では本当に入力データのパースに参っていて何やってるかさっぱり訳わかんない状態だったからね
自分で考えてHaskellのプログラムしたのは去年のcode jam以来だと思うので
って言うか去年も数問解けたのあるのですけど本当、自分でやっておいてまったく信じられないからね
よくHaskellで問題が解けたな去年の俺って感じですから

あと次の日落ち着いて練習のつもりで気楽にやってみたら入力文字のパースも簡単な方法がわかってなんか拍子抜けな感じ
takeとdropと再帰とwordsでこんなにも簡単にパースできるなんて昨日の苦労はなんだったんだろうかと感じております

org n = take n $ repeat 100

f rows cols ans = let size = rows * cols
        inrow n i = and [i >= n * cols, i < ((n + 1) * cols)]
        incol n i = (i `mod` cols) == n
        setrowval nth n = map (\i -> if inrow nth i then n else 0) [0..(size - 1)]
        setcolval nth n = map (\i -> if incol nth i then n else 0) [0..(size - 1)]
        mergeifnotzero = zipWith (\a  b -> if b /= 0 then (min a b) else a)
        rowvals nth = zipWith (\a b -> if inrow nth a then b else 0) [0..]
        colvals nth = zipWith (\a b -> if incol nth a then b else 0) [0..]
        computerow ans input nth = mergeifnotzero input $ setrowval nth ((maximum . rowvals nth) ans)
        computerows ans input = foldl (computerow ans) input [0..rows-1]
        computecol ans input nth = mergeifnotzero input $ setcolval nth ((maximum . colvals nth) ans)
        computecols ans input = foldl (computecol ans) input [0..cols-1]
        compute ans = (computerows ans . computecols ans . org) (rows * cols)
        in
        compute ans

rInt s = read s :: Int
resformat n b
  | b = "Case #" ++ show n ++ ": YES"
  | otherwise = "Case #" ++ show n ++ ": NO"

parseItem _ [] = []
parseItem n lines = let rows = (rInt . head . words . head) lines
   cols = (rInt . last . words . head) lines
   ls = (take rows . drop 1) lines
   ans = (map rInt . words . unlines) ls
   res = f rows cols ans
   in
   ((resformat (n + 1) . and) $ zipWith (==) ans res) : (parseItem (n + 1) . drop (rows + 1)) lines

parse lines = let t = (rInt . head) lines
    in
    (parseItem 0 . tail) lines

main = do cs <- getContents
   (putStr . unlines . parse . lines) cs

Haskellでcode jamに挑戦 2013予選A

2013年のcode jamに懲りずにまたまたHaskellで挑戦しました

Land of Lisp読んだばっかりだからやっぱりCommon Lispでやりたかったけど結局code jamみたいな数値計算系はHaskellの方が有利かなと思ってHaskellで挑戦しました
結局、入力のパースで散々な目にあいましたが

予選A
Xを+1、Oを-1、Tを2倍にするとして+3を上回るか-3を下回るものがあるか検索
+3を上回るか-3を下回るものが見つかったら終了
見つからなかったら「.」を検索してあったら途中、なかったら引き分けとして決着
注意点はTの2倍を最後に回すように気をつけてsmall、largeともにクリアできました

HaskellらしくX,O,Tの処理を関数の部分適応で対応したところがHaskellらしいのではないかなと思っております

しかし本題に取り組むよりも入力のパースで手間取りました
Haskellで入力をパースしてどうこうするってことをあまりやったことがないからテキストから整数に変換する方法やら入力を成形するところで大幅につまづきました
正直、途中で心が折れるところでした

import Data.List

x = (+1)
t = (*2)
o = (subtract 1)
d = (+0)

input = "xxxt....oo......"
predp 't' _ = GT
predp _ _ = LT

mapf = map f
     where f 'x' = x
    f 't' = t
    f 'o' = o
           f 'X' = x
    f 'T' = t
    f 'O' = o
    f '.' = d
    f _ = d

so = sortBy predp

r n = take 4 . drop (4 * n)
c n xs = foldr (\nn a -> (head $ drop (4 * nn + n) xs) : a) [] [0..3]
lurb xs = foldr f [] [0..3]
     where f 0 a = (head xs) : a
    f 1 a = (head $ drop 5 xs) : a
    f 2 a = (head $ drop 10 xs) : a
    f 3 a = (head $ drop 15 xs) : a
rulb xs = foldr f [] [0..3]
     where f 0 a = (head $ drop 3 xs) : a
    f 1 a = (head $ drop 6 xs) : a
    f 2 a = (head $ drop 9 xs) : a
    f 3 a = (head $ drop 12 xs) : a
app = foldl (\n x -> x n) 0

inputs = map (app . mapf . so) $ (map (\n -> r n input) [0..3]) ++ (map (\n -> c n input) [0..3]) ++ [(lurb input)] ++ [(rulb input)]
inlist i = map (app . mapf .so ) $ (map (\n -> r n i) [0..3]) ++ (map (\n -> c n i) [0..3]) ++ [(lurb i)] ++ [(rulb i)]

rInt s = read s :: Int

res [] s n
  | any (=='.') s = "Case #" ++ show n ++ ": Game has not completed"
  | otherwise = "Case #" ++ show n ++ ": Draw"
res (x:xs) s n
  | x > 3 = "Case #" ++ show n ++ ": X won"
  | x < -3 = "Case #" ++ show n ++ ": O won"
  | otherwise = res xs s n

main = do cs <- getContents
   putStr $ unlines $ map (\(s, m) -> res (inlist s) s (m + 1)) $ map (\n -> (foldl (++) "" $ take 4 $ drop ((n * 5) + 1) $ lines cs, n)) [0..((rInt $ head $ lines cs) - 1)]

ナチス式敬礼をしたサッカー選手

ナチス式敬礼をしたサッカー選手が騒ぎになっていましたけど、この人の写真見たときに富永一郎のマネしてるかと思いましたね

お笑いマンガ道場のエンディングで富永一郎がいつもやってるポーズと同じだなと

虚数の情緒

たまに趣味なんですかとか休みの日なにやってるんですかって聞かれるんですけど数学って答えるとびっくりされて鬱陶しいんですけどね
こんな本を休みに好んで読んでるってことはちょっとおかしいかもしれないなと思えるような本
今の時代らしいとにかく金を稼げと
とにかくお金で換算してどうこうって本とは全然違ってとにかく勉強しろと言う熱い本
時間がかかってもいいからとにかくやれと
資本主義の概念だとお金払って数学得意な人を雇えといわれそうなんですけどこの本では自分で身に付けろといってい

Code Jamの季節到来

今年こそ予選突破を目指す

最強プログラミング言語のCommon Lispを味方につけて予選突破をめざす
我ながらなんて低い目標なのかと悲しくなってきますが身の程をわきまえるとこの程度の実力しか有していないから仕方がないですね
大体、英語の問題の時点でかなり苦痛を強いられてしまうから悲しいです
出題文の英語がね
とりあえず問題の意味がわかるかどうかにかかっていますが
予選程度の問題だったら日本語で出題されたらわかるのかな？
いままでの実績だとsmallは解けるんだよな
でもlargeがダメなんだよね

SFカーニバル

http://www.tsogen.co.jp/np/isbn/9784488605032

タイムマシン

笑った笑った
会社の帰りに電車の中で読んでたんですけどあのアホな繰り返しのところで思わず笑っちゃった
なんでバイクにのった狂った猿から逃れるために木の枝に何回も何回も飛び移るのか意味わかんないし、しかも何回も何回も繰り返すからさ
今思い出しても笑える
電車乗ってるから必死でこらえたんですけど笑っちゃった
あー、可笑しかった

ジョーという名のロジック

意味わかんなかったな
でもなんかインターネットのこと言ってるみたいだなと思った

ミュータント

火星人来襲

勘違いものですね
地球に来られるくらいなのに火星人弱いな

SF作家失格

SF作家は基本的に売れっ子じゃないところがリアルだなと思う
結局アレンジするくらいじゃないとSF作家じゃないんだろうな

恐竜パラドックス

女子大生ナンパするのが自分と言うところがいいね
時間移動よりそっちの方に興味津々

ヴァーニスの戦士

宇宙サーカス

ロボット編集者

地球＝火星自動販売機

JavaScript第6版

第6版が出版されたので読書中
まだ本のはじめのほうの文法のところを読んでいるところですがまあ複雑な文法だなと改めて感じます
Common Lispの単純な簡潔な文法と比べると暗黙的な動作が多くてやたら説明が冗長に感じられます
Common Lispはよく括弧が多くて悲惨とかって言う批判を耳にしますが文法は非常に簡単で覚えることって凄く少ないし暗黙的な動作が少なくて沢山の括弧のおかげで明示的に記せることは利点になっていると思えるくらいだけど
括弧が利点と言うと「またLisp使いが自虐的な寒いギャグを言っておる」と捉えられがちですがやっぱり全然そんなことないと思う
計算の優先順位があったり右に結合するやらブロックがどうとか、そういうことがあるととにかく鬱陶しいと思うのだけど
覚えるのも癪に障るがCommon Lispほど余計な気遣い一切無くプログラミングに集中しやすい言語はないんじゃないのかと思えてくるよね
JavaScriptはなかなか素晴らしい言語だと思ってるんだけどやっぱりこの基本的な文法とかルールがかったるいな
しょうがないけどもったいないな

Haskell難しい

すごいHaskellたのしく学ぼう！
ですが第11章難しい
なに言ってるんだかさっぱりわからん
嫌になってきた

Haskellでcode jamに挑戦

2012年の予選問題
Problem C. Recycled Numbers

出題範囲の数を全部列挙して、それぞれrecycled numberを作り出して出題範囲に収まっているかどうか調べてからrecycled numberだけを畳み込んで数える

import Data.List

toInteger' s = read s :: Integer

rotate lower upper n = let f1 n = n `div` 10
      f2 n = (n `mod` 10) * 10 ^ (digitcount - 1)
      f3 n = f1 n + f2 n
      digitcount = length $ show n
      rec _ 0 r = length (filter (\x -> x >= lower && x <= upper) $ Data.List.nub r) - 1
      rec n d r = rec (f3 n) (d - 1) ((f3 n) : r)
      in rec n (digitcount - 1) (n:[])

scan lower upper = (foldl' (\acc x -> acc + (rotate lower upper x)) 0 [lower..upper]) `div` 2

compute s = let f = map (toInteger') (words s)
  in scan (head f) (last f)

main = do
 line <- getLine
 contents <- getContents
 putStrLn $ unlines $ map (\(i, line) -> "Case #" ++ show i ++ ": " ++ show (compute line)) $ zip [1..] $ lines contents

Haskellの注意点

Haskellは割り算を/（スラッシュ）でやってしまうとえらいことになってしまう
/（スラッシュ）じゃなくてdivが用意されているから気をつけないといけない

すごいHaskellたのしく学ぼう！読書感想

「すごいHaskellたのしく学ぼう！」を読みながらHaskell修行中
Haskellの楽しいところは非正格評価で必要になるまで評価されない点だと思う
整数配列が[1..]と書けるところが素晴らしい
あとは他の言語でもあるのだけどリスト内包表記だね
これがあると繰り返していちいちリスト作るのが面倒で仕方が無くなる
この本に載っている直角三角形を求める例も素晴らしい例だと思う
ワンライナーだけど全然読みづらくなくて逆に直感的で分かりやすい記述だと思う

Haskellは型推論がしっかりしてるから普通でいきなりジェネリックなところも素晴らしいですね
結局型宣言書くことになるのだけど実際のプログラム自体に余計な記述が入り込まないから簡潔になっていいですね
Common Lispは大好きでたいへん尊敬しているのですが動的型付はどうも性に合わないんですよね
静的型付のほうがしっくりくるので型推論は非常に嬉しいです

でもなんだかんだいっても結局Haskellの魅力は関数の構文の素晴らしさですね
パターンマッチ、ガード、where、let、caseとあって手続き型だと結局ifかswitch程度しかなくてなんとも貧弱なのですがHaskellはやっぱりこの辺りが洗練されているなと思います

次に続くのが超目玉のカリー化だったり部分適応だったりで
これらを駆使してmapやfoldを利用するために関数合成、$での関数適用でソースを読みやすくして
ポイントフリースタイルでさらに関数合成を洗練させられる
まあ当然ラムダも素晴らしいんですけどね

とりあえず5章まで読んだんですけどここまででもHaskellの素晴らしさ魅力はあふれんばかりだと思います
この本はモナドやIOがなかなか登場しないですね

まあなんにしても5章まででも十分すぎるほど読む価値あると思います

この本は関数型について学びたい人には向いてないかな
Haskellを使えるようになりたい人には向いていると思います
関数型についてだったらF#やOCamlの本の方がいいんじゃないかな

読書感想

「プログラミングClojure」を読んであらためてCommon Lispの素晴らしさがわかったような気がします
Clojureの本なんですけどこの本に書いてあることはCommon Lispで全てできる
Common Lispのパワーを改めて感じられました
やっぱりCommon Lispすげーや
Clojureって言っても、Common Lispのマクロ拡張セットじゃないかなと

LET OVER LAMBDA
この本は何回読んでも難しい
全然理解できない
意味わかんないと言うか頭がついていかない
実際コード入力してやってみても意味わかんないし
とにかく難しい
前回読んだときより多少理解できるようになってきてるのでまた一年後くらいに読むことになるのだけどその時はもう少しわかるようになっているかな

「すごいHaskellたのしく学ぼう！」
Haskellの本は4冊目くらいかな
一向にできるようにならないですね
関数のCase、ガード、whereが上手く使いこなせない気がします
このあたりは練習あるのみではないかなと

「ドメイン特化言語」
マーチン・ファウラー著の本が近所の普通の本屋で売ってたので思わず買ってしまった
なんでこんな本仕入れたのかまったく理解できないですね
今日買いました