?- better_compression("abbbbabbbb", "(ab4)2").

?- better_compression("abbbbabbbb", "<ab4>2").

?- better_compression([a,b,b,b,b,a,b,b,b,b], ['(',a,b,4,')',2]).

?- better_compression("abbbbabbbb", "((ab){4}){2}").

?- better_compression([a,b,b,b,b,a,b,b,b,b], "((ab4)2").

?- better_compression([a,b,b,b,b,a,b,b,b,b], [<,a,b,4,>,2]).

Para que el proceso necesite ser menos inteligente.

Para poder comprimir cadenas iniciales más cortas.

Para una compresión de más calidad.

Para que la compresión sea más eficiente.

Para conseguir menos cadenas comprimidas.

Para que las cadenas comprimidas sean más cortas.

?- byte_xor([h(a),h(s(0))], [h(a),h(s(0))], L).

?- byte_xor([h(a),h(1)], [h(a),h(1)], L).

?- byte_xor("A1", "A1", L).

?- byte_xor([h('A'),h(1)], [h('A'),h(1)], L).

?- byte_xor("10100001", "10100001", L).

Listas de bytes en binario o en hexadecimal

Bytes codificados en binario

Listas de bytes en binario

Listas de bytes en hexadecimal

Bytes codificados en hexadecimal

Sólo bytes expresados como listas de bits

No termina.

1

2

0

No se pueden poner dos cortes seguidos, por ejemplo "p(a) :- !, !."

El corte sólo descarta soluciones si se ejecuta

El corte es local al predicado y no elimina soluciones de los predicados a los que llama

Poner un corte al final de la última cláusula está recomendado por eficiencia

Porque se generan infinitas soluciones pero siempre fallan

La consulta termina pero es muy ineficiente

Porque el caso base es incorrecto

Porque no se está modificando ninguna variable en la cláusula recursiva y hay una recursión infinita

concatenar(L,0,[],[]).

Ninguna respuesta es correcta.

concatenar(Xs,N,Ys,[Xs|Ys]) :- length(Xs,N).

concatenar(Xs,N,Ys,Zs) :- length(Xs,N),append(Xs,Ys,Zs).

Ninguna de las otras respuestas.

todosUnicos([X|Xs]) :- todosUnicos(Xs), \+member(X,Xs).

todosUnicos([X|Xs]) :- \+member(X, Xs), todosUnicos(Xs).

todosUnicos(L) :- L=[X|Xs], todosUnicos(Xs), \+member(X, Xs).

resta(X,Y,Z) :- mayor(X,Y), suma(Y,Z,X).
resta(X,0,X).
resta(X,Y,0) :- menor(X,Y).

resta(X,Y,Z) :- mayor(X,Y), suma(Y,Z,X).
resta(X,X,0).
resta(X,Y,0) :- menor(X,Y).

resta(X,Y,Z) :- mayor(X,Y), suma(Y,Z,X).
resta(X,X,0). 

resta(X,Y,Z) :- mayor(X,Y), resta(Y,Z,X).
resta(X,X,0).
resta(X,Y,0) :- menor(X,Y).