Firefox 1.5でいつのまにか日本語の均等割り付けができるようになってるのにきがついた。
むかしは苦労したものだ。http://k16journal.blogspot.com/2005/05/htmlcss2.html
むかしは苦労したものだ。http://k16journal.blogspot.com/2005/05/htmlcss2.html
\newcommand{\replacechar}[3]{{\wordbyword{#2}{#3}#1\end }}\replacecharの第1引数に文字列、第2引数に置換前の文字、第3引数に置換後の文字を指定する。
\newcommand{\cutoff}[2]{{\relax}}
\def\wordbyword#1#2#3{\ifx#3\end \let\next=\cutoff
\else\ifx#3#1#2%
\else#3%
\fi \let\next=\wordbyword\fi \next{#1}{#2}}
\newcommand{\indexescape}[1]{{\indexwordbyword#1\end }}\myindexの定義に\stringを使っているのも2番目の制限のため。
\def\indexwordbyword#1{\ifx#1\end \let\next=\relax
\else\ifx#1{!}"!%
\else\ifx#1{@}"@%
\else\ifx#1{|}"|%
\else#1%
\fi\fi\fi \let\next=\indexwordbyword\fi \next}
\def\myindex#1{\index{\string\indexescape{#1}}}
(define able-to-pay? #f)この挿話は、悪魔にとって選択肢が(A)と(B)しかありえないことがポイントなんだと思う。つまり、(B)じゃなければ(A)。(B)でもないし(A)でもないってことはありえないドライな世界。上のコードだと、最初のcondが契約書に相当するつもり。
(define remind-contract #f)
(define (devils-contract init-choice)
(let ((ability able-to-pay?))
((lambda (choice)
(cond ((equal? 'first-answer choice)
(display ""))
((and (equal? 'B choice) ability)
(display "Say any wish!"))
(else
(display "Devil gives you one billion dollars"))))
(call/cc
(lambda (continuation)
(cond ((equal? 'A init-choice)
(display "Devil chooses A"))
((equal? 'B init-choice)
(display "Devil chooses B")))
(set! remind-contract continuation)
(continuation 'first-answer))))))
gosh> (devils-contract 'B)
Devil chooses B
gosh> (set! able-to-pay? #t)
#t
gosh> (remind-contract 'B)
Devil gives you one billion dollars
gosh> (set! able-to-pay? #t)
#t
gosh> (devils-contract 'B)
Devil chooses B
gosh> (remind-contract 'B)
Say any wish!
A = {(1, 2) (2, 3) (3, 4) (4, 5) (5, 6) (6, 7)}集合Aからすべての項が異なる3つのベクトルを取り出す組み合わせは、
{(1, 2) (3, 4) (5, 6)},の4つになるだろう。この4つを求めるのに、すべての3要素の組み合わせを求めてから相異なる要素で構成されているものを取り出していると、集合が大きくなるにつれ厄介なことになるのが目に見えている。かといって、集合Aをあらかじめユニークな要素だけで再構成することもできない。
{(1, 2) (3, 4) (6, 7)},
{(1, 2) (4, 5) (6, 7)},
{(2, 3) (4, 5) (6, 7)}
(define (normal-combinations ls n)境界条件がなんか複雑で、本当にこれであってるのかよくわからないのはここだけの話。まあ、とりあえず意図通りの結果にはなるみたい。
(cond ((> n (length ls))
'())
((= n 1)
(map list ls))
((> n (+ 1 (length (cdr ls))))
(list ls))
(else
(append
(map (lambda (x) (cons (car ls) x))
(normal-combinations (cdr ls) (- n 1)))
(normal-combinations (cdr ls) n)))))
gosh> test-set枝刈りしながら組み合わせを求めるという本題を達成するには、枝刈りプロシージャ proc を渡して、1.の操作の cdr を proc に変えればいいだろう(2.の部分の cdr はリストの再帰的な操作のためのものなので、proc に変える必要はない)。
((1 2) (2 3) (3 4) (4 5) (5 6) (6 7))
gosh> (normal-combinations test-set 3)
((#0=(1 2) #1=(2 3) #2=(3 4)) (#0# #1# #3=(4 5)) (#0# #1# #4=(5 6))
(#0# #1# #5=(6 7)) (#0# #2# #3#) (#0# #2# #4#) (#0# #2# #5#)
(#0# #3# #4#) (#0# #3# #5#) (#0# #4# #5#) (#1# #2# #3#)
(#1# #2# #4#) (#1# #2# #5#) (#1# #3# #4#) (#1# #3# #5#)
(#1# #4# #5#) (#2# #3# #4#) (#2# #3# #5#) (#2# #4# #5#)
(#3# #4# #5#))
(define (trim-combinations ls n proc)枝刈りプロシージャとしては、ベクトルが相異なることを表現する distinct? と、リストとして表した集合から car と相異なる cdr を導く distinct-cdr 用意する。gauche の lset-union は、(use srfi-1) が必要だね。
(cond ((> n (length ls))
'())
((= n 1)
(map list ls))
((> (- n 1) (length (proc ls)))
(trim-combinations (cdr ls) n proc))
(else
(append
(map (lambda (x) (cons (car ls) x))
(trim-combinations (proc ls) (- n 1) proc))
(trim-combinations (cdr ls) n proc)))))
(define (distinct? v1 v2)実行結果。
(= (length (lset-union eq? v1 v2))
(+ (length v1) (length v2))))
(define (distinct-cdr ls)
(let R ((tail (cdr ls)))
(cond ((null? tail) '())
((not (distinct? (car ls) (car tail)))
(R (cdr tail)))
(else
(cons (car tail) (R (cdr tail)))))))
gosh> (trim-combinations test-set 3 distinct-cdr)しかしアレだな。lengthとか使いすぎなので、あまり効率よくないんじゃないか、これ。
((#0=(1 2) #1=(3 4) (5 6)) (#0# #1# #2=(6 7)) (#0# #3=(4 5) #2#) ((2 3) #3# #2#))
■H1■はじめにこれは下訳をお願いした業者さんがよく使っている形式(というか編集指示)を拡張したものだけど、多かれ少なかれどこも似たような「マークアップ」を使っているようだ。見てわかるように、あくまでも人間が手作業で組版するためのコメントみたいな指示書き程度しか施されていない。コンピュータでそのまま処理するにはちょっと厄介な状態といえる(しかも、バリデータなんてないから、けっこういいかげん)。
■H2■本書の読み方
本書は初めてRailsに触れる人うんぬん……
★Rubyのコード
本書にはRubyのコードがたくさん出てきます。
しかも予約語は太字に、ダブルクォーテーション内はスラントにしなくちゃなりません。
◆→コード←◆ruby
puts "Hello World"
◆→ここまでコード←◆
ちなみに★で始まってる部分は小さな見出しつきの項目になります。
ここは、また本文に戻ってます。
● 箇条書きもあります。
こんなふうに、なんとなく箇条書きな部分がタブで示されています。
● もうひとつ箇条書き
また本文。
◆→コラム←◆Joeの疑問
枠で囲った記事もあります。「David曰く」「Joeの疑問」のほかに、何も指示のないコラムもあります。
◆→ここまでコラム←◆
1. 箇条書きとは別に
2. 連番もあります
■H3■もっと細かい本書の読み方
脚注もつけなければ◆→訳注 ←◆
■H2■終わりに
おしまい。
\chapter{はじめに}%このLaTeXの出力から書籍にするには、さらに各要素についてスタイルを定義する必要がある。実はこの作業がいちばん大変なところなんだけど(LaTeXのいい加減な規則や拡張に起因)、これは会社の業務として作成したものなので今のところ公開できない。まあ、LaTeXの泥臭いところが満載なので、実際のところあまり面白くないし。
\section{本書の読み方}%
本書は初めてRailsに触れる人うんぬん……%
%
\begin{entry}%
\item[Rubyのコード]
\item 本書にはRubyのコードがたくさん出てきます。
\item しかも予約語は太字に、ダブルクォーテーション内はスラントにしなくちゃなりません。
\begin{ruby}
puts \codesl{"Hello World"}
\end{ruby}%
\item ちなみに★で始まってる部分は小さな見出しつきの項目になります。%
\end{entry}%
%
ここは、また本文に戻ってます。%
%
\begin{myitemize}%
\item 箇条書きもあります。%
こんなふうに、なんとなく箇条書きな部分がタブで示されています。
\item もうひとつ箇条書き%%
\end{myitemize}%
%
また本文。%
%
\begin{column}{J}{の疑問}
枠で囲った記事もあります。「David曰く」「Joeの疑問」のほかに、何も指示のないコラムもあります。
\end{column}%
%
\begin{enumerate}%
\item 箇条書きとは別に%
\item 連番もあります%%
\end{enumerate}%
%
\subsection{もっと細かい本書の読み方}%
脚注もつけなければ\footnote{\kern-.5zw[訳注]}%
%
\section{終わりに}%
おしまい。
(define (lookup subtree pred)
(let lookup-for-suns ((suns (cdr subtree)))
(cond ((null? suns) '())
((pred (caar suns)) (car suns))
(else
(lookup-for-suns (cdr suns))))))
(define (include? subtree pred)
(let check-for-suns ((suns (cdr subtree)))
(cond ((null? suns) #f)
((pred (caar suns)) #t)
(else
(check-for-suns (cdr suns))))))
(define (without-grandchild? tree)
(or (null? (cdr tree))
(let without-children? ((suns (cdr tree)))
(cond ((null? suns) #t)
((null? (cdr (car suns)))
(without-children? (cdr suns)))
(else #f)))))
(define (extract tree pred)
(cond ((null? tree) '())
((pred (caar tree))
(extract (cdr tree) pred))
(else
(cons (car tree)
(extract (cdr tree) pred)))))
(define (rankup tree pred)
(if (without-grandchild? tree)
tree
(cons (car tree)
(let rankup-for-suns ((suns (cdr tree)))
(cond ((null? suns) '())
((include? (car suns) pred)
(cons
(cons (caar suns)
(extract (cdar suns) pred))
(cons (lookup (car suns) pred)
(rankup-for-suns (cdr suns)))))
(else
(cons (rankup (car suns) pred)
(rankup-for-suns (cdr suns)))))))))
(define test-tree
(list 'A (list 'B (list 'F)
(list 'G (list 'L)
(list 'M)))
(list 'C (list 'H)
(list 'I (list 'N)
(list 'O (list 'P)
(list 'Q)))
(list 'J))
(list 'D)
(list 'E (list 'K))))
(define eq-I? (lambda (x) (eq? 'I x)))
gosh> test-tree
(A (B (F) (G (L) (M))) (C (H) (I (N) (O (P) (Q))) (J)) (D) (E (K)))
gosh> (rankup test-tree eq-I?)
(A (B (F) (G (L) (M))) (C (H) (J)) (I (N) (O (P) (Q))) (D) (E (K)))
x = sinθ
f(x) = (d/dθ) x
=>
f(x) = cosθ
f(f(x)) = -sinθ
= -x(!?)
(define (cdr-cycle? x)
(if (not (pair? (cdr x)))
#f
(let R ((x x) (y (cdr x)) (c 0))
(cond ((null? y) #f)
((eq? x y) #t)
((< 0 c) (R (cdr x) y (- c 1)))
(else (R x (cdr y) (+ c 1)))))))
gosh> x
(0 . #0=(1 2 . #0#))
gosh> (cdr-cycle? x)
#t
gosh> y
(0 0 . #0=(1 2 . #0#))
gosh> (cdr-cycle? y)
#t
gosh> z
((0 . #0=(1 2 . #0#)) . 4)
gosh> (cdr-cycle? z)
#f
;; ex. 3.19
(define (cycle? x)
(define (whole-cycle? sub)
(if (or (null? sub) (not (pair? sub)))
#f
(let R ((y (cdr sub)))
(cond ((null? y) #f)
((eq? sub y) #t)
(else (R (cdr y)))))))
(if (or (null? x) (not (pair? x)))
#f
(or (whole-cycle? (car x))
(whole-cycle? (cdr x)))))
gosh> x
(0 . #0=(1 2 . #0#))
gosh> (cycle? x)
#t
gosh> x
(0 . #0=(1 2 . #0#))
gosh> (define z (cons x 4))
((0 . #0=(1 2 . #0#)) . 4)
gosh> (cycle? z)
...
(define (cycle? x)
(define (whole-cycle? sub)
(if (or (null? sub) (not (pair? sub)))
#f
(let R ((y (cdr sub)))
(cond ((null? y) #f)
((eq? sub y) #t)
(else (R (cdr y)))))))
(if (or (null? x) (not (pair? x)))
#f
(or (cycle? (car x)) (whole-cycle? (car x))
(cycle? (cdr x)) (whole-cycle? (cdr x)))))
;; ex. 3.19
(define (cycle? x)
(if (null? (cdr x))
#f
(let R ((y (cdr x)))
(cond ((null? y) #f)
((eq? x y) #t)
(else (R (cdr y)))))))
gosh> x
#0=(a b c . #0#)
gosh> (cycle? x)
#t
(define (count-pairs x)
(if (not (pair? x))
0
(+ (count-pairs (car x))
(count-pairs (cdr x))
1)))
(define x (list 'a 'b 'c))
gosh> (count-pairs x)
3
gosh> (set-car! x (cdr x))
gosh> (count-pairs x)
5
x-->|*|*|-->|*|*|-->|*|/|
! ! !
|a| |b| |c|
________
| !
x-->|*|*|-->|*|*|-->|*|/|
! !
|b| |c|
;; ex. 3.17
(define (count-pairs x)
(define aux-pairs '())
(define (member-eq? c ls)
(cond ((or (null? ls) (null? (cdr ls)) (null? c)) #f)
((eq? c (car ls)) #t)
(else
(member-eq? c (cdr ls)))))
(define (aux-count x)
(cond ((not (pair? x))
'())
((member-eq? x aux-pairs)
'())
(else
(set! aux-pairs (cons x aux-pairs))
(append (aux-count (car x))
(aux-count (cdr x))))))
(aux-count x)
(length aux-pairs))
gosh> (count-pairs x)
3
;; aa-graf.scm
(define (aa-graf RFC)
(let ((aas (aas RFC))
(alts (altitudes RFC)))
(let draw ((alt (apply max alts)))
(graf-at alt alts aas)
(if (> alt (apply min alts))
(draw (- alt 1))))))
(define (graf-at alt alts aas)
(print (list->string
(map (lambda (x y)
(if (eq? x alt)
y
#\space))
alts aas))))
(define (aas RFC)
(map (lambda (x)
(cond ((eq? x #\R) #\/)
((eq? x #\F) #\\)
((eq? x #\C) #\_)))
(string->list RFC)))
(define (altitudes RFC)
(map (lambda (pair)
(min (car pair) (cdr pair)))
(let R
((s 0)
(ls (map (lambda (x)
(cond ((eq? x #\R) 1)
((eq? x #\F) -1)
((eq? x #\C) 0)))
(string->list RFC))))
(if (null? ls)
'()
(cons (cons s (+ s (car ls)))
(R (+ s (car ls)) (cdr ls)))))))
gosh> (aa-graf "RCRFCRFFCCRFFRRCRRCCFRFRFF")
__
/ \/\/\
_/\_/\ _/ / \__/\ /
\/
;; ex. 2.97
(define ex-2-97-p1 (make-poly-with-dence 'x '(1 1)))
(define ex-2-97-p2 (make-poly-with-dence 'x '(-1 0 0 1)))
(define ex-2-97-p3 (make-poly-with-dence 'x '(0 1)))
(define ex-2-97-p4 (make-poly-with-dence 'x '(-1 0 1)))
(define ex-2-97-rp1 (make-rational-number ex-2-97-p1 ex-2-97-p2))
(define ex-2-97-rp2 (make-rational-number ex-2-97-p3 ex-2-97-p4))
gosh> (print ex-2-97-rp1)
(x + x^0)/(x^3 + -x^0)
gosh> (print ex-2-97-rp2)
(x)/(x^2 + -x^0)
gosh> (print (add ex-2-97-rp1 ex-2-97-rp2))
(-x^3 + -2x^2 + -3x + -x^0)/(-x^4 + -x^3 + x + x^0)
19×19 = (20 - 1)2
= 202 - 2×20×1 + 12
(a - b)2 = a2 - 2ab + b2
[1kpathsea: Running mktexpk --mfmode ……みたいなエラーメッセージが出るはず。
f hiraginox.mapなどと書く。hiraginox.mapのところは、使用するOpenTypeフォントに合わせて、kozukax.mapやmorisawax.mapを指定する。
\usepackage{type1cm}
\usepackage[T1]{fontenc}
\usepackage[scaled]{helvet}
\usepackage[deluxe]{otf}
\renewcommand{\rmdefault}{ppl}
\renewcommand{\sfdefault}{phv}
\renewcommand{\ttdefault}{pcr}
((a 1) (b 2) (a 3) (c 1) (d 0) (a 4) (c 5) (b 6))
↓
((a 8) (b 8) (c 6) (d 0))
(define (M-filter equ? proc ls)うまくないなあ。つーか、このex.2.92の時点で set! を使うのは、問題の回答としていけないような気もする。でも、"The Seasoned Schemer" の 16th Commmandment(set!はletで束縛している名前にだけは使ってもいい)は破ってないので、よしとすることにしよう。ちっとも先に進まないし。
(let ((L (merge-if-equ-with-car equ? proc ls)))
(if (null? (cdr L))
(merge-if-equ-with-car equ? proc L)
(cons (car L)
(M-filter equ? proc (cdr L))))))
(define (merge-if-equ-with-car equ? proc ls)
(letrec
((head (car ls))
(foot
(let M ((a (car ls))
(rest (cdr ls)))
(cond ((null? rest)
'())
((equ? a (car rest))
(let ((a (proc a (car rest))))
(set! head a)
(M a (cdr rest))))
(else
(cons (car rest)
(M a (cdr rest))))))))
(cons head foot)))
(M-filter (lambda (a b) (equal? (car a) (car b)))
(lambda (a b) (list (car a) (+ (cadr a) (cadr b))))
'((x 1) (xy 2) (x 3) (y 4) (z 5) (y 6) (xy 5)))
=>((x 4) (xy 7) (y 10) (z 5))
(a b c d e f g h i j)というリストがあって、その部分集合、たとえば
(f c a c)を、もとの親玉のリストと同じ順番
(a c f)にしたいというはなし。
(define (be-same-order ls1 ls2)
(if (or (null? ls1) (null? ls2))
'()
(let C ((ls ls1)
(passed '()))
(cond ((null? ls)
(be-same-order ls1 (cdr ls2)))
((equal? (car ls) (car ls2))
(cons (car ls)
(be-same-order (append passed (cdr ls)) (cdr ls2))))
(else
(C (cdr ls) (cons (car ls) passed)))))))
Expr = Term { (+|-) Term }
Term = Fact { (*|/) Fact }
Fact = ( Expr ) | number
↓
Expr = Term { (+|-) Expr }
Term = Fact { (*|/) Expr }
Fact = ( Expr ) | number
;; 10minutes-parser.scm
;; 2006/2/1
;; k16.shikano
;; inspired from http://fxp.hp.infoseek.co.jp/arti/parser.html
; Expr = Term { (+|-) Expr }
; Term = Fact { (*|/) Expr }
; Fact = Expr | number
(define left car)
(define op cadr)
(define right caddr)
(define-syntax or-match
(syntax-rules ()
((_ e0 e1 e2 ...)
(call-with-values
(lambda ()
(let R ((ls e0))
(cond ((null? ls)
(values '() '() '()))
((or (char=? (car ls) e1)
(char=? (car ls) e2)
...)
(values '() (car ls) (cdr ls)))
(else
(call-with-values
(lambda () (R (cdr ls)))
(lambda (l o r) (values (cons (car ls) l) o r)))))))
list))))
(define (expr ls)
(let ((parsed (or-match ls #\+ #\-)))
(let ((l (left parsed))
(r (right parsed))
(o (op parsed)))
(cond ((null? o)
(term l))
((char=? o #\+)
(+ (term l) (expr r)))
((char=? o #\-)
(- (term l) (expr r)))
(else
(error "unrecognize expr"))))))
(define (term ls)
(let ((parsed (or-match ls #\* #\/)))
(let ((l (left parsed))
(r (right parsed))
(o (op parsed)))
(cond ((null? o)
(fact l))
((char=? o #\*)
(* (fact l) (expr r)))
((char=? o #\/)
(/ (fact l) (expr r)))
(else
(error "unrecognize term"))))))
(define (fact ls)
(define (list->integer ls)
(let F ((ls ls) (added 0))
(let ((car-int (digit->integer (car ls))))
(if (null? (cdr ls))
(+ car-int added)
(F (cdr ls) (* (+ car-int added) 10))))))
(if (not (char-numeric? (car ls)))
(error "unrecognize fact")
(list->integer ls)))
gosh> (expr (string->list "1+3*2"))
7
(define delimiter "%%%")
(define (set-delimiter str)
(string-append
delimiter
(string-join (map x->string (string->list str)) delimiter)
delimiter))
(define (erace-delimiter str)
(regexp-replace-all (string->regexp delimiter) str ""))
(define (regexp-replace-delimiter-all* str . args)
(if (eq? (remainder (length args) 2) 1)
(error
"Need even args -- REGEXP-MATCH-REPLACE*"
args)
(if (null? args)
(erace-delimiter str)
(apply regexp-replace-delimiter-all*
(append
(list (regexp-replace-all
(car args)
str
(cadr args)))
(cddr args))))))
(regexp-replace-delimiter-all* "foobarbaz..."
#/foo(.*?)baz/
(lambda (m) (set-delimiter
(string-append
"|"
(rxmatch-substring m 1)
"|"
)))
#/bar/
(lambda (m) (set-delimiter "..."))
)
=> "|bar|..."
(regexp-replace-all* "foobarbaz..."
#/foo(.*?)baz/
(lambda (m) (string-append
"|"
(rxmatch-substring m 1)
"|"
))
#/bar/
(lambda (m) "...")
)
=> "|...|..."
(define (regexp-replace-delimiter-all* str . args)
(define delimiter "%%%")
(define (set-delimiter str)
(string-append
delimiter
(string-join (map x->string (string->list str)) delimiter)
delimiter))
(define (erace-delimiter str)
(regexp-replace-all (string->regexp delimiter) str ""))
(if (eq? (remainder (length args) 2) 1)
(error
"Need even args -- REGEXP-MATCH-REPLACE*"
args)
(if (null? args)
(erace-delimiter str)
(apply regexp-replace-delimiter-all*
(append
(list (regexp-replace-all
(car args)
str
(set-delimiter (cadr args))))
(cddr args))))))
gosh> (regexp-replace-delimiter-all* "abcde" #/a.*?c/ "xx" #/xd/ "zz")
=>"xxde"
(define (numbering file)
(with-input-from-file file
(lambda ()
(letrec
((Ns (lambda (ctrs)
(let ((line (read-line)))
(cond
((eof-object? line)
'())
((leveled? line)
(let ((ctr-lv (length ctrs))
(lin-lv (level-of line)))
(cond
((< ctr-lv lin-lv)
(let ((ctrs (deeper ctrs)))
(cons (put-head line ctrs)
(Ns ctrs))))
((> ctr-lv lin-lv)
(let ((ctrs (add1 (chop ctrs lin-lv))))
(cons (put-head line ctrs)
(Ns ctrs))))
((equal? ctr-lv lin-lv)
(let ((ctrs (add1 ctrs)))
(cons (put-head line ctrs)
(Ns ctrs)))))))
(else (cons line
(Ns ctrs))))))))
(Ns '())))))
(define-syntax tag-case
(syntax-rules (else)
((_ e0 (else e2 e3 ...)) (begin e2 e3 ...))
((_ e0 (e1 e2 e3 ...)) (if (equal? e0 e1) (begin e2 e3 ...)))
((_ e0 (e1 e2 e3 ...) c1 c2 ...)
(if (equal? e0 e1) (begin e2 e3 ...) (tag-case e0 c1 c2 ...)))))
(define (tagged-line-filter tagged-line)
(let ((tag (car tagged-line))
(str (cadr tagged-line)))
(tag-case tag
('column (column-filter str))
('verbatim (verbatim-filter str))
('table (table-filter str))
('numbered (numbered-filter str))
('itemized (itemized-filter str))
('enumerate (enumerate-filter str))
(else (default-filter str)))))
(define dice6
(make-probability-space
(list 1 2 3 4 5 6)
(lambda (w) (/ 1 6))))
dice6
=>
((1 . 0.16666666666666666) (2 . 0.16666666666666666) (3 . 0.16666666666666666)
(4 . 0.16666666666666666) (5 . 0.16666666666666666) (6 . 0.16666666666666666))
(define (even-pv w)
(if (even? w) 1 0))
((lead-distribution even-pv) dice6)
=> ((0 . 0.5) (1 . 0.5))
(variance dice6)
=> 2.9166666666666665
(variance ((lead-distribution even-pv) dice6))
=> 0.25
hisashim:mapcan おもしろいよな
shikano:破壊的ですよ
hisashim:いいんだよ、zip のフラットなのができるから
(compose (curry #'apply #'nconc) #'mapcar)
(define (my-mapcan fn . ls)
(apply append (apply map fn ls)))
##
#
##
#
#
## ## # # ### ###
# # # ## # # ## #
## ## # #
# # ## ##
# # # ## # # ## #
# # ## ## ### ###
(define (distinct? sets)
(= (length (apply lset-union = sets))
(* (length sets) (length (car sets)))))
(define (get-distinct-n set n)
(combinations-for-each
(lambda (s)
(if (distinct? s)
(begin (display s) (newline))))
set
n))
(get-distict-n valid-list 9)
(define (deep-rember item list)こんなふうな結果が得られる(昨日の定義では、末尾の3が残ってしまう)。
(cond ((null? list) '())
((not (pair? (car list)))
(if (equal? item (car list))
(cdr list)
(cons (car list) (deep-rember item (cdr list)))))
(else
(if (equal? item (caar list))
(append (cdar list) (cdr list))
(if (not (pair? (caar list)))
(cons (caar list) (deep-rember item (cons (cdar list) (cdr list))))
(deep-rember item
(append (caar list) (cdar list) (cdr list))))))))
gosh> (deep-rember 3 '(2 (1 4 ((((6))))) (3)))リスト同士を繋ぐときに append を使っているのは、deep-rember の結果として得られるリストにできるだけ nil を残さないため。nil があると、昨日定義した deep-equal? で、null? を終端条件に使えない。
(2 1 4 6 ())
(define (deep-equal? list1 list2)
(cond ((and (null? list1) (null? list2)) #t)
((equal? (deep-car list1) (deep-car list2))
(deep-equal? (deep-rember (deep-car list1) list1)
(deep-rember (deep-car list2) list2)))
(else #f)))
(define (deep-car list)
(cond ((null? list) '())
((not (pair? (car list))) (car list))
((null? (car list)) (deep-car (cdr list)))
(else (deep-car (car list)))))(define (deep-rember item list)
(cond ((null? list) '())
((not (pair? (car list)))
(if (equal? item (car list))
(cdr list)
(cons (car list) (deep-rember item (cdr list)))))
((null? (car list))
(list (car list) (deep-rember item (cdr list))))
(else
(if (equal? (deep-rember item (car list)) (car list))
(append (car list) (deep-rember item (cdr list)))
(append (deep-rember item (car list)) (cdr list))))))
dump -0f - /dev/hdb1 | restore xf -
install-mbr /dev/hda1