union / intersect / \\

とか使えば、List の和集合とか積集合とか差集合とか
できることを知った。

list って便利だ。

久々に問題作った（汗）　
意地悪な入力とか　どうやって　みんな考えているんだろう。。。

【初稿】
import List
m@main=getLine>>=(\l->putStrLn$l#(tail$inits l))>>m
l#[]=""
l#(a:s)|compare(concat$replicate((length l)`div`(length a))a)l==EQ=a|1>0=l#s

自分で作って、自分で苦しんだので、まだゴルフはしていません

【修正1】
import List
m@main=getLine>>=(\x->putStrLn$x#(tail$inits x))>>m
l=length
x#[]=""
x#(a:s)|compare([1..div(l x)(l a)]>>a)x==EQ=a|1>0=x#s

若干縮んだが、届かない。。。

【修正2】
main=interact$unlines.(\x->map(1#)x).lines
n#x|compare([1..div(length x)n]>>take n x)x==EQ=take n x|1>0=(n+1)#x

ラムダは消せたのでした。。。

【修正3】
main=interact$unlines.map(1#).lines
n#x|compare([1..div(length x)n]>>take n x)x==EQ=take n x|1>0=(n+1)#x

compare など　いっちょまえに使ったから長かったのでした。。。

【修正4】
main=interact$unlines.map(1#).lines
n#x|([1..div(length x)n]>>take n x)==x=take n x|1>0=(n+1)#x

ふー。take をこういう風に使うと縮むとは。。。
しかし、take を2回使うところが冗長っぽいねんなあ。。。

【修正5】
main=interact$unlines.map(1#).lines
(%)=take
n#x|([1..div(length x)n]>>n%x)/=x=(n+1)#x|1>0=n%x

とりあえず、情報を整理してみた。

まずは、対象コード。

import Text.Printf
main = printf "%d" (3::Int)

次は、集まった情報。

main の 型 は、IO()
printf     :: PrintfType r => String -> r
(!!)       :: [a] -> Int -> a
(>>)       :: Monad m => m a -> m b -> m b

=================================================================

で、よく分かってないのが、PrintType r という奴。

要するに、printf は、String を引数にして、PrintfType という
型を返すということか?

以下を参考にさせてもらうことにしよう。。。
http://haskell.g.hatena.ne.jp/illillli/20080313/1205428973

haskell のライブラリを見ると、
http://cvs.haskell.org/Hugs/pages/libraries/base/Text-Printf.html
PrintfType の Instance は以下のようだと書いている。

IsChar c => PrintfType ([] c)
PrintfType (IO a)
(PrintfArg a, PrintfType r) => PrintfType (a -> r)

で、ここで、そもそもインスタンスってなんじゃい。。。
オブジェクト指向での、クラスのインスタンス？

と思っていたが、やっぱりそれで正しそう。
クラスから出来る変数のようなものを作るということだね。
とりあえずは、その理解で進めることにする。

で、やっと分かってきたが、
PrintfType は、
● String
● IO a
● PrintfArg を引数にして、PrintfType を返す関数

のどれかに解釈できればＯＫという代物っぽい。

([] c) は、 どうもString を示しているようだ。
http://haskell.org/ghc/docs/latest/html/libraries/base/Data-String.html 

ちなみに、PrintfArg のインスタンスは以下のような感じらしい。

PrintfArg Char 
PrintfArg Double 
PrintfArg Float 
PrintfArg Int 
PrintfArg Integer 
IsChar c => PrintfArg [c] 

いやー　ひたすら推測だけで進めているよ。。。

=================================================================

でも、String 型で解釈できるなら、次のコードも動くのでは？？

import Text.Printf
main=putStr$printf "test"

おお、コンパイル通った♪ String 型に解釈されたっぽいぞ。

=================================================================

ということで、対象コードに　ようやく戻ってきた。

main = printf "%d" (3::Int)

上記のコードは、main が IO() なので、
【 "%d" (3::Int) 】 自体が String であり、printf　は、String -> IO() という形にしたんだと思う。。。

じゃあ、String を "%d" (3::Int) で表すことができるの？

=================================================================

ずっと考えていたが、

ここで、
(1) printf     :: PrintfType r => String -> r
(2) printf のインスタンスの一つが、
      (PrintfArg a, PrintfType r) => PrintfType (a -> r)

を使うわけか。

上記の定義を使うと、

PrintfType r => String -> r
は、
(PrintfArg a, PrintfType r) => String -> a -> r

というように、強引に変換されそうだ。

ということで、

printf "%d" (3::Int) では、

"%d" : String
(3::Int) : PrintfArg
で、【"%d"　(3::Int) 】 が String (PrintfType r から型推論されると予想)になるわけか。

ということで、printf "3" が IO() となり、main と型が一致するわけか。
ただし、PrintArg では、3 は Int か Integer か分からないので、
明示的に (3::Int) としなければいけないわけね。

=================================================================

ふうー。超　むずかしい。。。

もう縮まらない。。。

【初稿】137バイト
(\\ は一行で書いていることを示しています。)

k#n|k>n="_"|1>0=show k
f n=div(n+4)4-0^mod n 4
u=unwords
main=do n<-readLn;putStr$u\\
[u$map(#n)[4*f n+2-a,a-1,a,4*f n+1-a]|a<-[2,4..2*f n]]

こういう問題は、解くだけなら。。。

f l=last l:init l;main=interact$unlines.f.lines