このディレクトリの索引

http://pc12.2ch.net/test/read.cgi/tech/1247438792/291 
# [1] 授業単元:コンピュータリテラシー 
# [2] 問題文(含コード&リンク):問題文と参考は以下です 
#   http://kansai2channeler.hp.infoseek.co.jp/cgi-bin/joyful/img/9806.txt 
# ・試験の過程を記録 
# 1,番号、得点を入力したあと平均点を計算 
# 2,番号順と得点順に並べ替え(ifを使いどちらか選択できるようにする) 
# 3,番号、得点、平均との差を出力 
# 以上のプログラムを作成 

成績を記録する :-
    write('番号と得点をスペースで区切って一行で入力してください\n'),
    get_line(_行),
    成績を記録する(_行).

成績を記録する(end_of_file) :- !.
成績を記録する(_行) :-
    split(_行,[' '],[_番号,_得点]),
    assertz(成績(_番号,_得点)),
    get_line(_次の行),
    成績を記録する(_次の行).
    
平均点(_平均点) :- findavg(_得点,成績(_,_得点),_平均点).

番号順に並べ直し(_番号順成績ならび) :-
    findall([_番号,_得点],成績(_番号,_得点),_成績ならび),
    quicksort(_成績ならび,_番号順成績ならび).

得点順に並べ直し(_得点順成績ならび) :-
    findall([_得点,番号],成績(_番号,_得点),_得点・番号成績ならび),
    quicksort(_得点・番号成績ならび,_整列した得点・番号ならび),
    項目位置を元に戻す(_整列した得点・番号ならび,_得点順成績ならび).

項目位置を元に戻す([],[]).
項目位置を元に戻す([[A,B]|R1],[[B,A]|R2]) :- 項目位置を元に戻す(R1,R2).

番号、得点、平均との差の出力 :-
    平均点(_平均点),
    write('番号 得点 平均との差\n'),
    成績(_番号,_得点),
    _平均との差 is _得点 - _平均点,
    write_formatted('%t  %t  %t\n',[_番号,_得点,_平均との差]),
    fail.
番号、得点、平均との差の出力.

quicksort([],[]) :- !.
quicksort([X|Xs],Ys) :-
    partition(Xs,X,Littles,Gigs),
    quicksort(Littles,Ls),
    quicksort(Bigs,Bs),
    append(Ls,[X|Bs],Ys).

partition([],Y,[],[]) :- !.
partition([X|Xs],Y,[X|Ls],Bs) :- X @=< Y,partition(Xs,Y,Ls,Bs).
partition([X|Xs],Y,Ls,[X|Bs]) :- X @> Y,partition(Xs,Y,Ls,Bs).

%%%%%%%% findavg/3 加算/2 他 %%%%%%%%%%%%%%%%%%%%
:- op(A,B,は).

findavg(_集約項,_項,_算術平均) :-
    findall(_集約項,_項,_値ならび),
    '加算'(_値ならび,_合計値),
    length(_値ならび,_ならびの長さ),
    _算術平均 is _合計値 / _ならびの長さ,!.

加算(trunc(L),SL) :-
    加算(L,SL2),
    findall(A,(member(B,SL2) , A is trunc(B)),SL),!.
加算(四捨五入(L),SL) :-
    加算(L,SL2),
    findall(A,(member(B,SL2) , A は 四捨五入(B)),SL),!.
加算(切捨て(L),SL) :-
    加算(L,SL2),
    findall(A,(member(B,SL2) , A は 切捨て(B)),SL),!.
加算(切り上げ(L),SL) :-
    加算(L,SL2),
    findall(A,(member(B,SL2) , A は 切り上げ(B)),SL),!.
加算([],L) :-
    var(L),
    L = 0.0e+00,!.
加算([],L) :-
    \+(var(L)),
    加算の変数に零をおく(L),!.
加算([L|R],SL) :-
    ならび(L),
    行列の転置([L|R],L1),
    加算_2(L1,SL),!.
加算(X,S) :-
    加算_1(X,0.0e+00,S) .

加算_1([],S,S) :- !.
加算_1([A|R],Y,S) :-
    ならび(A),
    ならび(Y),
    !,
    ならび加算(A,Y,Z),
    加算_1(R,Z,S),!.
加算_1([A|R],Y,S) :-
    atom(A),
    atom_number(A,I),
    integer(I),
    Z is I + Y,
    加算_1(R,Z,S),!.
加算_1([A|R],Y,S) :-
    atom(A),
    atom_number(A,F),
    real(F),
    Z is F + Y,
    加算_1(R,Z,S),!.
加算_1([A|R],Y,S) :-
    atom(A),
    加算_1(R,Y,S),!.
加算_1([A|R],Y,S) :-
    A1 は A,
    Z is A1 + Y,
    加算_1(R,Z,S).
加算_1(A,Y,S) :-
    とからりすと(A,L),
    !,
    加算_1(L,Y,S) .

加算_2([],[]) :- !.
加算_2([L|R],[S|R2]) :-
    加算(L,S),
    加算_2(R,R2).

加算の変数に零をおく([]) :- !.
加算の変数に零をおく([A|R]) :-
    変数(A),
    A = 0.0e+00,
    加算の変数に零をおく(R),!.

とからりすと(A,[A]) :-
    atomic(A),!.
とからりすと(A と B,C) :-
    とからりすと(A,A1),
    とからりすと(B,B1),
    append(A1,B1,C).

変数(_変数) :- var(_変数).

ならび([_|_]).


_項 は (_ネットワーク :: _式) :-
    _ネットワーク :: _項 は _式,
    ! .
_評価項 は N : L :-
    M は N,
    L1 は L,
    list_nth(M,L1,_評価項),
    ! .
_評価項 は prolog(_評価項) :-
    functor(_評価項,F,Arg),
    \+(predicate_type(F,Arg,undefined)),
    !,
    error_protect(_評価項,fail) .
_評価値 は [X|{P}] :-
    findall(X,P,_評価値),
    ! .
_評価項 は ` _値 :-
    !,
    _評価項 = _値,
    ! .
_項 は _式 :-
    var(_式),
    _項 = _式,
    ! .
_項 は _式 :-
    error_protect(一時関数定義(_式,_項),fail) .
_項 は _式 :-
    atom(_式),
    member(_式,[minint,maxint,cputtime,time,csize,cused,dbsize,dbused,gsize,gused,noptrs,ptrsued,ssize,sused,tsize,tused]),
    !,
    _項 is _式,
    ! .
_項 は _式 :-
    二項組込み関数(_式),
    二項組込み関数の評価(_式,_項) .
_項 は _式 :-
    二項組込み関数(_式),
    !,
    fail .
_項 は _式 :-
    functor(_式,Functor,1),
    arg(1,_式,Arg),
    Y は Arg,
    functor(_式_1,Functor,1),
    arg(1,_式_1,Y),
    member(Functor,[atom,real,integer,var,float,list]),
    !,
    error_protect(_式_1,fail),
    _項 = Y,
    ! .
_項 は _式 :-
    atom(_式),
    error_protect(get_global(_式,_項),fail),
    ! .
_項 は _式 :-
    real(_式),
    _項 = _式,
    ! .
_項 は _式 :-
    real(_式),
    !,
    fail .
_項 は _式 :-
    list(_式),
    findall(X,(member(U,_式) , X は U),_項) .
_項 は _式 :-
    list(_式),
    !,
    fail.
_項 は _erlang_module : _erlang関数 :-
    erlang関数評価(_erlang_module : _erlang関数,_項),!.
_項 は _式 :-
    関数定義(_式,_項),!.
_項 は _式 :-
    functor(_式,_関数,_次数),
    function(_関数,_次数),
    findall(Arg,(for(1,N,_次数) , arg(N,_式,Arg)),L),
    関数評価に於いて引数部分の関数評価(L,L2),
    _式の二 =.. [_関数|L2],
    error_protect(_項 is _式の二,fail) .
_項 は _評価関数 :-
    error_protect(_項 is _評価関数,fail),!.
_評価項 は prolog(_評価項) :-
    functor(_評価項,F,Arg),
    \+(predicate_type(F,Arg,undefined)),
    !,
    error_protect(_評価項,fail),!.
_項 は _評価項 :-
    述語評価が可能(_評価項,_関数,_次数,_次数足す一),
    _評価項 =.. _評価項の項分解ならび,
    findall(Arg,(for(1,N,_次数) , arg(N,_評価項,Arg)),L),
    関数評価に於いて引数部分の関数評価(L,L2),
    append(L2,[_],_変数を付加した引数ならび),
    _解付き評価項 =.. [_関数|_変数を付加した引数ならび],
    error_protect(_解付き評価項,fail),
    arg(_次数足す一,_解付き評価項,_項) .
_項 は _評価項 :-
    \+(述語評価が可能(_評価項,_関数,_次数,_次数足す一)),
    functor(_評価項,F,Arg),
    \+(predicate_type(F,Arg,undefined)),
    error_protect(_評価項,fail),
    arg(Arg,_評価項,_項) .
_項 は _評価項 :-
    \+(述語評価が可能(_評価項,_関数,_次数,_次数足す一)),
    functor(_評価項,F,Arg),
    \+(predicate_type(F,Arg,undefined)),
    \+(error_protect(_評価項,fail)),
    _評価項 = _項,!.
_項 は _式 :-
    atomic(_式),
    \+(述語評価が可能(_式,_関数,_次数,_次数足す一)),
    _項 = _式,!.

述語評価が可能(_評価項,_関数,_次数,_次数足す一) :-
    functor(_評価項,_関数,_次数),
    _次数足す一 is _次数 + 1,
    \+(predicate_type(_関数,_次数足す一,undefined)),!.

関数評価に於いて引数部分の関数評価([],[]).
関数評価に於いて引数部分の関数評価([L|R1],[L2|R2]) :-
    list(L),
    !,
    関数評価に於いて引数部分の関数評価(L,L2),
    関数評価に於いて引数部分の関数評価(R1,R2),
    ! .
関数評価に於いて引数部分の関数評価([F|R1],[F|R2]) :-
    \+(error_protect(F2 は F,fail)),
    !,
    関数評価に於いて引数部分の関数評価(R1,R2) .
関数評価に於いて引数部分の関数評価([F|R1],[F2|R2]) :-
    error_protect(F2 は F,fail),
    関数評価に於いて引数部分の関数評価(R1,R2) .

erlang関数評価(os : cmd(Command),_項) :-
    erlang :: (os : cmd(Command) -> _項_1),
    _項 は string2atom(_項_1),!.
erlang関数評価(_erlang_module : _erlang関数,_項) :-
    erlang :: (_erlang_module : _erlang関数 -> _項),!.

関数定義(_項の一 + _項の二,_値) :-
    _値の一 は _項の一,
    number(_値の一),
    _値の二 は _項の二,
    number(_値の二),
    _値 is _値の一 + _値の二,
    !.
関数定義(_項の一 + _項の二,_値) :-
    _値の一 は _項の一,
    atomic(_値の一),
    _値の二 は _項の二,
    atomic(_値の二),
    concat_atom([_値の一,_値の二],_値),
    !.
関数定義(_ならびの一 + _ならびの二,_値) :-
    (
        変数(_ならびの一)
    ;
        _ならびの一 == []
    ;
        list(_ならびの一)
    ;
        変数(_ならびの二)
    ;
        _ならびの二 == []
    ;
        list(_ならびの二)
    ),
    !,
    append(_ならびの一,_ならびの二,_値) .
関数定義(_項の一 * _項の二,_値) :-
    _値の一 は _項の一,
    list(_値の一),
    _値の二 は _項の二,
    integer(_値の二),
    findall(_値の一,for(1,_,_値の二),LY),
    concat_list(LY,_値),
    !.
関数定義(_項の一 * _項の二,_値) :-
    _値の一 は _項の一,
    atom(_値の一),
    _値の二 は _項の二,
    integer(_値の二),
    findall(_値の一,for(1,_,_値の二),L),
    concat_atom(L,_値),
    !.
関数定義(_項の一 * _項の二,_値) :-
    _値の一 は _項の一,
    atomic(_値の一),
    _値の二 は _項の二,
    atomic(_値の二),
    concat_atom([_値の一,_値の二],_値),
    !.
関数定義(_ならびの一 * _ならびの二,_値) :-
    (
        変数(_ならびの一)
    ;
        _ならびの一 == []
    ;
        list(_ならびの一)
    ;
        変数(_ならびの二)
    ;
        _ならびの二 == []
    ;
        list(_ならびの二)
    ),
    !,
    append(_ならびの一,_ならびの二,_値) .
関数定義(` _値,_値) :-
    !.
関数定義(@ _式,_値) :-
    _値 は _式,!.
関数定義(四捨五入(_値),_四捨五入後の値) :-
    _値の二 は _値,
    _値の二 >= 0.0e+00,
    _四捨五入後の値 is floor(_値の二 + 0.5) * 1.0,!.
関数定義(四捨五入(_値),_四捨五入後の値) :-
    _値の二 は _値,
    _四捨五入後の値 is ceil(_値の二 - 0.5),!.
関数定義(切り捨て(_値),_切り捨て後の値) :-
    _値の二 は _値,
    _切り捨て後の値 は floor(_値の二) * 1.0,!.
関数定義(切り上げ(_値),_切り上げ後の値) :-
    _値の二 は _値,
    _切り上げ後の値 は ceil(_値の二),!.
関数定義(十円未満四捨五入(_値),_四捨五入後の値) :-
    _値の二 は _値,
    _四捨五入後の値 は floor(_値の二 / 10 + 0.5) * 10,!.
関数定義(十円未満切り捨て(_値),_切り捨て後の値) :-
    _値の二 は _値,
    _切り捨て後の値 は trunc(_値の二 / 10) * 10,!.
関数定義(十円未満切り上げ(_値),_切り上げ後の値) :-
    _値の二 は _値,
    _切り上げ後の値 は ceil(_値の二 / 10) * 10,!.
関数定義(百円未満四捨五入(_値),_四捨五入後の値) :-
    _値の二 は _値,
    _四捨五入後の値 は floor(_値の二 / 100 + 0.5) * 100,!.
関数定義(百円未満切り上げ(_値),_切り上げ後の値) :-
    _値の二 は _値,
    _切り上げ後の値 は ceil(_値の二 / 100) * 100,!.
関数定義(百円未満切り捨て(_値),_切り捨て後の値) :-
    _値の二 は _値,
    _切り捨て後の値 は floor(_値の二 / 100) * 100,!.
関数定義(整数化(_値),_整数化された値) :-
    _値の二 は _値,
    _整数化された値 is trunc(_値の二),!.
関数定義(char_code(_項),_値) :-
    (
        atom(_項),
        atomic_length(_項,1),
        char_code(_項,_値)
    ;
        integer(_項),
        char_code(_値,_項)
    ;
        複合項(_項),
        _項の一 は _項,
        _値 は char_code(_項の一)
    ),
    !.
関数定義($ _大域変数名,_値) :-
    atom(_大域変数名),
    get_global(_大域変数名,_値の一),
    _値 は _値の一,!.
関数定義(S,E) :-
    functor(S,select,1),
    to(S,E),!.
関数定義(setq(A,B),E) :-
    atom(A),
    B1 は B,
    set_global(A,B1),
    E = B1,!.
関数定義(++ A,X) :-
    A1 は A,
    list(A1),
    加算(A1,X),!.
関数定義(A ++ B,X) :-
    C is B / A,
    X = A + C + B,!.
関数定義(car(A),E) :-
    A1 は A,
    A1 = [E|_],!.
関数定義(cdr(A),E) :-
    A1 は A,
    A1 = [_|E],!.
関数定義(cons(A,B),E) :-
    A1 は A,
    B1 は B,
    E = [A1|B1],!.
関数定義(length(A),E) :-
    A1 は A,
    list(A1),
    length(A1,E),!.
関数定義(decode(A,B,C,D),E) :-
    A1 は A,
    B1 は B,
    A1 = B1,
    E は C,!.
関数定義(decode(A,B,C,D),E) :-
    E は D,!.
関数定義(decompcons(A),E) :-
    A1 は A,
    decompcons(A1,E),!.
関数定義(substr(A,B,C),E) :-
    関数定義(subatomic(A,B,C),E),!.
関数定義(subatomic(A,B,C),E) :-
    A1 は A,
    B1 は B,
    C1 は C,
    subatomic(A1,B1,C1,E),!.
関数定義(concat(A),E) :-
    A1 は A,
    concat(A1,E),!.
関数定義(concat(A,B),E) :-
    A1 は A,
    B1 は B,
    concat(A1,B1,E),!.
関数定義(append(A,B),E) :-
    A1 は A,
    B1 は B,
    append(A1,B1,E),!.
関数定義(reverse(A),E) :-
    A1 は A,
    reverse(A1,E),!.
関数定義(string2atom(A),E) :-
    A2 は A,
    flat(A2,B),
    atom_codes(E,B),!.
関数定義(P,E) :-
    functor(P,greatest,Arg),
    P =.. [greatest|L],
    findall(B,(member(A,L) , B は A),L2),
    max(L2,E),!.
関数定義(P,E) :-
    functor(P,least,Arg),
    P =.. [least|L],
    findall(B,(member(A,L) , B は A),L2),
    min(L2,E),!.
関数定義(cel(_列数,_行数,_行列),_解) :-
    _関数評価された行数 は _行数,
    _関数評価された列数 は _列数,
    list_nth(_関数評価された行数,_行列,_行),
    list_nth(_関数評価された列数,_行,_解),!.