necesito un programa en prolog que convierta un numero decimal en binario!!!!!

beckyta bonita
02 de Mayo del 2006
Para correrlo por ejemplo:
1?decBin(13,D).
D=[1,1,0,1]

invitado
02 de Mayo del 2006
domains
lenteros=integer*

predicates
nondeterm eselemento(integer,lenteros)
loncatenar(lenteros,lenteros,lenteros)
invertir(lenteros,lenteros)
eliminar_uno(integer,lenteros,lenteros)
union(lenteros,lenteros,lenteros)
diferencia(lenteros,lenteros,lenteros)
interseccion(lenteros,lenteros,lenteros)
sucesor(lenteros,lenteros)
sumar_uno(lenteros,lenteros)
predecesor(lenteros,lenteros)
restar_uno(lenteros,lenteros)
max_lista(lenteros,integer)
mayor(integer,integer,integer)
ordenar(lenteros,lenteros)
primo(integer)
divisible(integer,integer)
lista_impares(lenteros,lenteros)
a_binario(integer,lenteros)
longitud(lenteros,integer)
nondeterm a_completarLista(lenteros,lenteros)
nondeterm intercambioBits(lenteros,lenteros)
nondeterm a_binario8(integer,lenteros)
nondeterm producto_listas(lenteros,lenteros,integer)
nondeterm a_decimal(integer,integer)
clauses
eselemento(X,[X|_]):-!.
eselemento(X,[Y|Ys]):-X<>Y,eselemento(X,Ys).

loncatenar([],Ys,Ys):-!.
loncatenar([X|Xs],Ys,[X|Zs]):-loncatenar(Xs,Ys,Zs).

invertir([],[]):-!.
invertir([X|Xs],Ys):-invertir(Xs,A), loncatenar(A,[X],Ys).

eliminar_uno(_,[],[]):-!.
eliminar_uno(X,[X|Xs],Xs):-!.
eliminar_uno(X,[Y|Ys],[Y|L]):-eliminar_uno(X,Ys,L).

union([],Ys,Ys):-!.
union([X|Xs],Ys,[X|Zs]):- not(eselemento(X,Ys)), union(Xs,Ys,Zs),!.
union([_|Xs],Ys,Zs):- union(Xs,Ys,Zs).

interseccion([],_,[]):-!.
interseccion([X|Xs],Ys,[X|Zs]):- eselemento(X,Ys), interseccion(Xs,Ys,Zs),!.
interseccion([_|Xs],Ys,Zs):- interseccion(Xs,Ys,Zs).

diferencia([],_,[]):-!.
diferencia([X|Xs],Ys,[X|Zs]):- not(eselemento(X,Ys)), diferencia(Xs,Ys,Zs),!.
diferencia([_|Xs],Ys,Zs):- diferencia(Xs,Ys,Zs).

sumar_uno([],[1]):-!.
sumar_uno([X|Xs],[Y|Xs]):- X<9, Y=X+1,!.
sumar_uno([_|Xs],[0|Ys]):- sumar_uno(Xs,Ys).
sucesor(L,LR):- invertir(L,LAux), sumar_uno(LAux,LRAux), invertir(LRAux,LR).

restar_uno([],[]):-!.
restar_uno([X|Xs],[Y|Xs]):- X>0, Y=X-1,!.
restar_uno([_|Xs],[9|Zs]):- restar_uno(Xs,Zs).
predecesor(L,LR):- invertir(L,LAux), restar_uno(LAux,LRAux), invertir(LRAux,LR).

max_lista([X],X):-!.
max_lista([X|Xs],Max):-max_lista(Xs,R), mayor(X,R,Max).
mayor(X,Y,X):-X>Y,!.
mayor(_,Y,Y):-!.

ordenar([],[]):-!.
ordenar(Xs,Lo):-max_lista(Xs,M), eliminar_uno(M,Xs,Ys), ordenar(Ys,LAux), loncatenar([M],LAux,Lo).

divisible(_,1):-!.
divisible(N,D):-N mod D <>0, D1=D-1, divisible(N,D1).

primo(1):-!.
primo(N):-D=N-1,divisible(N,D).

lista_impares([],[]):-!.
lista_impares([X],[X]):-!.
lista_impares([X,_|Xs],[X|Zs]):-lista_impares(Xs,Zs).


a_binario(N,[N]):-N<2,!.
a_binario(N,L):- D=N mod 2, N1=N div 2, a_binario(N1,LAux), loncatenar(LAux,[D],L).

longitud([],0):-!.
longitud([_|Xs],L):-longitud(Xs,L1),L=L1+1.

intercambioBits([X|Xs],[0|Ys]):- X=1,intercambioBits(Xs,Ys),!.
intercambioBits([_|Xs],[1|Ys]):- intercambioBits(Xs,Ys).
intercambioBits([],[]):-!.

a_completarLista(L,Lr):- longitud(L,T), T<8, loncatenar([0],L,W), a_completarLista(W,Lr),!.
a_completarLista(L,L):-!.

a_binario8(N,Lr):-N<256, a_binario(N,L),a_completarLista(L,Lr),!.

producto_listas([],[],0):-!.
producto_listas([X|XS],[Y|YS],R):-producto_listas(XS,YS,R1),R=R1+X*Y.

a_decimal(X,Y):-a_binario8(X,L),producto_listas(L,[128,64,32,16,8,4,2,1],Y).

goal
/*predecesor([4,5,6],Zs).
max_lista([3,6,1,8],Max).
ordenar([2,3,5,7,8],Zs) .
lista_impares([2,4,5,7,9,1,3],Zs).
predecesor([2,3,4],Z).
a_completarLista([0,1,1,0],Z).
intercambioBits([1,0,1,0],Z).*/
a_binario8(18,Z).

Carlos
02 de Mayo del 2006
Recien entro a estos foros, creo q este codigo ya te lo e mandado muy tarde