Encomenda - Atribuições paramétricas

a)Suponha que uma encomenda de um produto é uma lista, com dois elementos, em que o primeiro elemento é uma (qualquer) "string", representando o nome do produto, e o segundo elemento é um inteiro positivo, representando o número de unidades desse produto que são encomendadas.

Defina (por atribuição paramétrica diferida ou por abstracção funcional) um predicado encomendaQ, de um argumento, que retorna True, se este puder representar a encomenda de um produto, e retorna False, se tal não for o caso.

Código:
Clear[encomendaQ];
encomendaQ[{_String, a_Integer /; a > 0 }] := True
encomendaQ[_] := False;

b)Defina, por atribuição paramétrica diferida, uma função f, de um argumento, que só está definida para listas, e que, recebendo uma lista w (contendo, possivelmente, encomendas de produtos e elementos de outros tipos) retorna uma lista formada pelas encomendas de produtos que se encontram em w.

Assim, por exemplo:
a invocação f[{{"caneta", 25}, 7, {"abc", 2}, "mesa", {"caneta", 7}, a^2}] retornará {{caneta, 25},{abc, 2},{caneta, 7}};

Código:
Clear[f];
f[w : {___}] := Select[w, Function[x, encomendaQ[x]]]

Explicação:

f receberá qualquer lista de nome w. Depois, seleccionar de w todos os elementos que se adequam ao encomendaQ.
.

Básico da Reescrita: Sequência

O básico da reescrita na sequência.

Acrescentar o inteiro n no início da sequência s:

primeiro[acr[s_,n_]]:=n;

tirarPrim[acr[s_,n_]]:= s;

ultimo[acr[s_,n_]]:= If[ vaziaQ[s], n , ultimo[s]];
(*se s é vazio então o último é o n, se não o último é o último de s*)

Acrescentar o inteiro n no fim da sequência s:

primeiro[acr[s_,n_]]:=If[vaziaQ [s], n, primeiro[s]];

tirarPrim[acr[s_,n_]]:= If[vazia
Q[s], nova, tiraPrim[s]];

ultimo[acr[s_,n_]]:= n ;

---- ---- --
vaziaQ[nova]:= True;
vaziaQ[acr[s_,n_]]:=False;

conta[nova]:=0;
conta[acr[s_,n_]]:= 1+ conta[s];
(*1 é o n*)

ocorre[nova,k_]:=False;
ocorre[acr[s_,n_],k_]:=If[ n==k, True, ocorre[s,k]];
(*se n = k então verdadeiro, se não verificar se k ocorre em s*)

menor[acr[s_,n_]]:=If [vaziaQ[s],n, If[n < menor[s], n, menor[s]]];
(*se s for vazio n é o menor, se não, se n menor que o menor de s então n é o menor, se não o menor é o menor de s. *)


Se descobrirem mais coloquem nos comentários que eu edito aqui (resolvidos ou por resolver).

ps: foi escrito aqui, por isso poderá ter algum parêntesis para fechar ou algo do género.
.

Básico da Reescrita: Fila de espera

O básico da reescrita na fila de espera:

vaziaQ[nova]:=True;
vaziaQ[entra[f_,e_]]:=False;

primeiro[entra[f_,e_]]:=If[ vaziaQ[f], e, primeiro[f];
(*se a fila estiver vazia o primeiro é "e", se não é o primeiro de "f"*)

sai[entra[f_,e_]]:= If[vaziaQ[f], nova, entra[sai[f],e_]];
(*se f estiver vazia dá nova, pois é o "e" que sai, se não o "e" mantém-se e sai o primeiro de f *)
*(Na fila o primeiro a entrar é o primeiro a sair (First In First Out)*)

comprimento[nova]:=0;
comprimento[entra[f_,e_]]:= 1+ comprimento[f];
(* se for nova é zero, se não é 1("e") mais o comprimento de f *)

ultimo[entra[f_,e_]]:=e
(*o último é sempre o "e" pois foi o último a entrar*)

ocorre[nova,k_]:=False
ocorre[entra[f_,e_]]:=If[k==e, True, ocorre[f,k]];
(*se k = e então Verdadeiro, se não verificar se k ocorre em f*)

Se descobrirem mais coloquem nos comentários que eu edito aqui (resolvidos ou por resolver).

ps: foi escrito aqui, por isso poderá ter algum parêntesis para fechar ou algo do género.
.

Básico da Reescrita: Pilha

O básico da reescrita na pilha:

topo[sobrepoe[p_,n_]]:=n;

retira(*topo*)[sobrepoe[p_,n_]]:=p;

vaziaQ[nova]:=True;
vaziaQ[sobrepoe[p_n_]]:=False;

conta[nova,k_]:=0;
conta[sobrepoe[p_,n_],k_]:= If[k==n,1+conta[p,k],conta[p,k]];
(*conta: conta quantos k há na pilha*)
(*se k =n então é 1 mais os k que existir em p, se não conta só os k existem em p*)

cc[p1_,nova]:=p1
cc[p1_,sobrepoe[p2_,n_]]:=sobrepoe[cc[p1,p2],n];
(*cc: colocar uma pilha sobre outra*)

base[sobrepoe[p_,n_]]:=If[vaziaQ[p],n,base[p]];
(*base: mostra a base da pilha*)
(*se p estiver vazio a base é n, se não a base é a base do p*)

retirar2[sobrepoe[nova,k_]:=nova
(*se retirar k de nova dá nova*)
retirar2[soprepoe[p_,n_],k_]:=If[k==n, retirar2[p,k], sobrepoe[retirar[p,k], n];
(*retirar2: retira todos elementos = k da pilha*)
(*Se k=n então retira o n e retira os elementos iguais a k da pilha p, se k diferente de n então o n mantém-se na pilha e retira os elementos de p iguais a k*)

Se descobrirem mais coloquem nos comentários que eu edito aqui(resolvidos ou por resolver).

ps: foi escrito aqui, por isso poderá ter algum parêntesis para fechar ou algo do género.
.
Defina, por atribuição paramétrica diferida, uma função f, de um argumento, que recebendo uma lista de reais, retorna a lista desses reais que são positivos.
Caso o argumento da função não seja uma lista de reais, a invocação da função deverá retornar a mensagem "não é lista de reais".
Exemplos: f[{5,4}] retorna a mensagem "não é lista de reais"; f[{-2. ,4.3, -5.1, 6.2}] retorna {4.3,6.2}; f[5.2] retorna a mensagem "não é lista de reais";

Código:
Clear[f]
f[w : {__Real}] := Select[w, # > 0 &]
f[__] := "não é lista de Reais"

Explicação:
w é uma lista de reais:
w : {__Real}

Se a condição for verdadeira seleccionar da lista w todos elementos maiores que zero:
Select[w, # > 0 &]
.

Real True or False

Defina, por atribuição paramétrica diferida, um predicado p, de um argumento, que retorna True, se este for um número real, e retorna False, se não o for.

Código:
Clear[p];
p[n_Real] := True
p[_] := False

Explicação:

Se p receber número real então true
p[n_Real] := True

Numero não real dá false:
p[_] := False
.

Pedido Pedro: Existe na lista

Defina, por atribuição paramétrica diferida, uma função existe, de dois argumentos, que recebendo uma lista de produtos (existentes numa certa loja) e (o nome de) um produto, retorna True se o produto em causa ocorre na lista, e retorna False, caso tal não se verifique.
Caso algum dos argumentos não seja do tipo especificado, a função deverá retornar a mensagem "argumentos não conformes com o especificado".

Código:
Clear[exist];
exist[w : {___String}, p_String] := MemberQ[w, p]
exist[_, _] := "argumentos não conformes..."

Explicação:
w será uma lista com elementos do tipo Strings
w : {___String}

p será do tipo String
p_String
Se as condições anteriormente apresentadas forem verdadeiras então procurar em w elementos iguais ao p.
MemberQ[w, p]

Se for outro tipo de elementos apresenta mensagem de erro:
exist[_, _] := "argumentos não conformes com o especificado"
.