#Please do not post homework

#Guy Adami, 2026-03-08, Assignment 12

#-----------

with(combinat):


#----------

#A41ok(N): OEIS sequence A41 done much more efficiently
# using Euler's generating function
# Sum(p(n)*q^n,n=0..infinity)=Prod(1/(1-q^k), k=1..infinity)
A41ok:=proc(N) local k,f,q:
f:=mul(1/(1-q^k),k=1..N):
f:=taylor(f,q=0,N+4):
[seq(coeff(f,q,k),k=1..N)]:
end:


#----------


#Park(n,k): The set of partitions of n into exactly k parts


Park:=proc(n,k) local S,k1,S1,s1:
	option remember:

	if n<k then
   		RETURN({}):
	fi:
	if k=0 then
 		if n=0 then
   			RETURN({[]}):
   		else
    			RETURN({}):
		fi:
	fi:

	
	S:={}:
	for k1 from 0 to k do
 		S1:=Park(n-k,k1):
 		S:= S union {seq([op(s1+[1$k1]),1$(k-k1)], s1 in S1)}:
	od:
	S:
end:


#--------------


#Par(n): The set of partitions of n, the clever way.

Par:=proc(n) local k:
	{seq(op(Park(n,k)), k=1..n)}:
end:


#----------


OddParStupid:= proc(n) local P,p, POdd:
	POdd:={}:

	for P in Par(n) do
		if type(P, list(odd)) = true then
			POdd:= {op(POdd),P}:
		fi:
			
	od:
	POdd;
end:


#-----------


DistinctParStupid := proc(n) local DP, P, p:
	DP:= {}:

	P:= Par(n):

	for p in P do
		if nops(p) = nops({op(p)}) then
			DP:= {op(DP),p}:
		fi:
	od:
	
	DP;
end:


#________________________________________

#Question 1


A41c1 := proc(n) local j, P, p1, p2:
	option remember: 

	if n < 0 then 
		return 0:
	fi: 

	if n = 0 then 
		return 1: 
	fi:
 
	P := 0: 
	
	for j while 3/2*j^2 - 1/2*j <= n do 
		p1 := 3/2*j^2 - 1/2*j: 
		p2 := 3/2*j^2 + 1/2*j; 
		
		P := P + (-1)^(j - 1)*A41c1(n - p1); 

		if p2 <= n then 
			P := P + (-1)^(j - 1)*A41c1(n - p2); 
		fi: 
	od: 
	
	P; 
end:

#-----

A41c := proc(N) local P,n:
	
	P:= {seq(A41c1(n),n=1..N)}:

end:	

#-----

###How does time(A41c(1000)) compare to time(A41ok(1000))?

#time(A41c(1000)) = 0.031
#time(A41ok(1000)) = 3.218
## time(A41ok(1000)) is over 100x than time(A41c(1000))


#_____________________

#Question 2


a:=proc(j):
	(3*j^2 + j)/2:
end:	

#-----

PSI := proc(n, lambda) local t, j, N, P, i, psi; 

	psi := []:

	t := nops(lambda): 
	N := add(lambda[i], i = 1 .. t): 


	if n < N then 
		RETURN("Size error: Invalid n or lamda"):
	fi: 

	j := x: 

	if n = N then 
		j := 0; 
	else 
		for i to n do 
			if a(i) = n - N then 
				j := i:
			fi: 
		od: 
	fi: 


	if j = x then 
		RETURN("Invalid n or lambda: j is not an integer"): 
	fi: 


	if lambda[1] <= t + 3*j then 
		psi := [t + 3*j - 1, seq(lambda[i] - 1, i = 1 .. t)]: 
	else 
		for i from 2 to t do 
			psi := [op(psi), lambda[i] + 1]: 
		od:
		psi := [op(psi), 1 $ (lambda[1] - 3*j - t - 1)]:
	fi: 

psi; 
end:



#_____________________

#Question 3

#I tried for a very long time to understand/get the maple code to work Sylvester's Bijection, but I couldn't


#Uses Stupid Odd and Distinct from Homework 10:


T:=proc(a,r,m) local d,dprior:
	option remember:
	if r = 1 then
		return[m]:
	else
		d:= a+r+m-1:
		dprior:=T(a-1,r-1,m):
		[d,op(dprior)];
	fi:
end:

OddToDis:= proc(p)local O,o,o1,A,a,D,d,i,m:


	D:={}:
	O:= OddParStupid(p):
	A:=[]:

	for o in O do
		for o1 in o do
			a:=(o1-1)/2:
			
			A:=[op(A),a]:
		od:
		r:=nops(A):
			d:=[A[1]+r]
		for i from 2 to nops(A) do
			d:= [op(d),A[2]+r-1]
		od:
		D:=[op(D),d]
	od:
	D;
end: