プログラム不要の「制約プログラミング手習い」

少し大きな問題で実験

Wed, 11 Mar 2009 16:54:00 +0900

５×５の問題でうまくいったけれど、小さいサイズでは偶然できることも多々ある。もうすこし大きな問題で実験を続けよう。ここでは、７×７のサイズの問題で試してみる。

用意した７×７の問題は次である。

さて、一応、自分の頭で解いておくべきだ。が、答えはここには示さない。

この問題を、プログラムにしてしまおう。サイズが変わった以外、プログラム： planeloop1-5.csp　とまったく同じであるので説明は省略し、プログラムと結果を示す。

プログラム： planeloop2-1.csp

実行結果： planeloop2-1.txt

この結果だが、実はとんでもないことになっているのだ。

５×５のとき、ちゃんと１つのループになってくれたのに、今回は４個のループに分かれてしまった。

しかし、プログラムには、ループは１つというのが入っているはずなのだが、なぜおかしくなってしまったのだろうか？

単一ループ

Fri, 27 Feb 2009 16:31:26 +0900

とりあえず、ループになったが、まだループが１つという保証はない。

単一ループにするというのは、スリザーリンク／単一ループで検討したことがある。このときは、ループ上のあるマスを起点として、１から順に番号を振った。すべてのループのマスには、１からループ長さまでの連続した数が入る。こうなっていると、１の個数とループの個数が同じになるので、「１の個数が１つでなくてはならない」という制約で調べた。

同じ方法を使えば解けると思うのだが、それでは面白くない。ここでは、何か別の方法を考えてみよう。できれば、もっと素直な方法を考えてみたい。

「同一ループのマスには同じ数字を入れる」のが自然だと思う。この線で、プログラムを作っていくことにしよう。

ところで、ループ毎に異なる数字を割り当てるには、どうしたらよいだろうか。

で、ちょっと考えた。

すべてのマスに、１〜順に値を対応させる。白マス、黒マスの区別をせずに順番に次のように入れる。

各ループについて、そのループが通過するマスの値すべてが、通過するマスのうちの一番小さい数になるようにしよう。

上の２つのループに対してこの処理をすると、値が２と、値が１６のループができる。

このやり方では、ループが異なれば、必ず異なる番号が割り当てられる。用意した番号（１〜マスの総数）に対して、ループに使われている数が何個か調べる。

上の例では、２と１６が使われているので（ループの中の○の位置が、それぞれのループでの最小値の位置）、これからループ数が２つと分かり、この状態は却下される。

さて、これをどうやったら実現できるだろうか？

矢印の向きを決める配列とは別に、ループ毎の番号のための配列を用意しよう。

(domain dn 1 25)
(domain dz 0 0)

int n11 dz)(int n21 dn)(int n31 dn)(int n41 dn)(int n51 dn)
(int n12 dn)(int n22 dn)(int n32 dz)(int n42 dn)(int n52 dn)
(int n13 dn)(int n23 dn)(int n33 dn)(int n43 dn)(int n53 dn)
(int n14 dn)(int n24 dn)(int n34 dn)(int n44 dn)(int n54 dn)
(int n15 dn)(int n25 dn)(int n35 dz)(int n45 dn)(int n55 dn)

この配列の中身が、

の数字になればよい。そのためには、どのような制約、predicateを用意すればよいか考えてみよう。

変数 nij を決めるのに何が欲しいだろうか。

1. aij そのマスの矢印の方

2. n?? 矢印の先にあるマスの中の nij なのだが、実際には現在マスの上下左右のマスのnij（ループ値）

3. nij 注目しているマスのループ値

4. 各マスが異なるようにするための値(cn セル番号)、つまり次の図の値である。

これを、numbering というpredicateにしてみた。

(predicate (numbering a n_e n_s n_w n_n an cn)
        (or  (and (= a 0) (= an 0))
             (and (= a 1) (= an (min n_e cn)))
             (and (= a 2) (= an (min n_s cn)))
             (and (= a 3) (= an (min n_w cn)))
             (and (= a 4) (= an (min n_n cn))) ))

aは、矢印の方向
となりマスのnij（ループ値）は、n_e n_s n_w n_n であり、最後の1文字が方向を示す。
an は、注目マスのループ値。
cn は、マスの識別番号

となっているのだが、上のpredicateは、まず黒マスの場合、ループ番号も0と決めている。これは問題ないだろう。

次に、各方向について、「マスの識別番号」と「隣マスのループ番号」の小さい方を、そのマスのループ番号としている。

分かっただろうか。

つまり、これで、ループが通過するマスの識別番号のうち最小の値がループ全体に伝搬するはずである。たぶんそうなるはずなんだ。

上は定義だけなので、実際には、これを次のように使わないといけない。

(numbering a11 n21 n12  0   0  n11)
(numbering a21 n31 n22 n11  0  n21)
(numbering a31 n41 n32 n21  0  n31)
(numbering a41 n51 n42 n31  0  n41)
(numbering a51  0  n52 n41  0  n51)
(numbering a12 n22 n13  0  n11 n12)
(numbering a22 n32 n23 n12 n21 n22)
(numbering a32 n42 n33 n22 n31 n32)
(numbering a42 n52 n43 n32 n41 n42)
(numbering a52  0  n53 n42 n51 n52)
(numbering a13 n23 n14  0  n12 n13)
(numbering a23 n33 n24 n13 n22 n23)
(numbering a33 n43 n34 n23 n32 n33)
(numbering a43 n53 n44 n33 n42 n43)
(numbering a53  0  n54 n43 n52 n53)
(numbering a14 n24 n15  0  n13 n14)
(numbering a24 n34 n25 n14 n23 n24)
(numbering a34 n44 n35 n24 n33 n34)
(numbering a44 n54 n45 n34 n43 n44)
(numbering a54  0  n55 n44 n53 n54)
(numbering a15 n25  0   0  n14 n15)
(numbering a25 n35  0  n15 n24 n25)
(numbering a35 n45  0  n25 n34 n35)
(numbering a45 n55  0  n35 n44 n45)
(numbering a55  0   0  n45 n54 n55)

この制約でちゃんとなる（と思う）。

プログラム： planeloop1-4.csp

実行結果： planeloop1-4.txt

実行結果のループ番号部分だけ示すと次のようになっている。

つまり、２と１６の２つのループがあるということで、次図の番号と一致している。

ということで、「めでたしめでたし」なのだが、実はループが１つというのがルールだった。

ループが１つというのは、以前にもやった気がする。思い出してみよう。

このループの決め方には、１つの特徴があった。ループの値は、ループが通過するマス（１〜２５の番号が順に各マスに対応：マスID）のうち、最小の値がループの値になっているはずだ。

だとすると、マスの値と、ループの値が一致しているマスが、そのループが通過するマスIDで一番小さいはずだ。そして、そうなっているのは、各ループ毎に１つしか存在しない。

ということは、マスIDとループ番号が一致している個数を調べれば、ループ数を計算できる。そして、そのループ数は１でなければならない。

ということで、ループ数１の制約を次のように書いた。

; single loop
(= 1 
   (+ (if (= n11  1) 1 0)
      (if (= n21  2) 1 0)
      (if (= n31  3) 1 0)
      (if (= n41  4) 1 0)
      (if (= n51  5) 1 0)
      (if (= n12  6) 1 0)
      (if (= n22  7) 1 0)
      (if (= n32  8) 1 0)
      (if (= n42  9) 1 0)
      (if (= n52 10) 1 0)
      (if (= n13 11) 1 0)
      (if (= n23 12) 1 0)
      (if (= n33 13) 1 0)
      (if (= n43 14) 1 0)
      (if (= n53 15) 1 0)
      (if (= n14 16) 1 0)
      (if (= n24 17) 1 0)
      (if (= n34 18) 1 0)
      (if (= n44 19) 1 0)
      (if (= n54 20) 1 0)
      (if (= n15 21) 1 0)
      (if (= n25 22) 1 0)
      (if (= n35 23) 1 0)
      (if (= n45 24) 1 0)
      (if (= n55 25) 1 0)))

マスの数だけ行数が増えるが、難しいところはないだろう。

上記を追加してプログラムを走らせたら、次のようになった。

プログラム： planeloop1-5.csp

実行結果： planeloop1-5.txt

この結果を図にすると、次のようになっていた。すべての白マスのループ番号は２であったので、ちゃんと１つのループになっているはずだ。

ということで、一応成功のようだ。

では、次からもっと大きなサイズで試してみよう。

ループ表現戦略

Thu, 12 Feb 2009 20:29:17 +0900

例題は小さすぎるし、問題は大きすぎるので、次の問題に対して、プログラムしていこう。

すべての白マスを通過するループを作るパズルであるので、まず、ループの表現方法を考えよう。ループは、どうも有向ループを考えるのが良いらしいことは、いままでの経験でなんとなく想像できる。

今回は、書くマスに対して、次のマスへの矢印でループを示すことにしよう。

図で、きちんと示そう。

白マスには、上下左右のいずれかに向いた矢印が入る。この矢印の方向に、ループを回ることができることにする。

４方向を、図にあるように、各方向に、１〜４の値を割り当てる。そして、矢印の入らないマスは、０を割り当てる。

これで、例題の盤面は、次のように表現できる。

(domain da 1 4)
(domain dz 0 0)

; arrow
(int a11 dz)(int a21 da)(int a31 da)(int a41 da)(int a51 da)
(int a12 da)(int a22 da)(int a32 dz)(int a42 da)(int a52 da)
(int a13 da)(int a23 da)(int a33 da)(int a43 da)(int a53 da)
(int a14 da)(int a24 da)(int a34 da)(int a44 da)(int a54 da)
(int a15 da)(int a25 da)(int a35 dz)(int a45 da)(int a55 da)

da	1〜4	白マス
dz	0	黒マス

プログラム： planeloop1-1.csp

これだけでは何も決まらない。ループにするにはどうすれば良いだろうか？

注目しているマスから次へマスへの矢印の決め方を

(predicate (next  a e s w n)
　　　.... )

という書き方で作ってみよう。
aが注目しているマス、e s w n はそれぞれ、そのマスの東西南北の方向の隣マスである。

nextを定義する前に、nextの使い方を先に示しておこう。各マスは、aijで示されるので、それを各マスに対して延々と書き連ねると次のようになる。 0は、盤面の外側であることを示している。

(next a11 a21 a12  0   0 )
(next a21 a31 a22 a11  0 )
(next a31 a41 a32 a21  0 )
(next a41 a51 a42 a31  0 )
(next a51  0  a52 a41  0 )
(next a12 a22 a13  0  a11)
(next a22 a32 a23 a12 a21)
      ...
(next a35 a45  0  a25 a34)
(next a45 a55  0  a35 a44)
(next a55  0   0  a45 a54)

まず、aが黒マスだった場合を考えよう。黒マスだったら、隣のマスから、この黒マスへの矢印があってはダメである。だから、黒マスの場合、次が成り立つ。

(and (= a 0) (and (!= w 1) (!= n 2) (!= e 3) (!= s 4)))

矢印の方向が黒マスに向かっていてはいけないので、１、２、３、４が上のように入る。

次に、白マスの場合を考えよう。白マスの値は１〜４であり、東西南北いずれかの方向に出て行く。つまり、白マスから出て行く矢印は１つである。

次に、その白マスに入ってくる矢印の数について考えよう。当然、ループで枝分かれしないのだから、どのマスで考えても、出るのも１つ、入るのも１つでなければならない。入るのが１つというのは、東西南北の隣マスを順番に調べて、それらが、今注目している白マスの方向に向いているかどうかを数えれば良いだろう。

  (+ (if (= w 1) 1 0)
   　(if (= n 2) 1 0)
     (if (= e 3) 1 0)
     (if (= s 4) 1 0))

これで、入ってくる数が決まる。そして入ってくる数は１でなければならない。そういうことを全部考えると、nextは次のようになるだろう。

(predicate (next  a e s w n)
        (or  (and (= a 0) (and (!= w 1) (!= n 2) (!= e 3) (!= s 4)))
             (and (!= a 0)
                  (= 1 
                     (+ (if (= w 1) 1 0)
                        (if (= n 2) 1 0)
                        (if (= e 3) 1 0)
                        (if (= s 4) 1 0))))))

プログラム： planeloop1-2.csp

さて、実行した結果はどうなったであろうか。

実行結果： planeloop1-2.txt

わかりやすいように、図に示した。（作るの面倒なんだ）

1,2,3,4の値は、全部矢印の向きに直して示してある。黒い矢印は、ちゃんとループになっている。しかし、赤い矢印の部分がダメだ。

なぜ？

矢印が互いにぶつかってしまっていたのを取り除かねばいけない。

つまり、もうすこし(predicate (next a e s w n) ... ) の条件を増やさねばならない。

具体的に考えてみよう。右向きの矢印（a=1）だったら、右のマスは、左向きの矢印であってはいけない(!= e 3)。つまり、

(and (= a 1) (!= e 3)）

となる。つまり、白マスならば、aは1〜4のいずれかなので、

    (or (and (= a 1) (!= e 3)）
        (and (= a 2) (!= s 4))
        (and (= a 3) (!= w 1))
        (and (= a 4) (!= n 2)))

を条件に加えれば良いはずだ。

(predicate (next  a e s w n)
        (or  (and (= a 0) (and (!= w 1) (!= n 2) (!= e 3) (!= s 4)))
             (and (!= a 0)
                  (or (and (= a 1) (!= e 3))
                      (and (= a 2) (!= s 4))
                      (and (= a 3) (!= w 1))
                      (and (= a 4) (!= n 2)))
                  (= 1 
                     (+ (if (= w 1) 1 0)
                        (if (= n 2) 1 0)
                        (if (= e 3) 1 0)
                        (if (= s 4) 1 0))))))

(!= a 0) は、無駄なので省略できるので、次のようになる。

(predicate (next  a e s w n)
        (or  (and (= a 0) (and (!= w 1) (!= n 2) (!= e 3) (!= s 4)))
             (and (or (and (= a 1) (!= e 3))
                      (and (= a 2) (!= s 4))
                      (and (= a 3) (!= w 1))
                      (and (= a 4) (!= n 2)))
                  (= 1 
                     (+ (if (= w 1) 1 0)
                        (if (= n 2) 1 0)
                        (if (= e 3) 1 0)
                        (if (= s 4) 1 0))))))

こう直したプログラムを示す。

プログラム： planeloop1-3.csp

実行結果： planeloop1-3.txt

図示したものを示す。

ループがちゃんと閉じているので一応成功だ。

しかし、２つのループになってしまった。これは今まで、他のパズルでも経験したことであり、別途制約を加えることで対応していこう。

ルール

Mon, 09 Feb 2009 16:40:27 +0900

いろいろなパズルを紹介してきたが、今回は非常にルールが簡単、それも超簡単なやつである。

ジャンルとしては、ループ系のパズルで、すべてのマスを通るループの作成だ。

まずは、ルールから。

もう説明の余地がないほど簡単だ。

このパズルは、実は、『ひまつぶしパズル集』のプレーンループ　全てのマスを一度ずつ通る(PDF) そのものである。

とりあえず、同じページの問題も載せておこう。

この問題を解きながら、sugarプログラム作成の戦略を次回までに考えよう。

完全虫食算

Wed, 04 Feb 2009 17:06:03 +0900

調子に乗って、さらに上のレベルの問題である、すべてのマスが虫食いの問題に挑戦してみよう。

といっても、その中にもいろいろなレベルが存在する。

次の問題では、最後に綺麗に割り切れるので０が存在する。

商の部分に「.」があるが、小数点である。

筆算での割り算表記は国により若干の相違があり、割りきれてしまう、引いたとき何も残らないとき、普通に線を引くのではなく、２重線を引いて割り切れたことを示すというのがあり、その場合には０も書かないので、「完全虫食い算」として扱うのである。

完全虫食い算になったからといって、プログラミングは何も変わらない。制約がどんどん少なくなるので、ちゃんともとまるのかどうかが不安になるだけである。

それでは、まず、自分で解いてみよう。自分の頭で解くもよし、プログラムで解くもよし。

完全虫食い算になったからといって、何も変わりはしない。縛りが少なくなるので、もしかしたら強烈に遅くなってしまわないかという懸念だけである。

今までと同様に、上から順に、各数（□のまとまり）についてaから順に変数を割り当てた。次の図では、割り当てたアルファベットを赤で示してある。

プログラムは、完全虫食い算になったため、制約が少なくなる。小数点が存在するが、小数点以下が０の場合にマスがなくなるが、プログラム上では０になるだけである

プログラム： mushikuizan5-1.csp

さて、実行速度はどうであろうか。帰ってくるだろうか。

では実行してみよう。今回は遅いかもしれない。

$ time sugar mushikuizan5-1.csp > mushikuizan5-1.txt

real    0m1.232s
user    0m0.964s
sys     0m0.132s
$

今回も、１秒で求まった。良かった。

実行結果： mushikuizan5-1.txt

　　　　　　１０１１１００８
　　　ーーーーーーーーーーー
６２５）６３１９３８
　　　　６２５
　　　　ーーーーー
　　　　　　６９３
　　　　　　６２５
　　　　　　ーーーー
　　　　　　　６８８
　　　　　　　６２５
　　　　　　　ーーーー
　　　　　　　　６３０
　　　　　　　　６２５
　　　　　　　　ーーーー
　　　　　　　　　　５０００
　　　　　　　　　　５０００
　　　　　　　　　　ーーーー
　　　　　　　　　　　　　０

小数点は書きにくかったので省略してある。

ということで、これで終わりとしても良いのだが、割り切れることを示す０も無くしたいと思わないか。つまり、数字がまったく現れない正真正銘の完全虫食い算は存在しないのだろうか？

最後の虫食い算として、０も存在しない問題を紹介しよう。

１９２１年に、オランダのFred Schuchが「American Mathematical Monthly」に発表した問題である。

同じ問題は、青空文庫の佐野昌一の『虫喰い算大会』の第28会場にも見られる。

０を失したかわりに、一番上の数（商）の上に、「・」が２箇所ある。これは、何だろうか？

循環小数であるが、循環小数なんて覚えているだろうか？

上の黒点は、点と点の間（両端の点もともに含む）が永久に繰り替えされるということである。

さて、これはどうやってプログラムを組めば良いのだろうか。つまり、循環小数であることをどういう制約にすればよいのだろうか。

今までと違うところは、循環小数の部分である。

そもそも、循環小数とは何か、筆算の上ではどのようになるか調べたであろうか。

まあ、調べたとして、話を進めよう。

    . .
1.23456

とは、

1.23456456456456456

ということで、上の点がついている数字を両端とする数字列が延々と繰り替えされることである。これは、1.23 の余りを割ると456となり、さらにその余りを割ると456tなり、というのが永久に繰り替えされることを示している。

これを、虫食算で示すと、次図の空色マスの部分が一致することである。

ということで、分かって欲しい。

これ以上書くのは面倒なのだ！

さて、いつものように、各数字に、a〜uまでの記号を割り当ててると、次図のようになる。

桁数も多いし、段数も多く、プログラムが長くなってしまった。延々と書くだけであるが、一発でバグを入れずに書くのは難しく、実際には徐々に試して行った。

プログラム： mushikuizan6-1.csp

実行してみよう。

$ time sugar mushikuizan6-1.csp > mushikuizan6-1.txt

real    3m2.152s
user    3m2.407s
sys     0m0.412s
$

３分もかかって、やっと結果が出てきた。結果はどうだろうか。

実行結果： mushikuizan6-1.txt

　　　　　　　　　　　　　　　・　　　　　　　・
　　　　　　　　　　　　１１６１６８８３０００１
　　　　　　ーーーーーーーーーーーーーーーーーーー
６６７３３４）７７５２３４１
　　　　　　　６６７３３４
　　　　　　ーーーーーーーーー
　　　　　　　１０７９００１
　　　　　　　　６６７３３４
　　　　　　　ーーーーーーーーー
　　　　　　　　４１１６６７０
　　　　　　　　４００４００４
　　　　　　　ーーーーーーーーーー
　　　　　　　　　１１２６６６０
　　　　　　　　　　６６７３３４
　　　　　　　　　ーーーーーーーーー
　　　　　　　　　　４５９３２６０
　　　　　　　　　　４００４００４
　　　　　　　　　ーーーーーーーーーー
　　　　　　　　　　　５８９２５６０
　　　　　　　　　　　５３３８６７２
　　　　　　　　　　ーーーーーーーーーー
　　　　　　　　　　　　５５３８８８０
　　　　　　　　　　　　５３３８６７２
　　　　　　　　　　　ーーーーーーーーーー
　　　　　　　　　　　　　２００２０８０
　　　　　　　　　　　　　２００２００２
　　　　　　　　　　　　ーーーーーーーーーーーーー
　　　　　　　　　　　　　　　　　　７８００００
　　　　　　　　　　　　　　　　　　６６７３３４
　　　　　　　　　　　　　　　　　ーーーーーーーー
　　　　　　　　　　　　　　　　　　１１２６６６

ということで、３分かかったものの、ちゃんと解けているようだ。

もっと大きな虫食算、さらには『世界最大の虫食い算』などもあるが、そこまで頑張るのは宿題にしておこう。

虫食算は以上で終わりにしておく。

孤独の７

Sun, 25 Jan 2009 22:25:55 +0900

同じく、割り算の虫食算であるが、今度は７が１つだけのを紹介しよう。最後が割りきれて０になってしまうので０もあるのだが、これはそういうものだと納得しよう。

これは、ドイツのアッカーマン（Wilhelm Ackermann, 1896〜1962)の１９２５年に出された「Scientific Paradoxes and Problems」に、E.F.オドリング(Egbert F. Odling)の「孤独の７」という問題である。

アッカーマンは、あのアッカーマン関数という悪魔のように計算量が爆発する関数を考案した数学者として有名である。

さて、そのアッカーマンの本に掲載された、オドリングの問題は次である。

途中の７が１つと、最後の０しか情報がないので大変に見えるかもしれない。今日は問題だけ示しておくので、ぜひ解いてみよう。

「７つの７の問題」と同様に解くことができる。上から順に、各数（□のまとまり）についてaから順に変数を割り当てた。次の図では、割り当てたアルファベットを赤で示してある。

プログラムは、「７つの７の問題」とまったく同じようにして作れる。そして、問題のサイズは小さくなっているので、プログラムは短くなっってしまったので、プログラムだけ載せておく。

プログラム： mushikuizan4-1.csp

さて、実行速度はどうであろうか。前回と違って、制約が少なくなってしまった。最後の０を入れても、数字が明示されているのは２つである。

では実行してみよう。今回は遅いかもしれない。

$ time sugar mushikuizan4-1.csp > mushikuizan4-1.txt

real    0m0.990s
user    0m1.028s
sys     0m0.092s
$

今回も、１秒で求まった。

実行結果： mushikuizan4-1.txt

　　　　　　　９７８０９
　　　ーーーーーーーーー
１２４）１２１２８３１６
　　　　１１１６
　　　　ーーーーー
　　　　　　９６８
　　　　　　８６８
　　　　　　ーーーー
　　　　　　１００３
　　　　　　　９９２
　　　　　　　ーーーーー
　　　　　　　　１１１６
　　　　　　　　１１１６
　　　　　　　　ーーーー
　　　　　　　　　　　０

さて、ここまでできるのなら、次は、まったく数字が現れない「完全虫食算」に挑戦しよう。

7つの7の問題

Sun, 25 Jan 2009 22:37:08 +0900

虫食算は百年以上の歴史があり、歴史的な名作を実際に解いてみよう。

まずは、７が７つ現れる問題を紹介しよう。

これは、英国の数学者ベリック（W.E.H.Berwick, 1888〜1944)が１９０６年に「The School World」に掲載したものである。

これは、あまりにも有名な古典的名作だそうである。この問題によって、虫食算が知的な大人の遊びとして認識されたとのことだ。（『数のパズル読本』秋山久義著、新紀元社　よりの受け売り。より詳しくは、この本を読まれたし。）

今日は、問題の提供だけにとどめておくので、ぜひ自分でプログラムしてみよう。

前回と同様に、上から順に、各数（□のまとまり）についてaから順に変数を割り当てた。次の図では、割り当てたアルファベットを赤で示してある。

掛け算と割り算では、見かけは違うが、実はそれほど差はない。筆算における割り算とは、結局掛け算と引き算を行っているだけに過ぎないので、特別な説明は不要だと思う。

ただし、プログラムで、１つだけ工夫というか、横着している部分があるので、その点だけを示すにどどめる。

用意したプログラムには、実は引き算は使っていない。引き算を、足し算に直して計算している。

つまり、　c - d = e があったら、　c = d + e に直してプログラムした。

これだけ頭に入れてプログラムを見れば、プログラムはただただ書いているだけというのが分かるだろう。

プログラムは140行にもなってしまったので、リンクだけにしておいた。

プログラム： mushikuizan3-1.csp

では、実行してみよう。本格的（？）な虫食算だと、どのくらい時間がかかるだろうか？

$ time sugar mushikuizan3-1.csp > mushikuizan3-1.txt

real    0m1.486s
user    0m1.740s
sys     0m0.188s
$

何と、またまたすぐに解けてしまった。

実行結果： mushikuizan3-1.txt

本当に正しいか、確認が必要だ。長くなるから、結果は実行結果ファイルを見てもらうことにして、筆算の形に直したものだけ載せておこう。

　　　　　　　　　　　　５８７８１
　　　　　　ーーーーーーーーーーーー
１２５４７３）７３７５４２８４１３
　　　　　　　６２７３６５
　　　　　　　ーーーーーーー
　　　　　　　１１０１７７８
　　　　　　　１００３７８４
　　　　　　　ーーーーーーーー
　　　　　　　　　９７９９４４
　　　　　　　　　８７８３１１
　　　　　　　　　ーーーーーーー
　　　　　　　　　１０１６３３１
　　　　　　　　　１００３７８４
　　　　　　　　　ーーーーーーーー
　　　　　　　　　　　１２５４７３
　　　　　　　　　　　１２５４７３
　　　　　　　　　　　ーーーーーー
　　　　　　　　　　　　　　　　０

今回の問題は、７が７つも存在したわけで、たくさんの制約があり、それで高速になっただけかもしれない。もうちょっと制約の少ない問題を探すことにしよう。

多倍長整数演算

Tue, 20 Jan 2009 10:10:00 +0900

虫食算や覆面算では、非常に桁数の多い問題も存在する。

sugarで整数がどこまで使えるか、ちょっと試しておこう。

まず、a + b = c の計算をしてみよう。ただし、a=12345, b=67890 とやや大きな数にしておく。

; long.csp

(domain num 0 999999)

(int a num)
(int b num)
(int c num)

(= (+ a b) c)

(= a 12345)
(= b 67890)

これを実行すると、

$ sugar long.csp
s SATISFIABLE
a a     12345
a b     67890
a c     80235
a
$

となり、和の80235がちゃんと得られた。

ここで、domainの範囲だけを拡大してみた。

; long.csp

(domain num 0 9999999999)

(int a num)
(int b num)
(int c num)

(= (+ a b) c)

(= a 12345)
(= b 67890)

これを実行すると、

$ sugar long.csp
c 0     ERROR Exception Illegal domain instantiation 0 -2
s UNKNOWN
$

となってしまった。

変数の値は変更していなくて、変数のドメインを変更しただけなのに、それだけで　Illegal domain　に成り果てたようだ。」

つまり、９桁はOKだが、１０桁の計算はできないということだ。

となると、１０桁以上がどこかに現れる虫食算はsugarでは不可能ということだ。

しかし、それでは、大型虫食算といわれる虫食算の大作には挑戦できないということだ。ちと情けないではないか。筆算には桁数制限などないのである。何万桁の虫食算だった作れるのだ。たぶん世界最大の虫食算は安福氏の『世界最大の虫食い算』文春新書に掲載されている2万桁の虫食算であろう。

まあ、こんな無茶な問題は別として、10桁以上が現れる虫食算はいくらでも存在する。そういうのもちゃんと解けるようにするには、sugarの桁数制限を突破しなくてはならない。

さて、どうすれば桁数制限のない計算が可能になるのだろうか？

例題の一部に対して、いくら桁が長くなっても大丈夫な方法で計算することを考えてみよう。

まず、以下の赤い部分だけの計算を考える。

５桁　×　１桁　⇒　５桁

の計算である。そのうち、一部の桁については、数字が決まっている。

この計算を、１桁毎にやっていくことを考えよう。そのためには、桁上がりが必要なので、次のように大文字の Cn を用いた。cnが積を示すのに対し、その途中の桁上がりについては、変数を大文字にして使うことにした。

sugarでの変数は、大文字、小文字を区別する。

上の図をsugarで示すと次のようになる。

(= (+ (* a1 b1)  0) (+ (* C1 10) c1))
(= (+ (* a2 b1) C1) (+ (* C2 10) c2))
(= (+ (* a3 b1) C2) (+ (* C3 10) c3))
(= (+ (* a4 b1) C3) (+ (* C4 10) c4))
(= (+ (* a5 b1) C4) (+ (* C5 10) c5))
(= C5 0)

と言いたいところだが、sugarでは変数同士の掛け算ができないので、工夫が必要である。

上の積の部分は、mul1 を用いて、中間の変数に１桁同士の掛け算の結果を記憶し、後で使うようにした。まあ、使い捨て変数みたいなものであるが、sugarでは必要だ。

(predicate (mul1 a b c)
           (element b ((* a 1) (* a 2) (* a 3)
                       (* a 4) (* a 5) (* a 6)
                       (* a 7) (* a 8) (* a 9))
                    c))

(mul1 a1 b1 a1b1) (= (+ a1b1  0) (+ (* C1 10) c1))
(mul1 a2 b1 a2b1) (= (+ a2b1 C1) (+ (* C2 10) c2))
(mul1 a3 b1 a3b1) (= (+ a3b1 C2) (+ (* C3 10) c3))
(mul1 a4 b1 a4b1) (= (+ a4b1 C3) (+ (* C4 10) c4))
(mul1 a5 b1 a5b1) (= (+ a5b1 C4) (+ (* C5 10) c5))
(= C5 0)

上記の計算のために、変数をあれこれ前もって宣言しておかねばならない。

(domain num 0 9)
(domain nn  0 99)

(int a5 num)(int a4 num)(int a3 num)(int a2 num)(int a1 num)
(int b1 num)
(int c5 num)(int c4 num)(int c3 num)(int c2 num)(int c1 num)
(int C5 num)(int C4 num)(int C3 num)(int C2 num)(int C1 num)

(int a5b1 nn)(int a4b1 nn)(int a3b1 nn)(int a2b1 nn)(int a1b1 nn)

(!= a5 0)
(!= b1 0)
(!= c5 0)

そして、最初から決まっている箇所を指定する。

(= a3 7)
(= c4 0) (= c2 7)
(!= b1 1)

ここまでの説明を全部まとめたのが次のプログラムである。

プログラム： mushikuizan2-1.csp

虫食算の一部だけなのだが、一応実行してみよう。

$ sugar mushikuizan2-1.csp
s SATISFIABLE
a a5    1
a a4    7
a a3    7
a a2    1
a a1    9
a b1    4
a c5    7
a c4    0
a c3    8
a c2    7
a c1    6
a C5    0
a C4    3
a C3    2
a C2    0
a C1    3
a a5b1  4
a a4b1  28
a a3b1  28
a a2b1  4
a a1b1  36
a
$

つまり、次の計算ができた。

　　１７７１９
　×　　　　４
ーーーーーーーー
　　７０８７６

このやり方だと、桁数はまったく関係ない。

さて、これで、

を解いたらどうなるだろうか。

前は、16分30秒ほど掛かっているが、この1桁毎のバラバラ事件で解くと、どのくらい掛かるだろうか？速くなるだろか、遅くなるだろうか、予想してみよう。

まず、最下段の最終的な積の部分を無視したプログラムを作った。

考え方は、前回示した mushikuizan2-1.csp の方法を３度繰り替えしただけであるので詳しい説明は省略し、プログラムを別ファイルで示す。

プログラム： mushikuizan2-2.csp

さあ、これを実行してみよう。どのくらい時間がかかるかも測定したいので、timeで計測しよう。

$ time sugar mushikuizan2-2.csp > mushikuizan2-2.txt

real    0m0.977s
user    0m0.984s
sys     0m0.100s
$

おかしい、前回16分30秒、つまり990秒もかかったのに、今回は1秒弱である。速度が1000倍になってしまった。こんなことはあるのだろうか。

もしかして、解が求まっていないのではないだろうか。

実行結果： mushikuizan2-2.txt

a a5    1
a a4    2
a a3    7
a a2    1
a a1    8
a b3    6
a b2    7
a b1    4
a c5    5
a c4    0
a c3    8
a c2    7
a c1    2
....

ということで、１２７１８×６７４になっているので正解だ。

恐ろしく早くなってしまった。

ついでに、最下段の積の部分も３つの積の和を求めることで完成させてみよう。この問題では影響はないが、普通は影響がでる。

最後の積（途中の３つの積の和）を求めるときにも、桁上がりのための変数を大文字の変数として用意した。その他はまったく同様にしてできるのと、図を描くのが面倒なので、図は省略し、プログラムを示す。

プログラム： mushikuizan2-3.csp

$ time sugar mushikuizan2-3.csp > mushikuizan2-3.txt

real    0m0.958s
user    0m1.064s
sys     0m0.140s
$

最下段を加えても、今回はトラブルも発生せず、ほぼ同じ時間で計算できてしまった。

実行結果： mushikuizan2-3.txt

結果は正しいと思うので、疑い深い人は確認されたし。

sugarは虫食算には向かないかと思ったが、もしかして向いているかも。

とりあえず解いてみよう

Sun, 18 Jan 2009 21:46:14 +0900

虫食い算は、どこかな算に非常に近い。周囲に矢印で数字の入る位置（列）を示すのではなく、一部の数字が決まっている。

説明を書くのも面倒なので、さっさと例題を示すことにしよう。

例題は、青空文庫の『虫喰い算大会』佐野昌一著から引用することにしよう。

第二十一会場の（１）の問題である。

この問題を、まずは虫食い算のところでやったような方法でプログラムしてみよう。

その前に、自分で頭と手で解いてみますか。ちゃんと解ければ、正月ボケはもう直っているでしょう。

さっそくプログラムを用意した。「どこかな算」より簡単である。

; mushikuizan1-1.csp

(domain num 0 9)

(int a5 num)(int a4 num)(int a3 num)(int a2 num)(int a1 num)
(int b3 num)(int b2 num)(int b1 num)
(int c5 num)(int c4 num)(int c3 num)(int c2 num)(int c1 num)
(int d5 num)(int d4 num)(int d3 num)(int d2 num)(int d1 num)
(int e5 num)(int e4 num)(int e3 num)(int e2 num)(int e1 num)
(int f7 num)(int f6 num)(int f5 num)(int f4 num)(int f3 num)(int f2 num)(int f1 num)

(= a3 7)
(= b2 7)
(= c4 0)(= c2 7)
(= d3 0)
(= e5 7)(= e2 0)

(predicate (mul1 a b c)
           (element b ((* a 1) (* a 2) (* a 3)
                       (* a 4) (* a 5) (* a 6)
                       (* a 7) (* a 8) (* a 9))
                    c))

(int na   10000  99999)  (= na (+ (* a5 10000) (* a4 1000) (* a3 100) (* a2 10) a1))
(int nb     100    999)  (= nb (+ (* b3 100) (* b2 10) b1))
(int nc   10000  99999)  (= nc (+ (* c5 10000) (* c4 1000) (* c3 100) (* c2 10) c1))
(int nd   10000  99999)  (= nd (+ (* d5 10000) (* d4 1000) (* d3 100) (* d2 10) d1))
(int ne   10000  99999)  (= ne (+ (* e5 10000) (* e4 1000) (* e3 100) (* e2 10) e1))
(int nf   1000000  9999999)  
    (= nf (+ (* f7 1000000) (* f6 100000) (* f5 10000) (* f4 1000) (* f3 100) (* f2 10) f1))

(mul1 na b1 nc)
(mul1 na b2 nd)
(mul1 na b3 ne)
(= (+ nc (* nd 10) (* ne 100)) nf)

プログラム： mushikuizan1-1.csp

では実行してみよう。

$ sugar mushikuizan1-1.csp

........ずっと待たされて

c 3758  ERROR Exception Too large /tmp/sugar25053.cnf
s UNKNOWN
$

となる。一体何が起きたのだろか？

/tmpの下には、きっとテンポラリ・ファイルができるだろうから、それが巨大になってどうにもならなくなって、Too large を出されて終わったようだ。

う〜む、やさしくはないけれど、この程度の問題で爆発してしまうのでは困るなぁ。リソースを食いつぶしやすいプログラムであると言われているのは、こういうことなんだろね。

さて、どうすれば良いだろうか？ここで引き下がってはいけない。

どうやったらリソースの浪費を減らせるであろうか。

問題をじーっと見つめていると、この問題には大いなる無駄がある。つまり、下図の赤で括っている部分である。

この赤い部分は、単に上の3行の和になっているだけで、問題に何の制約を加えている訳でもない。桁数も、上の３行を加えても、８桁になることはありえないので、７桁であること自体も解く手がかりを一切与えてくれない。

つまり、赤で括った積の部分は無くても問題としては何も変化がない。

パズル的に頭は使いたくなかったのだが、今回は特別に上記のことを考慮してプログラムを変更した。

以下に、変更部分（コメントアウト）だけを示す。最下段に関する部分を消すだけである。

.....
;(int f7 num)(int f6 num)(int f5 num)(int f4 num)(int f3 num)(int f2 num)(int f1 num)
.....
;(int nf   1000000  9999999)
;     (= nf (+ (* f7 1000000) (* f6 100000) (* f5 10000) (* f4 1000) (* f3 100) (* f2 10) f1))
.....
;(= (+ nc (* nd 10) (* ne 100)) nf)

プログラム： mushikuizan1-2.csp

これをもう一度実行し、我慢強く待っていると(16分も待っているのは大変だ！)

$ time sugar mushikuizan1-2.csp > mushikuizan1-2.txt

real    16m35.745s
user    16m28.370s
sys     0m3.916s

今度は、次の結果が得られた。

実行結果： mushikuizan1-2.txt

a na    12718
a nb    674
a nc    50872
a nd    89026
a ne    76308

最後の積（和）は自分で計算すると、次の解が得られていた。

　　　１２７１８
　　×　　６７４
ーーーーーーーーー
　　　５０８７２
　　８９０２６
　７６３０８
ーーーーーーーーー
　８５７１９３２

最下段は他から自動的に決まってしまうのだが、そういう判断は勝手にはやってくれず、最下段の変数の値も色々変更して探索しようとしてリソースを食いつぶしていたようだ。

ちょっとプログラム以外の手を使ってしまったが、まあこんな感じで虫食い算もなんとかできそうだ。

しかし、虫食い算にも色々あるので、まったく別の解き方を次から考えてみよう。

年賀パズル2009

Mon, 12 Jan 2009 19:19:00 +0900

年賀状に載せるパズルにはずいぶん悩むものだ。これで正しく受け取った相手が悩んでくれるか心配になる。難しすぎてもいけないし、やさし過ぎてもいけない。このところ、ナンプレが流行ってしまったので止むなくナンプレの問題にしていたが、それではまったく「ナンプレ・ボケ」しているのかと思われてしまう。

それで、今年はまったく別の考案されたパズルにしたわけである。

能書きよりも、どんな問題かを示そう。

とりあえずは手で解いて、次はプログラムで自分の頭の正常さ加減を調べるのが手順というものだろう。

プログラムは次回に示すので、まずは頭（手）で解いてみよう。

少し大きくなった分だけプログラムが長くなったが、まったく同様にして解くことができた。詳しい説明は不要と思う。実際のプログラムは、以下を参照のこと。

プログラム　dokokana8-1.csp

では、早速実行してみよう。

結果　　　　dokokana8-1.txt

肝心な部分を示す。

a na    257
a nb    7
a nc    1800
a nd    14
a ne    40
a nf    35
a ng    50
a nh    49
a ni    1

筆算の形に直したのが次である。

　　　２５７
　ーーーーー
７）１８００
　　１４
　　ーーー
　　　４０
　　　３５
　　　ーーー
　　　　５０
　　　　４９
　　　　ーー
　　　　　１

どこかな算は、虫食い算、それもすべてのマスが虫に食われている虫食い算である「完全虫食い算」に対して、少々ヒントを与えて、答えをユニークにしたものである。

ここで、基本に戻って、次は虫食い算についてやろう。

内容は同じようになってしまうと予想しているかも知れないが、決してそんなことはない。乞うご期待。

割り算

Sat, 10 Jan 2009 17:38:00 +0900

今度は割り算だ。

まずは簡単な例題を示そう。

こういうのを解くのであるが、どういう準備が必要だろうか。

そのために、掛け算のときを振り返ってみよう。

次のような１桁の割り算を用意した。

(predicate (mul1 a b c)
           (element b ((* a 1) (* a 2) (* a 3)
                       (* a 4) (* a 5) (* a 6)
                       (* a 7) (* a 8) (* a 9))
                    c))

これに習って、今度は１桁の数で割るのを用意しなければならない、のかなぁ。

いや、割る数は、１桁とは限らない。例題では偶然除数（カッコの左側の数）が1桁だが、通常は複数桁に及ぶし、そうでないとパズルとしては面白くない。

一体何を用意すれば、割り算が簡単にプログラムできるのか考えてみよう。

そのために、もう１つ例題を示しておく。つまり、こういうのが解きやすいようにするには、何を用意しておけば良いかということである。

宿題
割り算のためには、どんなpredicateを用意しておけば良いでしょうか？

割り算のためのpredicateは準備できましたか。

では、さっそく最初の例題から解いてみよう。

あまり何も考えずに、変数を次のように上から順に規則的に決めた。

　　　  na
    --------
nb  )   nc
        nd
      ------ 
        ne

この例題では、ncだけが２桁で、その他は全部1桁の数に過ぎないのだが、それぞれ、各桁毎に別に変数を掛け算のときと同じように用意した。

1桁の場合は簡単なので、とりあえず一気にプログラムを見せてしまおう。

(domain num 0 9)

                               (int a1 num)
(int b1 num)      (int c2 num) (int c1 num)
                               (int d1 num)
                               (int e1 num)

(predicate (mul1 a b c)
           (element b ((* a 1) (* a 2) (* a 3)
                       (* a 4) (* a 5) (* a 6)
                       (* a 7) (* a 8) (* a 9))
                    c))

(int na   1   9)  (= na a1)
(int nb   1   9)  (= nb b1)
(int nc  10  99)  (= nc (+ (* c2 10) c1))
(int nd   1   9)  (= nd d1)
(int ne   0   9)  (= ne e1)

(mul1 nb a1 nd)       ; nb * a1 = nd
(= (- nc nd) ne)

(predicate (exist4 v x1 x2 x3 x4)
    (or (= v x1) (= v x2) (= v x3) (= v x4)))

(exist4 7  a1 c1 d1 e1)
(exist4 8  -1 b1 c2 c1)

ちょっとだけ付け加えておくと、余りのneに関しては０もありうるので、注意が必要だ。

プログラム　dokokana6-1.csp

では、早速実行してみよう。

結果　　　　dokokana6-1.txt

結果の肝心な部分を以下に示す。

a na    1
a nb    8
a nc    17
a nd    8
a ne    9

これを筆算の形になおすと次のようになる。

　　　１
　ーーー
８）１７
　　　８
　　ーー
　　　９

ちゃんとできていることを確かめて、次へ進もう。

さて、以下の筆算をちゃんと確認しただろうか。

　　　１
　ーーー
８）１７
　　　８
　　ーー
　　　９

これはもちろん不正解で、こんな筆算をしていたのでは小学校で落第してしまう。

では、どこがダメなのだろうか。

８で割っているのに、余りが９になっているからダメなのである。

余りは、割る数より小さくなければならない。

これを数式で表すと、

nb > ne

となる。

sugarでは、

(> nb ne)

である。

これを加えたプログラムを示す。

プログラム　dokokana6-2.csp

では、早速実行してみよう。

結果　　　　dokokana6-2.txt

a na    1
a nb    8
a nc    15
a nd    8
a ne    7

より

　　　１
　ーーー
８）１５
　　　８
　　ーー
　　　７

となり、商は相変わらず１であるが、余りの７は割る数８より小さくなった。

今度は大丈夫なようだ。

では、次の大きな問題にチャレンジしよう。

問題が大きくなった分だけsugarのプログラムが長くなったが、特別なことは何もしていないので、詳しくはプログラムを参照のこと。

プログラム　dokokana7-1.csp

では、早速実行してみよう。

結果　　　　dokokana7-1.txt

結果の肝心な部分は以下である。

a na    38
a nb    19
a nc    740
a nd    57
a ne    170
a nf    152
a ng    18

これを、筆算に反映すると、次のようになる。

　　　　３８
　　ーーーー
１９）７４０
　　　５７
　　　ーーー
　　　１７０
　　　１５２
　　　ーーー
　　　　１８

もうここまでくれば、どんな「どこかな算」でも大丈夫と思うがどうだろか。

次は、年賀パズル2009として年賀状にて全国に出題された問題を解いてみよう。

掛け算

Mon, 05 Jan 2009 14:12:00 +0900

では、掛け算の場合の「どこかな算」の問題を示そう。

掛け算になったからといって、特別なことはない。同じようにプログラムすれば良いはずだ。

ということで、プログラムしてみた。

プログラム： dokokana4-1.csp

(domain num 0 9)

(int a2 num) (int a1 num)
             (int b1 num)
(int c2 num) (int c1 num)

(int na  10  99)  (= na (+ (* a2 10) a1))
(int nb   1   9)  (= nb b1)
(int nc  10  99)  (= nc (+ (* c2 10) c1))
(= (* na nb) nc)

(predicate (exist3 v x1 x2 x3)
    (or (= v x1) (= v x2) (= v x3)))
(exist3 5  a1 b1 c1)
(exist3 7  a1 b1 c1)

説明する必要があるような箇所はないと思う。

それでは実行してみよう。

$ sugar dokokana4-1.csp
c 1     ERROR Exception Unsupported (mul na nb)
s UNKNOWN
$

何とエラーだ。(mul na nb)がダメらしい。

でも、これってタダの掛け算ではないか。何か間違ったかな？？

掛け算でエラーが出てしまった。こういう時には、マニュアルを調べ直すに限る。

At least one argument of mul should be an integer constant. 
However, some special cases (such as (< (* x y) 0)) 
are allowed.

困った。英語である。

掛け算の場合、どうも少なくとも１つのアーギュメント（引数）は整数定数でないといけないようだ。でも、結果が負の場合は許されるらしい。なんでかなぁ、まあいいや。

この但し書きに引っかかってしまったようだ。しかし、「どこかな算」では、どこも変数なのである。定数では問題にそもそもならないではないか。

でも、何とか解決する方法はないだろうか。

今解こうとしているのは、「どこかな算」であって、普通の掛け算ではない。どこかな算が解けるようにさえなれば充分だ。

どこかな算の場合、　a * b = c の式において、乗数のbは、すべて1桁（１〜９）と仮定しても構わない。

それで、この条件の掛け算を行う mul1 というpredicateをでっち上げてみた。

(predicate (mul1 a b c)
           (element b ((* a 1) (* a 2) (* a 3)
                       (* a 4) (* a 5) (* a 6)
                       (* a 7) (* a 8) (* a 9))
                    c))

ここで、elementというのを使ってみた。シンタックスは次のようになっている。

ElementConstraint ::=
    (element Index (Term+) Value)
Index ::=
    Term
Value ::=
    Term

bをインデックスにし、(Term+)つまりリストに結果を１から順に並べて用意しておく。そして、このリストのインデックスで示される項は、リストの後に書かれている項（値）に一致するということだ。

文で説明するのは分かりづらい。ブログラムを見てほしい。

プログラム： dokokana4-2.csp

実行結果： dokokana4-2.txt

a na    17
a nb    5
a nc    85

より、

　１７
×　５
ーーー
　８５

が分かる。

例題は、もっとも小さなサイズの掛け算の問題だった。もうちょっと大きな、普通の問題を示しておこう。

さて、上の問題を解いてみよう。

といっても、至って簡単である。

(domain num 0 9)

                          (int a2 num) (int a1 num)
                          (int b2 num) (int b1 num)
             (int c3 num) (int c2 num) (int c1 num)
(int d3 num) (int d2 num) (int d1 num)
(int e4 num) (int e3 num) (int e2 num) (int e1 num)

(predicate (mul1 a b c)
           (element b ((* a 1) (* a 2) (* a 3)
                       (* a 4) (* a 5) (* a 6)
                       (* a 7) (* a 8) (* a 9))
                    c))

(int na   10   99)  (= na (+ (* a2 10) a1))
(int nb   10   99)  (= nb (+ (* b2 10) b1))
(int nc  100  999)  (= nc (+ (* c3 100) (* c2 10) c1))
(int nd  100  999)  (= nd (+ (* d3 100) (* d2 10) d1))
(int ne 1000 9999)  (= ne (+ (* e4 100) (* e3 100) (* e2 10) e1))

(mul1 na b1 nc)
(mul1 na b2 nd)
(= (+ nc (* nd 10)) ne)

(predicate (exist3 v x1 x2 x3)
    (or (= v x1) (= v x2) (= v x3)))
(exist3 4  c3 c2 c1)
(exist3 5  d3 d2 d1)
(exist3 9  -1 d3 e4)

上から順に、横に並んだ数を na,nb,nc,nd,ne とし、各□に対して、a1,a2 のように変数を割り当てた。そして、掛け算を１桁ずつ実行し、結果を全部足せばよい。

最後に、矢印で示された条件を追加したに過ぎない。

プログラム　dokokana5-1.csp

結果　　　　dokokana5-1.txt

結果の肝心な部分は

a na    38
a nb    49
a nc    342
a nd    152
a ne    1862

であり、これを筆算の形にすると次のようになる。

　　３８
×　４９
ーーーー
　３４２
１５２
ーーーー
１８６２

もう、ここまでできれば、もっと大きな掛け算の「どこかな算」も平気であろう。

次から割り算の説明をしよう。

足し算

Sat, 03 Jan 2009 09:36:00 +0900

例題として非常にやさしい問題を示したが、もうちょっと普通に難しい足し算の「どこかな算」の問題を２題示しておく。

矢印１つにつき、２つ以上の数字が示されていることもある。最初の例では、１つの矢印に６と８があるが、矢印の方向のどこかに、６もあり、８もあるということである。

プログラム的にも、人間が解くにしても、これは条件が増えるだけなので、解きやすくなるだけである。

今日は、答えは出さないので、自分の頭で解くか、sugarで解くか、はたまた何らかのプログラミング言語で解くかしてみよう。

とても簡単だっただろうか。

それぞれのsugarのプログラムを結果を示そう。

問題　その１

dokokana2-1.csp

(domain num 0 9)
             (int a1 num)
(int b2 num) (int b1 num)
(int c2 num) (int c1 num)
(int d2 num) (int d1 num)

(int na 1 9)    (= na a1)
(int nb 10 99)  (= nb (+ (* b2 10) b1))
(int nc 10 99)  (= nc (+ (* c2 10) c1))
(int nd 10 99)  (= nd (+ (* d2 10) d1))
(= (+ na nb nc) nd)

(predicate (exist2 v x1 x2)
    (or (= v x1) (= v x2)))
(predicate (exist4 v x1 x2 x3 x4)
    (or (= v x1) (= v x2) (= v x3) (= v x4)))
(exist4 6  -1 b2 c2 d2)
(exist4 8  -1 b2 c2 d2)
(exist4 0  a1 b1 c1 d1)
(exist2 9  -1 a1)
(exist2 6  b2 b1)
(exist2 5  c2 c1)

結果　dokokana2-1.txt

a na    9
a nb    60
a nc    15
a nd    84

より

　　９
　６０
＋１５
ーーー
　８４

が得られた。

問題　その２

プログラム　dokokana3-1.csp

(domain num 0 9)

             (int a2 num) (int a1 num)
(int b3 num) (int b2 num) (int b1 num)
(int c3 num) (int c2 num) (int c1 num)

(int na  10  99)  (= na (+ (* a2 10) a1))
(int nb 100 999)  (= nb (+ (* b3 100) (* b2 10) b1))
(int nc 100 999)  (= nc (+ (* c3 100) (* c2 10) c1))
(= (+ na nb) nc)

(predicate (exist3 v x1 x2 x3)
    (or (= v x1) (= v x2) (= v x3)))
(exist3 3  -1 b3 c3)
(exist3 8  a2 b2 c2)
(exist3 5  a1 b1 c1)
(exist3 4  -1 a2 a1)
(exist3 0  b3 b2 b1)
(exist3 9  c3 c2 c1)

結果　dokokana3-1.txt

a na    84
a nb    305
a nc    389

より

　　８４
＋３０５
ーーーー
　３８９

が得られた。

「どこかな算」あるいは「虫食い算」の足し算はここまでにしておく。

次は「引き算」と考えるのが普通だろうが、引き算はあまり好まれない。内容的に、足し算とあまり変わらないからである。そして、複数の項を足したり引いたりするためには、それぞれの前に＋ーをつけなければいけなくて、どうも美的センスに欠ける、つまりパズルとして美しくないのだ。美しくないパズルがあっては良くない。ということかどうかは知らないが、引き算は省略する。

本当におもしろくなるのは、掛け算や割り算なので、次からそちらに進む。

とりあえずプログラミング

Thu, 01 Jan 2009 18:48:00 +0900

とりあえず、次の問題でsugarのプログラムをでっちあげてみよう。

まず、マスには０〜９の数字が入る、０〜９の数字しか入らないという制約のために、 numというdomainを用意しておこう。

(domain num 0 9)

□は、場所によっては０が入らなくなるのだが、それは別の方法で制約しよう。

すると、マスの配置にしたがって、次のように変数を用意した。問題の形に合わせて、適当に空白が入っている。

             (int a1 num)
(int b2 num) (int b1 num)
(int c2 num) (int c1 num)

次に、足し算が成り立っていることをsugarで書いてみる。そのために、各横列が示す数を上から、na, nb, nc として計算した。

(int na 1 9)    (= na a1)
(int nb 10 99)  (= nb (+ (* b2 10) b1))
(int nc 10 99)  (= nc (+ (* c2 10) c1))
(= (+ na nb) nc)

ここまでで実行してみよう。

プログラム： dokokana1-1.csp

実行結果： dokokana1-1.txt

さて、この結果はどうだっただろうか？

a na    2
a nb    97
a nc    99

より

　　２
＋９７
ーーー
　９９

となっていることが分かる。

確かに足し算としては正しいが、周囲の矢印で示された条件はまだ満たしていない。

周囲のヒント（数字）に対処していこう。

そのために、１つだけ道具を用意しよう。 Nマスにある数（つまり矢印のところの数）の存在を確かめる制約を作ってみた。

マスの並びは２マスと３マスがあるが、多ければ少ない方はなんとかなるだろうから３マスの場合に対応したpredicateを作った。

(predicate (exist3 v x1 x2 x3)
    (or (= v x1) (= v x2) (= v x3)))

順番に等しいかどうか確認しているだけなので、何も説明はいらないだろう。

そして、これを周囲の、１、７、４について適用してみた。

(exist3 1  -1 b2 c2)
(exist3 7  a1 b1 c1)
(exist3 4  -1 c2 c1)

１や４は２マスに対するヒントなので、１つ使われない引数が存在するが、そこには「-1」を入れておいた。これは、-1ならば、絶対にマスに入れられない数値であり、偶然一致することがないからである。

プログラム： dokokana1-2.csp

実行結果： dokokana1-2.txt

a na    7
a nb    17
a nc    24

より、

　　７
＋１７
ーーー
　２４

であることが分かり、条件を満たしている。

どこかな算とは

Thu, 01 Jan 2009 16:14:51 +0900

小学校の算数には「何とか算」という名前が付いた特徴ある計算方式がたくさんあったのを覚えているだろうか。ここでは、「どこかな算」というのを、sugarを使って解いてみるこのだが、もう「どこかな算」はどんなものだったか思い出しただろうか。

次が問題である。

これだけでは、何だか「虫食い算」みたいだろう。実は、虫食い算にちょっと工夫がされて、小学校でも使えるように工夫されたものだ。大きな違いは、矢印があって、そこに数字が書かれていることである。

まず、「どこかな算」のルールなるものを紹介しておこう。

ルール
空いている□に数字を入れて、正しい筆算にしてください。
まわりの数字は、その列のどこかに必ず入ります。

さあ、上の問題を解いてみよう。

答えは来年になったら教えることにしよう。

なお、虫食い算と同じで、２桁以上になっているところの最上位桁の□には０は入らない。

年も明けたので、問題の答えを示そう。まさか解けなかった人はいないと思うが、念のため答えを示す。

さて、「どこかな算」は「虫食い算」にヒントを加えたものになっていることが分かっただろうか。

矢印のヒントがないと虫食い算になってしまう。とくに、すべての数字が虫に食われている虫食い算を「完全虫食い算」という。そして、「完全虫食い算」の問題は非常に作り難いし、解くのも大変である。少なくとも人間には。

普通の虫食い算は、いくつかの数字が最初からあって、それらを手がかりにして解いていく。

それに対して、「どこかな算」は、完全虫食い算の形にしておいて、縦や横の並びに対して、こういう数字が入っているよ、というヒントを加えたものである。

これにより、問題自体も作りやすくなるし、問題自体も非常に教育的で、このところ小学校や学習塾で非常にはやっていると風の噂に聞いている。周りに知っている人がいるかぜひ確かめて欲しい。

それでは、次から、sugarで問題を解いていこう。

木構造

Thu, 25 Dec 2008 18:18:22 +0900

ルールの中にループがあってはいけないというのがあったのだが、得られた図はループだらけであった。

ループをなくすには、どうすれば良いだろうか。

これには、木構造にするのが便利である。最初から完全な木構造にする前に、各頂点に関する条件をすこしずつ考えていこう。

枝（矢印）は、末端からルート（頂点）に向かっていくものとする。

今まで、頂点につながっている矢印の数（出入りともにカウント）を数えていたが、出るのと、入るのと、両方別々に数えることにしよう。

そのために、cixy, coxy, cnxy という３種の変数を考える。 x, y の部分は、座標を示す。

cixyは頂点xyに入る矢印数、coxyは頂点xyから出る矢印数、そして、cnxyは、その頂点に出入りする矢印数で、

cnxy = cixy + coxy

が当然成り立つ。また、木構造にしたことで、頂点から出る矢印数は高々１になった。

このために、まず、以下を削除し、

;;　削除
(domain d8 0 8)
(int c11 d8) (int c21 d8) (int c31 d8) (int c41 d8) (int c51 d8) (int c61 d8) (int c71 d8)
(int c12 d8) (int c22 d8) (int c32 d8) (int c42 d8) (int c52 d8) (int c62 d8) (int c72 d8)
(int c13 d8) (int c23 d8) (int c33 d8) (int c43 d8) (int c53 d8) (int c63 d8) (int c73 d8)
(int c14 d8) (int c24 d8) (int c34 d8) (int c44 d8) (int c54 d8) (int c64 d8) (int c74 d8)
(int c15 d8) (int c25 d8) (int c35 d8) (int c45 d8) (int c55 d8) (int c65 d8) (int c75 d8)
(int c16 d8) (int c26 d8) (int c36 d8) (int c46 d8) (int c56 d8) (int c66 d8) (int c76 d8)
(int c17 d8) (int c27 d8) (int c37 d8) (int c47 d8) (int c57 d8) (int c67 d8) (int c77 d8)

この代わりに、次の配列を用意した。

;; 追加

(domain d8 0 8)
(int cn11 d8) (int cn21 d8) (int cn31 d8) (int cn41 d8) (int cn51 d8) (int cn61 d8) (int cn71 d8)
(int cn12 d8) (int cn22 d8) (int cn32 d8) (int cn42 d8) (int cn52 d8) (int cn62 d8) (int cn72 d8)
(int cn13 d8) (int cn23 d8) (int cn33 d8) (int cn43 d8) (int cn53 d8) (int cn63 d8) (int cn73 d8)
(int cn14 d8) (int cn24 d8) (int cn34 d8) (int cn44 d8) (int cn54 d8) (int cn64 d8) (int cn74 d8)
(int cn15 d8) (int cn25 d8) (int cn35 d8) (int cn45 d8) (int cn55 d8) (int cn65 d8) (int cn75 d8)
(int cn16 d8) (int cn26 d8) (int cn36 d8) (int cn46 d8) (int cn56 d8) (int cn66 d8) (int cn76 d8)
(int cn17 d8) (int cn27 d8) (int cn37 d8) (int cn47 d8) (int cn57 d8) (int cn67 d8) (int cn77 d8)

(int ci11 d8) (int ci21 d8) (int ci31 d8) (int ci41 d8) (int ci51 d8) (int ci61 d8) (int ci71 d8)
(int ci12 d8) (int ci22 d8) (int ci32 d8) (int ci42 d8) (int ci52 d8) (int ci62 d8) (int ci72 d8)
(int ci13 d8) (int ci23 d8) (int ci33 d8) (int ci43 d8) (int ci53 d8) (int ci63 d8) (int ci73 d8)
(int ci14 d8) (int ci24 d8) (int ci34 d8) (int ci44 d8) (int ci54 d8) (int ci64 d8) (int ci74 d8)
(int ci15 d8) (int ci25 d8) (int ci35 d8) (int ci45 d8) (int ci55 d8) (int ci65 d8) (int ci75 d8)
(int ci16 d8) (int ci26 d8) (int ci36 d8) (int ci46 d8) (int ci56 d8) (int ci66 d8) (int ci76 d8)
(int ci17 d8) (int ci27 d8) (int ci37 d8) (int ci47 d8) (int ci57 d8) (int ci67 d8) (int ci77 d8)

(domain d1 0 1)
(int co11 d1) (int co21 d1) (int co31 d1) (int co41 d1) (int co51 d1) (int co61 d1) (int co71 d1)
(int co12 d1) (int co22 d1) (int co32 d1) (int co42 d1) (int co52 d1) (int co62 d1) (int co72 d1)
(int co13 d1) (int co23 d1) (int co33 d1) (int co43 d1) (int co53 d1) (int co63 d1) (int co73 d1)
(int co14 d1) (int co24 d1) (int co34 d1) (int co44 d1) (int co54 d1) (int co64 d1) (int co74 d1)
(int co15 d1) (int co25 d1) (int co35 d1) (int co45 d1) (int co55 d1) (int co65 d1) (int co75 d1)
(int co16 d1) (int co26 d1) (int co36 d1) (int co46 d1) (int co56 d1) (int co66 d1) (int co76 d1)
(int co17 d1) (int co27 d1) (int co37 d1) (int co47 d1) (int co57 d1) (int co67 d1) (int co77 d1)

次に、頂点の接続数に関する count predicate を変更した。

変更前のものは

(predicate (count c nwst nth nest est sest sth swst wst)
  (= (+ (abs nwst) (abs nth) (abs nest) (abs est)
        (abs sest) (abs sth) (abs swst) (abs wst))
     c))

頂点への出入りの方向は考えていなかったので単に絶対値をとって加えただけだったが、今度は、ちゃんと方向を考えながら加えるようにした。そうしたら長くなってしまった。

;; 変更後

(predicate (count cn ci co nwst nth nest est sest sth swst wst)
  (and
     (= (+ (if (= wst   1) 1 0)
           (if (= nwst  1) 1 0)
           (if (= nth   1) 1 0)
           (if (= nest  1) 1 0)
           (if (= est  -1) 1 0)
           (if (= sest -1) 1 0)
           (if (= sth  -1) 1 0)
           (if (= swst -1) 1 0))
         ci)
     (= (+ (if (= wst  -1) 1 0)
           (if (= nwst -1) 1 0)
           (if (= nth  -1) 1 0)
           (if (= nest -1) 1 0)
           (if (= est   1) 1 0)
           (if (= sest  1) 1 0)
           (if (= sth   1) 1 0)
           (if (= swst  1) 1 0))
         co)
     (= cn (+ ci co))))

前との違いは、前は矢印の数を示す引数が１つだけ(c)だったのが、変更後は　cn ci co の３個になってしまった。

これにより、count を使っている箇所の書き方が変更になった。変更は以下のとおり、規則的である。

変更前  (count c42 d31 v41 e51 h42 d42 v42 e42 h32)

変更後　(count cn42 ci42 co42 d31 v41 e51 h42 d42 v42 e42 h32)

ただし、countは、頂点の数だけ、この制約が並ぶことになる。この変更は省略する。

では、プログラムと実行結果をみてみよう。

プログラム： oct3-3.csp

実行結果： oct3-3.txt

さて、図を示したいところだが、長くなったので、次回にしよう。

図示すると、つぎのようになった。赤い箇所がルールに従っていない。

この赤い部分全体がルートになっていると言えば良いだろうか。このように、最上位のレベルがルートになってしまうことがある。

まず、ルートとはなんであろうか。

ルート
入力矢印が１つ以上存在し、出力矢印が存在しない箇所である。

これに基づいて判断すると、ループに含まれる点は出力矢印があるわけだから、ルートにはなれない。

したがって、上図は、ルート個数が０個ということになる。

ルートとなる点が１つという制約をつけてみよう。

まず、各頂点が、ルートだったときに１になり、そうでないとき０になるようにしよう。 bool変数（true/false）するのが普通だと思うが、それには訳がある。

まず、rootというpredicateを作った。

(predicate (root rt ci co)
           (= rt (if (and (= co 0) (> ci 0)) 1 0)))

ルートかどうかを、上で定義したとおりの方法で判定している。

パラメータの意味は、rt がルート判定を示し、 ciが入力矢印数、coが出力矢印数を示す。

これを全頂点について適用する。

(root rt11 ci11 co11)
(root rt21 ci21 co21)
(root rt31 ci31 co31)
(root rt41 ci41 co41)
(root rt51 ci51 co51)
(root rt61 ci61 co61)
(root rt71 ci71 co71)
..... 以下省略

これで、各頂点がルートになっているかどうかを 1/0 で求められる。

ループしないためには、また複数に分かれないためには、ルート（根っこ）の個数が１でなければならない。

これを実現するには、全頂点の、ルート判定変数 rtxy を加えると、これがルートの個数を示すので、それが１であるという制約にした。

(= 1 (+ rt11 rt21 rt31 rt41 rt51 rt61 rt71
        rt12 rt22 rt32 rt42 rt52 rt62 rt72
        rt13 rt23 rt33 rt43 rt53 rt63 rt73
        rt14 rt24 rt34 rt44 rt54 rt64 rt74
        rt15 rt25 rt35 rt45 rt55 rt65 rt75
        rt16 rt26 rt36 rt46 rt56 rt66 rt76
        rt17 rt27 rt37 rt47 rt57 rt67 rt77))

最後の、ルートが１個の場合に、こういう方法を使うのは常套手段なのだろう。何だったか忘れたが、パズルをSugar制約ソルバーで解くで勉強したのであった。

では、プログラムと実行結果をみてみよう。

プログラム： oct3-4.csp

実行結果： oct3-4.txt

そして、結果はこうなった。

空色がルートである。

木構造では、ルートの場所はどこでも大丈夫になる。これは知っていないとまずい。なお、理由は、自分で考えてみよう。

ということで、オクトパスは、これで終わりとする。

黒点では交差しない

Wed, 17 Dec 2008 11:05:00 +0900

うまく行かなかった結果について、問題点の１つを赤で示した。

ここで問題としているのは、黒点のマスは、線が通過するだけで、枝分かれや交差してはいけないのだが、上手の赤の点では交差している。

これを取り除くための制約について考えよう。

現在、数字の入っている白丸についてだけ次のような制限を加えている。

(predicate (cchk a c)
   (=> (> a 0) (= a c)))

(> a 0)　つまり、a が正（数字の値）のときだけ、実際の接続数(c)と丸数字の値(a) が一致という条件になっている。

これに、黒点の時、つまり a が -1（あるいは負）の時の条件を付け加えてみた。

(predicate (cchk a c)
   (or (and (> a 0) (= a c))
       (= a 0)
       (and (< a 0) (or (= c 0) (= c 2)))))

調べていることは、とても簡単である。

正：白丸に正の数字が入っている場合、丸数字の値と接続数は一致する。
０：白丸のままの場合、何も制限を加えない。
負：黒点の場合、接続数は0または2（通過）でなければならない。

プログラム： oct3-2.csp

実行結果： oct3-2.txt

さて、これを図示すると

となり、黒点に関しては正常になった。

しかし、まだいろいろな問題が残っているようだ。

より大きな問題

Thu, 11 Dec 2008 19:28:00 +0900

４×４という非常に小さな問題が解けただけではいけない。より大きな問題について試していこう。

といっても、まずは５×５にしておこう。

この問題に対する sugarのプログラムを作ってみよう。

単に作るのでは面白くないので、１つだけ工夫をした。ただの黒点について通過するというだけの predicate であるが、これは本当の黒点についてだけ制約を書いたのだが、これでは問題を見て、黒点についてだけ制約をつけるということになり汎用性が低い。白丸、黒点を一切考えることなく規則的にというか、機械的に処理できるようにしてみた。

(predicate (through a nwst nth nest est sest sth swst wst)
  (=> (< a 0)
    (and (= nwst sest)
         (= nth  sth )
         (= nest swst)
         (= est  wst ))))

各点について、axyの値を引数に加え、axyの値が負だった場合には通過の判断をし、そうでない場合（白丸）には何もしないようにした。

各点に関する制約は、次のように機械的に書ける。

(through a11  0   0   0  h11 d11 v11  0   0 )
(through a21  0   0   0  h21 d21 v21 e21 h11)
(through a31  0   0   0  h31 d31 v31 e31 h21)
(through a41  0   0   0  h41 d41 v41 e41 h31)
(through a51  0   0   0   0   0  v51 e51 h41)
(through a12  0  v11 e21 h12 d12 v12  0   0 )
(through a22 d11 v21 e31 h22 d22 v22 e22 h12)
(through a32 d21 v31 e41 h32 d32 v32 e32 h22)
(through a42 d31 v41 e51 h42 d42 v42 e42 h42)
(through a52 d41 v51  0   0   0  v52 e52 h42)
(through a13  0  v12 e22 h13 d13 v13  0   0 )
(through a23 d12 v22 e32 h23 d23 v23 e23 h13)
(through a33 d22 v32 e42 h33 d33 v33 e33 h23)
(through a43 d32 v42 e52 h43 d43 v43 e43 h33)
(through a53 d42 v52  0   0   0  v53 e53 h43)
(through a14  0  v13 e23 h14 d14 v14  0   0 )
(through a24 d13 v23 e33 h24 d24 v24 e24 h14)
(through a34 d23 v33 e43 h34 d34 v34 e34 h24)
(through a44 d33 v43 e53 h44 d44 v44 e44 h34)
(through a54 d43 v53  0   0   0  v54 e54 h44)
(through a15  0  v14 e24 h15  0   0   0   0 )
(through a25 d14 v24 e34 h25  0   0   0  h15)
(through a35 d24 v34 e44 h35  0   0   0  h25)
(through a45 d34 v44 e54 h45  0   0   0  h35)
(through a55 d44 v54  0   0   0   0   0  h45)

プログラム： oct2-1.csp

実行結果： oct2-1.txt

さて、この結果はどうだろうか？

この５×５の問題は大丈夫のようだ。

では、待望の、７×７の次の問題に挑戦してみよう。

説明は省略し、sugarのプログラムと結果を見てみよう。

プログラム： oct3-1.csp

実行結果： oct3-1.txt

さて、これを図示すると

のように無茶苦茶になってしまった。

さて、どこから手をつけようか。

黒点は通過

Wed, 26 Nov 2008 21:06:00 +0900

現状の図を見てみよう。

そして、答えも見てみよう。

丸数字は色々な接続が可能だが、黒点に関しては、そこはまっすぐ通過するだけである。

線分だけ見れば、直線になっていて通過するように見えるのにも、次の３種類がある。

(1) →・→
(2) →・←
(3) ←・→

ここでは、(1)の、文字通り通過するものだけをOKとする。

方向としては、ー、｜、＼、／の４つの方向があり、さらに、それぞれに向きがある。各方向について、通過する点（・）の両端の有向辺（矢印）が、もし存在するならば、同じ方向を向いていなければならない。ということは、同じ値でなければならない。また、共に存在しない(0)というのもOKなので、通過する点（・）の両端の有向辺の値は同じということになる。

点（・）の周囲の有向辺の値
 nwst nth nest est sest sth swst wst
に対して、４方向の通過は次のように示せる。
　　　　　
(= nwst sest)   北西：南東
(= nth  sth )　   北：南
(= nest swst)   北東：南西
(= est  wst )　   東：西

これより、

(predicate (through nwst nth nest est sest sth swst wst)
    (and (= nwst sest)
         (= nth  sth )
         (= nest swst)
         (= est  wst )))

を用意し、すべての黒点（丸数字の点を除く）について、調べれば良い。

(through  0   0   0  h31 d31 v31 e31 h21)
(through  0  v11 e21 h12 d12 v12  0   0 )
(through d11 v21 e31 h22 d22 v22 e22 h12)
(through d31 v41  0   0   0  v42 e42 h32)
(through  0  v12 e22 h13 d13 v13  0   0 )
(through d22 v32 e42 h33 d33 v33 e33 h23)
(through d32 v42  0   0   0  v43 e43 h33)
(through d13 v23 e33 h24  0   0   0  h14)

プログラム： oct1-3.csp

実行結果： oct1-3.txt

さて、この結果はどうだろうか？

正解になっているようだ、めでたし、めでたし。プログラムは完成だ。

と喜んで良いのだろうか。

交差

Thu, 20 Nov 2008 14:54:00 +0900

oct1-1.txtの実行結果を図にしてみた。

全部の丸はつながっているのだが、右上の赤とマゼンダで示した２つの矢印が重なっている。

ということで、重なりを禁止してみよう。

(predicate (nocross d e) .... )

という nocross というのを作ってみよう。 dおよびeは、それぞれ、対角線方向（＼）、逆対角線方向（／）の矢印を示す位置的に重なる矢印変数である。つまり、dにはdで始まる変数、eにはeで始まる変数が入る。

上の宣言ができているとして、どう使うかをまず考えてみよう。簡単だから、以下に並べておく。全部で９箇所重なる場所があり、それを禁止するために、以下の制約を加える。

(nocross d11 e21) (nocross d21 e31) (nocross d31 e41)
(nocross d12 e22) (nocross d22 e32) (nocross d32 e42)
(nocross d13 e23) (nocross d23 e33) (nocross d33 e43)

さて、 (nocross d e)　はどう書けばよいのだろうか。

矢印が交わるということは、dとeがともに矢印として同時に存在することだ。矢印の向きは関係ないので、言葉どおりに、２つの矢印が同時に存在してはいけないという書き方をすると次のようになる。

(predicate (nocross d e)
  (not (and (!= 0 d)
            (!= 0 e) )))

同じことだが、次のように書き直すこともできる。

(predicate (nocross d e)
  (or (= 0 d)
      (= 0 e) ))

プログラム： oct1-2.csp

実行結果： oct1-2.txt

さて、この結果はどうだろうか？

矢印が交差するのは消えた。めでたし、めでたし。

さて、次は何をちゃんとしようか？

プログラム不要の「制約プログラミング手習い」

少し大きな問題で実験

単一ループ

ループ表現戦略

ルール

完全虫食算

孤独の７

7つの7の問題

多倍長整数演算

sugarは虫食算には向かないかと思ったが、もしかして向いているかも。

とりあえず解いてみよう

年賀パズル2009

割り算

宿題

掛け算

足し算

問題 その１

問題 その２

とりあえずプログラミング

どこかな算とは

木構造

ルート

黒点では交差しない

より大きな問題

黒点は通過

交差

問題　その１

問題　その２