ARRANGEMENTS

[Xlambda]

ARRANGEMENTS Extracts all permutations or combinations, with or without repetitions, of all elements of an array, by a number chosen.
Study inspired by latest MrExcel's YT (15aug21) Excel All Combinations Using Power Query - 2424
This is the first draft I came with, of course, the recursion way deserves first place. There are 2 other approaches, one using AFUSBYROW/BYCOL functions, and the other using new functions.
Calls 3 tool lambdas, 1 non recursive and 2 recursive (no risk to reach limitations, recursion takes place on the "short" direction, the columns one) . The recursive ones were created with ease using the ARF recursive kits concepts. Also, both recursive ones can be used as standalone lambdas, T_P is filtering an array by rows with no dups, and T_CA is filtering an array by rows that are in ascending order. The challenge was to do this by columns iterations and not by rows iteration (too many).
For ARRANGEMENTS function we use them to create the index patterns for extracting array's elements as are required. T_PA (non-recursive) creates the index pattern for permutations with repetitions, Once we have that, T_P (recursive) creates the index pattern for permutations without repetitions T_P(T_PA), T_CA creates the patterns for combinations with repetitions T_CA(T_PA), and for combinations without repetitions we use the same T_CA but this time, as input, we use T_P, T_CA(T_P). Calculation time for arrays having 1M rows 1 to 3 seconds.
T_PA(n,c)=LAMBDA(n,c,MOD(ROUNDUP(SEQUENCE(n^c)/n^(c-SEQUENCE(,c)),0)-1,n)+1) where n: number ; c: number chosen
T_P(a,[ai],[ i ] )=LAMBDA(a,[ai],[ i ],LET(n,COLUMNS(a),j,IF(i="",n,i),x,INDEX(a,,j),IF(j=0,FILTER(a,MMULT(ai,SEQUENCE( n)^0)=n),T_P(a,ai+(x=a),j-1)))) !! recursive !!
T_CA(a,[ai],[ i ])=LAMBDA(a,[ai],[ i ],LET(n,COLUMNS(a),j,IF(i="",1,i),aj,IF(ai="",1,ai),x,INDEX(a,,j),IF(j=n,FILTER(a,aj),T_CA(a,aj*(x<=INDEX(a,,j+1)),j+1)))) !! recursive !! where a:array, ai,i,omitted

=LAMBDA(a,t,c,
    IF(AND(t<>{"p","pa","c","ca"}),"check type",
      LET(k,MAX(1,c),x,AFLAT(a),n,ROWS(x),IF(AND(OR(t={"p","c"}),k>n),"nr chosen>n !",LET(y,T_PA(n,k),
       SWITCH(t,"pa",INDEX(x,y),"p",INDEX(x,T_P(y)),"ca",INDEX(x,T_CA(y)),"c",LET(z,T_P(y),w,T_CA(z),INDEX(x,w))))))
    )
)

LAMBDA 1.1.1.xlsx
	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O
1	Introduction: Combinatorics Excel functions:
2	1,) PERMUTATIONA Returns the number of permutations for a given number of objects (with repetitions) that can be selected from the total objects.
3		- PERMUTATIONA(number, number-chosen); "nc" or "c" (number chosen) can be >=n (number of elements/objects) ; order is important; PA=n^nc
4	2.) PERMUT Returns the number of permutations for a given number of objects (no repetitions) that can be selected from the total objects.
5		- PERMUT(number, number_chosen); if nc>n returns #NUM! error; also called arrangements; order is important ;P=n!/(n-nc)!
6	3.) COMBINA Returns the number of combinations (with repetitions) for a given number of items.
7		- COMBINA(number, number_chosen) ; nc can be > n; order is not important; CA=(n+nc-1)!/(nc!*(n-1)!)
8	4.) COMBIN Returns the number of combinations (no repetitions) for a given number of items.
9		- COMBINA(number, number_chosen) ; nc can be > n; order is not important; C=P/nc! or C=n!/(nc!*(n-nc)!)
10	What ARRANGEMENTS does is "printing" or extracting all this numbers of permutations or combinations, given the object array "a" and the number_chosen "c",
11	for all types "t" above : "pa" for 1.) , "p" for 2.) , "ca" for 3.) ,"c" for 4.)
12
13		input n:	7	Table of values returned by all functions for an array of n objects ,nc [1,10]
14
15		function\nc	1	2	3	4	5	6	7	8	9	10
16		1,) PERMUTATIONA	7	49	343	2401	16807	117649	823543	5764801	40353607	282475249
17		2,) PERMUT	7	42	210	840	2520	5040	5040	#NUM!	#NUM!	#NUM!
18		3.) COMBINA	7	28	84	210	462	924	1716	3003	5005	8008
19		4.) COMBIN	7	21	35	35	21	7	1	#NUM!	#NUM!	#NUM!
20
21		Note:	It is easy to run out of "printing" real estate in an excel spreadsheet for small arrays of objects
22
ARR post 1

Cell Formulas
Range	Formula
C15:L15	C15	=SEQUENCE(,10)
C16:L16	C16	=PERMUTATIONA(C13,C15#)
C17:L17	C17	=PERMUT(C13,C15#)
C18:L18	C18	=COMBINA(C13,C15#)
C19:L19	C19	=COMBIN(C13,C15#)
Dynamic array formulas.

 

[Xlambda]

Example inspired by today's (12-Dec-21) MrExcel YT: Random Combination Of PBPBBP - 2448
The challenge is: "Jon wants to generate 6-letter sequences using only the letters B and P.
So, for example: BBBBBB, PPPPPP, BPBPPB, BBBPPP, and so on. There are 64 such combinations and Bill shows you one way to solve this use BASE and SUBSTITUTE."
Check the video please, you will find out that using of BASE function is a super cool trick.
Also, this can be solved with ARRANGEMENTS function. Other functions on minisheet ATEXTJOIN

LAMBDA 1.2.1.xlsx
	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O
1	Letters			Number chosen
2	B	P		6
3
4	1. Why there are 64 possible "combinations" (permutations with repetition) ?
5	Because PERMUTATIONA(2,6)=64
6	=PERMUTATIONA(2,6)
7	64
8	For example, for 3 letters total nr. will be PERMUTATIONA(3,6)=729
9	=PERMUTATIONA(3,6)
10	729
11								Now , the only thing to do is to concatenate the columns(BYROW)
12	=ARRANGEMENTS(A2:B2,"pa",6)							=BYROW(A13#,LAMBDA(a,CONCAT(a)))
13	B	B	B	B	B	B		BBBBBB
14	B	B	B	B	B	P		BBBBBP		Or a single cell using ATEXTJOIN
15	B	B	B	B	P	B		BBBBPB		=ATEXTJOIN(ARRANGEMENTS(A2:B2,"pa",6),"")
16	B	B	B	B	P	P		BBBBPP		BBBBBB
17	B	B	B	P	B	B		BBBPBB		BBBBBP		checks
18	B	B	B	P	B	P		BBBPBP		BBBBPB		=ROWS(A13#)		=ROWS(J16#)
19	B	B	B	P	P	B		BBBPPB		BBBBPP		64		64
20	B	B	B	P	P	P		BBBPPP		BBBPBB
21	B	B	P	B	B	B		BBPBBB		BBBPBP			=INDEX(J16#,1)
22	B	B	P	B	B	P		BBPBBP		BBBPPB		first value :	BBBBBB
23	B	B	P	B	P	B		BBPBPB		BBBPPP		last value:	PPPPPP
24	B	B	P	B	P	P		BBPBPP		BBPBBB			=INDEX(J16#,64)
25	B	B	P	P	B	B		BBPPBB		BBPBBP
26	B	B	P	P	B	P		BBPPBP		BBPBPB
27	B	B	P	P	P	B		BBPPPB		BBPBPP		Other functions
28	B	B	P	P	P	P		BBPPPP		BBPPBB		ATEXTJOIN
29	B	P	B	B	B	B		BPBBBB		BBPPBP
30	B	P	B	B	B	P		BPBBBP		BBPPPB
31	B	P	B	B	P	B		BPBBPB		BBPPPP
32	B	P	B	B	P	P		BPBBPP		BPBBBB
33	B	P	B	P	B	B		BPBPBB		BPBBBP
34	B	P	B	P	B	P		BPBPBP		BPBBPB
35	B	P	B	P	P	B		BPBPPB		BPBBPP
36	B	P	B	P	P	P		BPBPPP		BPBPBB
37	B	P	P	B	B	B		BPPBBB		BPBPBP
38	B	P	P	B	B	P		BPPBBP		BPBPPB
39	B	P	P	B	P	B		BPPBPB		BPBPPP
40	B	P	P	B	P	P		BPPBPP		BPPBBB
41	B	P	P	P	B	B		BPPPBB		BPPBBP
42	B	P	P	P	B	P		BPPPBP		BPPBPB
43	B	P	P	P	P	B		BPPPPB		BPPBPP
44	B	P	P	P	P	P		BPPPPP		BPPPBB
45	P	B	B	B	B	B		PBBBBB		BPPPBP
46	P	B	B	B	B	P		PBBBBP		BPPPPB
47	P	B	B	B	P	B		PBBBPB		BPPPPP
48	P	B	B	B	P	P		PBBBPP		PBBBBB
49	P	B	B	P	B	B		PBBPBB		PBBBBP
50	P	B	B	P	B	P		PBBPBP		PBBBPB
51	P	B	B	P	P	B		PBBPPB		PBBBPP
52	P	B	B	P	P	P		PBBPPP		PBBPBB
53	P	B	P	B	B	B		PBPBBB		PBBPBP
54	P	B	P	B	B	P		PBPBBP		PBBPPB
55	P	B	P	B	P	B		PBPBPB		PBBPPP
56	P	B	P	B	P	P		PBPBPP		PBPBBB
57	P	B	P	P	B	B		PBPPBB		PBPBBP
58	P	B	P	P	B	P		PBPPBP		PBPBPB
59	P	B	P	P	P	B		PBPPPB		PBPBPP
60	P	B	P	P	P	P		PBPPPP		PBPPBB
61	P	P	B	B	B	B		PPBBBB		PBPPBP
62	P	P	B	B	B	P		PPBBBP		PBPPPB
63	P	P	B	B	P	B		PPBBPB		PBPPPP
64	P	P	B	B	P	P		PPBBPP		PPBBBB
65	P	P	B	P	B	B		PPBPBB		PPBBBP
66	P	P	B	P	B	P		PPBPBP		PPBBPB
67	P	P	B	P	P	B		PPBPPB		PPBBPP
68	P	P	B	P	P	P		PPBPPP		PPBPBB
69	P	P	P	B	B	B		PPPBBB		PPBPBP
70	P	P	P	B	B	P		PPPBBP		PPBPPB
71	P	P	P	B	P	B		PPPBPB		PPBPPP
72	P	P	P	B	P	P		PPPBPP		PPPBBB
73	P	P	P	P	B	B		PPPPBB		PPPBBP
74	P	P	P	P	B	P		PPPPBP		PPPBPB
75	P	P	P	P	P	B		PPPPPB		PPPBPP
76	P	P	P	P	P	P		PPPPPP		PPPPBB
77										PPPPBP
78										PPPPPB
79										PPPPPP
80
ARRG ex 1

Cell Formulas
Range	Formula
A6,M21,L18,N18,J15,A12,H12,A9	A6	=FORMULATEXT(A7)
A7	A7	=PERMUTATIONA(2,6)
A10	A10	=PERMUTATIONA(3,6)
A13:F76	A13	=ARRANGEMENTS(A2:B2,"pa",6)
H13:H76	H13	=BYROW(A13#,LAMBDA(a,CONCAT(a)))
J16:J79	J16	=ATEXTJOIN(ARRANGEMENTS(A2:B2,"pa",6),"")
L19	L19	=ROWS(A13#)
N19	N19	=ROWS(J16#)
M22	M22	=INDEX(J16#,1)
M23	M23	=INDEX(J16#,64)
M24	M24	=FORMULATEXT(M23)
Dynamic array formulas.

 

[Xlambda]

Study of using BASE function, as feasible alternative for creating arrays of permutations with repetitions, replacing T_PA function concept, the function that is triggered by ARRANGEMENTS when this this type of permutation is needed.

LAMBDA 1.2.1.xlsx
	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z	AA	AB	AC
1	Using of BASE function concept vs. T_PA function. Part 1.
2	As we know, the t="pa" (type) argument in ARRANGEMENTS(a,t,c) is triggering T_PA(n,c) function
3
4					total arrangements
5	Letters		Nr. chosen		=COLUMNS(A6:B6)^C6				To avoid using nested SUBSTITUTE functions there are 2 approaches
6	B	P	5		32				- calling custom made function AREPLACE (deals with nested substitute's)
7	Note: For shorter formula , replaced permutationa(n,c) with n^c								- creating an array of the arrangements "indexes"									T_PA returns indexes array
8	=BASE(SEQUENCE(COLUMNS(A6:B6)^C6)-1,COLUMNS(A6:B6),C6)								AREPLACE									by default, no AREPLACE needed
9	↓		=SUBSTITUTE(SUBSTITUTE(A10#,0,A6),1,B6)						=AREPLACE(A10#,{0,1},A6:B6)			=MID(A10#,SEQUENCE(,C6),1)+1						=T_PA(2,5)						=INDEX(A6:B6,R10#)
10	00000		BBBBB						BBBBB			1	1	1	1	1		1	1	1	1	1		B	B	B	B	B
11	00001		BBBBP						BBBBP			1	1	1	1	2		1	1	1	1	2		B	B	B	B	P
12	00010		BBBPB						BBBPB			1	1	1	2	1		1	1	1	2	1		B	B	B	P	B
13	00011		BBBPP						BBBPP			1	1	1	2	2		1	1	1	2	2		B	B	B	P	P
14	00100		BBPBB						BBPBB			1	1	2	1	1		1	1	2	1	1		B	B	P	B	B
15	00101		BBPBP						BBPBP			1	1	2	1	2		1	1	2	1	2		B	B	P	B	P
16	00110		BBPPB						BBPPB			1	1	2	2	1		1	1	2	2	1		B	B	P	P	B
17	00111		BBPPP						BBPPP			1	1	2	2	2		1	1	2	2	2		B	B	P	P	P
18	01000		BPBBB						BPBBB			1	2	1	1	1		1	2	1	1	1		B	P	B	B	B
19	01001		BPBBP						BPBBP			1	2	1	1	2		1	2	1	1	2		B	P	B	B	P
20	01010		BPBPB						BPBPB			1	2	1	2	1		1	2	1	2	1		B	P	B	P	B
21	01011		BPBPP						BPBPP			1	2	1	2	2		1	2	1	2	2		B	P	B	P	P
22	01100		BPPBB						BPPBB			1	2	2	1	1		1	2	2	1	1		B	P	P	B	B
23	01101		BPPBP						BPPBP			1	2	2	1	2		1	2	2	1	2		B	P	P	B	P
24	01110		BPPPB						BPPPB			1	2	2	2	1		1	2	2	2	1		B	P	P	P	B
25	01111		BPPPP						BPPPP			1	2	2	2	2		1	2	2	2	2		B	P	P	P	P
26	10000		PBBBB						PBBBB			2	1	1	1	1		2	1	1	1	1		P	B	B	B	B
27	10001		PBBBP						PBBBP			2	1	1	1	2		2	1	1	1	2		P	B	B	B	P
28	10010		PBBPB						PBBPB			2	1	1	2	1		2	1	1	2	1		P	B	B	P	B
29	10011		PBBPP						PBBPP			2	1	1	2	2		2	1	1	2	2		P	B	B	P	P
30	10100		PBPBB						PBPBB			2	1	2	1	1		2	1	2	1	1		P	B	P	B	B
31	10101		PBPBP						PBPBP			2	1	2	1	2		2	1	2	1	2		P	B	P	B	P
32	10110		PBPPB						PBPPB			2	1	2	2	1		2	1	2	2	1		P	B	P	P	B
33	10111		PBPPP						PBPPP			2	1	2	2	2		2	1	2	2	2		P	B	P	P	P
34	11000		PPBBB						PPBBB			2	2	1	1	1		2	2	1	1	1		P	P	B	B	B
35	11001		PPBBP						PPBBP			2	2	1	1	2		2	2	1	1	2		P	P	B	B	P
36	11010		PPBPB						PPBPB			2	2	1	2	1		2	2	1	2	1		P	P	B	P	B
37	11011		PPBPP						PPBPP			2	2	1	2	2		2	2	1	2	2		P	P	B	P	P
38	11100		PPPBB						PPPBB			2	2	2	1	1		2	2	2	1	1		P	P	P	B	B
39	11101		PPPBP						PPPBP			2	2	2	1	2		2	2	2	1	2		P	P	P	B	P
40	11110		PPPPB						PPPPB			2	2	2	2	1		2	2	2	2	1		P	P	P	P	B
41	11111		PPPPP						PPPPP			2	2	2	2	2		2	2	2	2	2		P	P	P	P	P
42
ARRG ex 2

Cell Formulas
Range	Formula
E5,X9,I9,L9,R9,C9	E5	=FORMULATEXT(E6)
E6	E6	=COLUMNS(A6:B6)^C6
A8	A8	=FORMULATEXT(A10)
A10:A41	A10	=BASE(SEQUENCE(COLUMNS(A6:B6)^C6)-1,COLUMNS(A6:B6),C6)
C10:C41	C10	=SUBSTITUTE(SUBSTITUTE(A10#,0,A6),1,B6)
I10:I41	I10	=AREPLACE(A10#,{0,1},A6:B6)
L10:P41	L10	=MID(A10#,SEQUENCE(,C6),1)+1
R10:V41	R10	=T_PA(2,5)
X10:AB41	X10	=INDEX(A6:B6,R10#)
Dynamic array formulas.

 

[Xlambda]

LAMBDA 1.2.1.xlsx
	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V
1	Using of BASE function concept vs. T_PA function. Part 2.
2	We have seen that BASE function can have good premises to replace T_PA(n,c) function, or not?
3	T_PA(n,c)=LAMBDA(n,c,MOD(ROUNDUP(SEQUENCE(n^c)/n^(c-SEQUENCE(,c)),0)-1,n)+1)
4	Also we have seen that, to avoid nested SUBSTITUTE functions, it is better to create array of "indexes" concept,
5	that avoids calling other function AREPLACE
6	Designing T_PAB(n,c) function using BASE for a simple scenario n=2,c=3 (n<c scenario)
7
8	step 1. BASE(SEQUENCE(n^c)-1,n,c)
9	=BASE(SEQUENCE(2^3)-1,2,3)
10	000
11	001		step 2. expanding values to					step 3. for corect indexes					step 4. The function
12	010		an array of indexes					we have to add 1
13	011		=MID(A10#,SEQUENCE(,3),1)					=C14#+1					=LAMBDA(n,c,LET(b,BASE(SEQUENCE(n^c)-1,n,c),MID(b,SEQUENCE(,c),1)+1))(2,3)
14	100		0	0	0			1	1	1			1	1	1
15	101		0	0	1			1	1	2			1	1	2
16	110		0	1	0			1	2	1			1	2	1
17	111		0	1	1			1	2	2			1	2	2
18			1	0	0			2	1	1			2	1	1
19			1	0	1			2	1	2			2	1	2
20			1	1	0			2	2	1			2	2	1
21			1	1	1			2	2	2			2	2	2
22
23	T_PAB(n,c)=LAMBDA(n,c,LET(b,BASE(SEQUENCE(n^c)-1,n,c),MID(b,SEQUENCE(,c),1)+1))
24
25			=T_PAB(2,3)					=T_PA(2,3)
26			1	1	1			1	1	1
27			1	1	2			1	1	2
28			1	2	1			1	2	1
29			1	2	2			1	2	2
30			2	1	1			2	1	1
31			2	1	2			2	1	2
32			2	2	1			2	2	1
33			2	2	2			2	2	2
34
35	So far so good, both functions return same outcome,on the next post will cover scenarios where n>c
36
ARRG ex 3

Cell Formulas
Range	Formula
A9,H25,C25,M13,C13,H13	A9	=FORMULATEXT(A10)
A10:A17	A10	=BASE(SEQUENCE(2^3)-1,2,3)
C14:E21	C14	=MID(A10#,SEQUENCE(,3),1)
H14:J21	H14	=C14#+1
M14:O21	M14	=LAMBDA(n,c,LET(b,BASE(SEQUENCE(n^c)-1,n,c),MID(b,SEQUENCE(,c),1)+1))(2,3)
C26:E33	C26	=T_PAB(2,3)
H26:J33	H26	=T_PA(2,3)
Dynamic array formulas.

 

[Xlambda]

LAMBDA 1.2.1.xlsx
	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U
1	Using of BASE function concept vs. T_PA function. Part 3.(n>c scenario)
2	Checking T_PAB(n,c) function using BASE for n=13,c=3								The reason T_PAB returns errors is because BASE, when radix argument n>10, returns letters
3	- total possibilities n^c=			2197					This problem can be addressed easily with AREPLACE, but this is exactly what we wanted to avoid.
4									Conclusion: T_PA is better for covering both scenarios.
5									So T_PA will stay, and on following posts will cover what I have stated since day one, alternatives for the recursive ones T_P and T_CA.
6									"There are 2 other approaches, one using AFUSBYROW/BYCOL functions, and the other using new functions." (lambda helper functions)
7
8	=T_PAB(13,3)				=T_PA(13,3)				=BASE(SEQUENCE(13^3)-1,13,3)		=MID(I9#,SEQUENCE(,3),1)				=K9#+1
9	1	1	1		1	1	1		000		0	0	0		1	1	1		checking
10	1	1	2		1	1	2		001		0	0	1		1	1	2		=ROWS(A9#)
11	1	1	3		1	1	3		002		0	0	2		1	1	3		2197
12	1	1	4		1	1	4		003		0	0	3		1	1	4		=ROWS(E9#)
13	1	1	5		1	1	5		004		0	0	4		1	1	5		2197
14	1	1	6		1	1	6		005		0	0	5		1	1	6		=ROWS(I9#)
15	1	1	7		1	1	7		006		0	0	6		1	1	7		2197
16	1	1	8		1	1	8		007		0	0	7		1	1	8		=ROWS(O9#)
17	1	1	9		1	1	9		008		0	0	8		1	1	9		2197
18	1	1	10		1	1	10		009		0	0	9		1	1	10
19	1	1	#VALUE!		1	1	11		00A		0	0	A		1	1	#VALUE!
20	1	1	#VALUE!		1	1	12		00B		0	0	B		1	1	#VALUE!
21	1	1	#VALUE!		1	1	13		00C		0	0	C		1	1	#VALUE!
22	1	2	1		1	2	1		010		0	1	0		1	2	1
23	1	2	2		1	2	2		011		0	1	1		1	2	2
24	1	2	3		1	2	3		012		0	1	2		1	2	3
25	1	2	4		1	2	4		013		0	1	3		1	2	4
26	1	2	5		1	2	5		014		0	1	4		1	2	5
27	1	2	6		1	2	6		015		0	1	5		1	2	6
28	1	2	7		1	2	7		016		0	1	6		1	2	7
29	1	2	8		1	2	8		017		0	1	7		1	2	8
30	1	2	9		1	2	9		018		0	1	8		1	2	9		down to
31	1	2	10		1	2	10		019		0	1	9		1	2	10		2197 rows
32	1	2	#VALUE!		1	2	11		01A		0	1	A		1	2	#VALUE!		↓↓↓↓
33	1	2	#VALUE!		1	2	12		01B		0	1	B		1	2	#VALUE!
34	1	2	#VALUE!		1	2	13		01C		0	1	C		1	2	#VALUE!
ARRG ex 4

Cell Formulas
Range	Formula
D3	D3	=13^3
A8,S10,S12,S14,S16,I8,K8,O8,E8	A8	=FORMULATEXT(A9)
A9:C2205	A9	=T_PAB(13,3)
E9:G2205	E9	=T_PA(13,3)
I9:I2205	I9	=BASE(SEQUENCE(13^3)-1,13,3)
K9:M2205	K9	=MID(I9#,SEQUENCE(,3),1)
O9:Q2205	O9	=K9#+1
S11	S11	=ROWS(A9#)
S13	S13	=ROWS(E9#)
S15	S15	=ROWS(I9#)
S17	S17	=ROWS(O9#)
Dynamic array formulas.

 

[Xlambda]

When I first started this thread, I've said: "There are 2 other approaches, one using AFUSBYROW/BYCOL functions, and the other using new functions." Here are the other approaches.
Recap: Permutations
As we know PERMUTATIONA(n,c) calculates all permutations with repetitions of "n" by nr. chosen "c", and PERMUT(n,c) calculates the number of permutations without repetitions.
T_PA(n,c) is a function we created to "print" an array "a" of all these permutations with repetitions. Is simple and non-recursive.
T_P(a) is a recursive function filters the rows of "a" that have repetitions (dups), will keep only the rows with no dups. To check these results, rows(T_P(a))=PERMUT(n,c), the same "n" and "c" that created "a".
T_PN(a) will replace the recursive one using New REDUCE and BYROW.
T_PF(a) will replace the recursive one with other existing Functions AFUSBYROW and AHCLEAN.
Note: All functions T_P(a),T_PN(a),T_PF(a), can be used as standalone functions that will be capable to filter any array "a" for rows w/o dups, not only the array "a" created by T_PA(n,c)

LAMBDA 1.2.1.xlsx
	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X
1	Concept of T_P(a), T_PN(a)
2
3	T_P(a)=LAMBDA(a,[ai ],[i ],LET(n,COLUMNS(a),j,IF(i="",n,i),x,INDEX(a,,j),IF(j=0,FILTER(a,MMULT(ai,SEQUENCE( n)^0)=n),T_P(a,ai+(x=a),j-1))))
4
5					clm 1=a				clm 2=a				clm 3=a			if we sum all these arrays					summing by rows
6			a		=A7:A16=A7:C16				=B7:B16=A7:C16				=C7:C16=A7:C16				=E7#+I7#+M7#				=SUM(Q7:S7)
7	1	1	2		TRUE	TRUE	FALSE		TRUE	TRUE	FALSE		FALSE	FALSE	TRUE		2	2	1		5
8	a	b	b		TRUE	FALSE	FALSE		FALSE	TRUE	TRUE		FALSE	TRUE	TRUE		1	2	2		5
9	c	d	c		TRUE	FALSE	TRUE		FALSE	TRUE	FALSE		TRUE	FALSE	TRUE		2	1	2		5
10	2	2	2		TRUE	TRUE	TRUE		TRUE	TRUE	TRUE		TRUE	TRUE	TRUE		3	3	3		9
11	1	2	3		TRUE	FALSE	FALSE		FALSE	TRUE	FALSE		FALSE	FALSE	TRUE		1	1	1		3
12	2	1	3		TRUE	FALSE	FALSE		FALSE	TRUE	FALSE		FALSE	FALSE	TRUE		1	1	1		3
13	3	2	1		TRUE	FALSE	FALSE		FALSE	TRUE	FALSE		FALSE	FALSE	TRUE		1	1	1		3
14	a	b	c		TRUE	FALSE	FALSE		FALSE	TRUE	FALSE		FALSE	FALSE	TRUE		1	1	1		3
15	c	c	b		TRUE	TRUE	FALSE		TRUE	TRUE	FALSE		FALSE	FALSE	TRUE		2	2	1		5
16	b	a	c		TRUE	FALSE	FALSE		FALSE	TRUE	FALSE		FALSE	FALSE	TRUE		1	1	1		3
17
18					Note: There is also a solution to do iterations by rows, but I chose column orientation iterations for being the short dimension.
19
20					T_P does sum of arrays clm i=a recursively,T_PN with REDUCE
21					The rows that deliver 1,1,1 coresponds to the rows of "a" that hold unique values
22					On other words, if we sum by rows, the rows with unique values =3 or =clms(a)
23					T_P does the sum by rows with MMULT, T_PN with by BYROW
24
25					=MMULT(Q7#,SEQUENCE(3)^0)					=BYROW(Q7#,LAMBDA(x,SUM(x)))
26					5					5
27					5					5			For final result both use FILTER
28					5					5
29					9					9			=FILTER(A7:C16,J26#=3)				=T_P(A7:C16)
30					3					3			1	2	3		1	2	3
31					3					3			2	1	3		2	1	3
32					3					3			3	2	1		3	2	1
33					3					3			a	b	c		a	b	c
34					5					5			b	a	c		b	a	c
35					3					3
36
ARRG np1

Cell Formulas
Range	Formula
E6,M29,Q29,E25,J25,Q6,U6,M6,I6	E6	=FORMULATEXT(E7)
E7:G16	E7	=A7:A16=A7:C16
I7:K16	I7	=B7:B16=A7:C16
M7:O16	M7	=C7:C16=A7:C16
Q7:S16	Q7	=E7#+I7#+M7#
U7:U16	U7	=SUM(Q7:S7)
E26:E35	E26	=MMULT(Q7#,SEQUENCE(3)^0)
J26:J35	J26	=BYROW(Q7#,LAMBDA(x,SUM(x)))
M30:O34	M30	=FILTER(A7:C16,J26#=3)
Q30:S34	Q30	=T_P(A7:C16)
Dynamic array formulas.

 

[Xlambda]

T_PN(a) Tool function calculating Permutations indexes without repetitions, using New lambda helper functions REDUCE, BYROW.

=LAMBDA(a,LET(c,COLUMNS(a),FILTER(a,BYROW(REDUCE(0,SEQUENCE(c),LAMBDA(v,i,v+(INDEX(a,,i)=a))),LAMBDA(x,SUM(x)=c)))))

LAMBDA 1.2.1.xlsx
	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y
1	T_PN(a) : alternative of T_P(a) (recursive) , using NEW lambda helper functions (REDUCE,BYROW) - filters rows w/o dups
2
3	If a=T_PA(n,c) "prints" all PERMUTATIONA(n,c) (permutations w repetitions) , T_PN(T_PA(n,c))=T_PN(a) will "print" all PERMUT(n,c) (permutations w/o repetitions)
4
5	n,4,c,3
6	=PERMUTATIONA(4,3)				step 1 (clm1=a)+(clm2=a)+(clm3=a)
7	64	check			=REDUCE(0,SEQUENCE(COLUMNS(A11#)),LAMBDA(v,i,v+(INDEX(A11#,,i)=A11#)))
8	64	=ROWS(A11#)			⬇											check
9					⬇				step 2 sum BYROW(a')							24	=PERMUT(4,3)
10	=T_PA(4,3)		a		⬇		a'		=BYROW(E11#,LAMBDA(a,SUM(a)))							24	=ROWS(P14#)
11	1	1	1		3	3	3		9	a''						NEW!! T_PN(a)
12	1	1	2		2	2	1		5		step 3 FILTER(a,a''=clms(a))					step 4 single cell				recursive one T_P(a)
13	1	1	3		2	2	1		5		=FILTER(A11#,I11#=COLUMNS(A11#))					=T_PN(A11#)				=T_P(A11#)
14	1	1	4		2	2	1		5		1	2	3			1	2	3		1	2	3
15	1	2	1		2	1	2		5		1	2	4			1	2	4		1	2	4
16	1	2	2		1	2	2		5		1	3	2			1	3	2		1	3	2
17	1	2	3		1	1	1		3		1	3	4			1	3	4		1	3	4
18	1	2	4		1	1	1		3		1	4	2			1	4	2		1	4	2
19	1	3	1		2	1	2		5		1	4	3			1	4	3		1	4	3
20	1	3	2		1	1	1		3		2	1	3			2	1	3		2	1	3
21	1	3	3		1	2	2		5		2	1	4			2	1	4		2	1	4
22	1	3	4		1	1	1		3		2	3	1			2	3	1		2	3	1
23	1	4	1		2	1	2		5		2	3	4			2	3	4		2	3	4
24	1	4	2		1	1	1		3		2	4	1			2	4	1		2	4	1
25	1	4	3		1	1	1		3		2	4	3			2	4	3		2	4	3
26	1	4	4		1	2	2		5		3	1	2			3	1	2		3	1	2
27	2	1	1		1	2	2		5		3	1	4			3	1	4		3	1	4
28	2	1	2		2	1	2		5		3	2	1			3	2	1		3	2	1
29	2	1	3		1	1	1		3		3	2	4			3	2	4		3	2	4
30	2	1	4		1	1	1		3		3	4	1			3	4	1		3	4	1
31	2	2	1		2	2	1		5		3	4	2			3	4	2		3	4	2
32	2	2	2		3	3	3		9		4	1	2			4	1	2		4	1	2
33	2	2	3		2	2	1		5		4	1	3			4	1	3		4	1	3
34	2	2	4		2	2	1		5		4	2	1			4	2	1		4	2	1
35	2	3	1		1	1	1		3		4	2	3			4	2	3		4	2	3
36	2	3	2		2	1	2		5		4	3	1			4	3	1		4	3	1
37	2	3	3		1	2	2		5		4	3	2			4	3	2		4	3	2
38	2	3	4		1	1	1		3
39	2	4	1		1	1	1		3
40	2	4	2		2	1	2		5
41	2	4	3		1	1	1		3
42	2	4	4		1	2	2		5
43	3	1	1		1	2	2		5
44	3	1	2		1	1	1		3
45	3	1	3		2	1	2		5
46	3	1	4		1	1	1		3
47	3	2	1		1	1	1		3
48	3	2	2		1	2	2		5
49	3	2	3		2	1	2		5
50	3	2	4		1	1	1		3
51	3	3	1		2	2	1		5
52	3	3	2		2	2	1		5
53	3	3	3		3	3	3		9
54	3	3	4		2	2	1		5
55	3	4	1		1	1	1		3
56	3	4	2		1	1	1		3
57	3	4	3		2	1	2		5
58	3	4	4		1	2	2		5
59	4	1	1		1	2	2		5
60	4	1	2		1	1	1		3
61	4	1	3		1	1	1		3
62	4	1	4		2	1	2		5
63	4	2	1		1	1	1		3
64	4	2	2		1	2	2		5
65	4	2	3		1	1	1		3
66	4	2	4		2	1	2		5
67	4	3	1		1	1	1		3
68	4	3	2		1	1	1		3
69	4	3	3		1	2	2		5
70	4	3	4		2	1	2		5
71	4	4	1		2	2	1		5
72	4	4	2		2	2	1		5
73	4	4	3		2	2	1		5
74	4	4	4		3	3	3		9
75
ARRG np2

Cell Formulas
Range	Formula
A6,T13,K13,P13,A10,I10	A6	=FORMULATEXT(A7)
A7	A7	=PERMUTATIONA(4,3)
E7	E7	=FORMULATEXT(E11)
A8	A8	=ROWS(A11#)
B8,Q9:Q10	B8	=FORMULATEXT(A8)
P9	P9	=PERMUT(4,3)
P10	P10	=ROWS(P14#)
A11:C74	A11	=T_PA(4,3)
E11:G74	E11	=REDUCE(0,SEQUENCE(COLUMNS(A11#)),LAMBDA(v,i,v+(INDEX(A11#,,i)=A11#)))
I11:I74	I11	=BYROW(E11#,LAMBDA(a,SUM(a)))
K14:M37	K14	=FILTER(A11#,I11#=COLUMNS(A11#))
P14:R37	P14	=T_PN(A11#)
T14:V37	T14	=T_P(A11#)
Dynamic array formulas.

 

[Xlambda]

T_PF(a) Tool function calculating Permutations indexes without repetitions, using other Functions AFUSBYROW, AHCLEAN

=LAMBDA(a,AHCLEAN(AFUSBYROW(a,,1)))

LAMBDA 1.2.1.xlsx
	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q
1	T_PF(a) , alternative of T_P(a) or T_PN(a) , using other Functions (AFUSBYROW,AHCLEAN) - filters rows w/o dups
2	( f,u,s are the filter, unique, sort, arguments of AFUSBYROW )
3					step 1				step 2
4	permutationa(4,3)				f,omitted,u,1,s,omitted				n,omitted				step 3				other functions
5	n,4,c,3				(unique by each row)				(filters only full rows)				single cell				AFUSBYROW
6	=T_PA(4,3)				=AFUSBYROW(A7#,,1)				=AHCLEAN(E7#)				=T_PF(A7#)				AHCLEAN
7	1	1	1		1				1	2	3		1	2	3
8	1	1	2		1	2			1	2	4		1	2	4
9	1	1	3		1	3			1	3	2		1	3	2
10	1	1	4		1	4			1	3	4		1	3	4
11	1	2	1		1	2			1	4	2		1	4	2
12	1	2	2		1	2			1	4	3		1	4	3
13	1	2	3		1	2	3		2	1	3		2	1	3
14	1	2	4		1	2	4		2	1	4		2	1	4
15	1	3	1		1	3			2	3	1		2	3	1
16	1	3	2		1	3	2		2	3	4		2	3	4
17	1	3	3		1	3			2	4	1		2	4	1
18	1	3	4		1	3	4		2	4	3		2	4	3
19	1	4	1		1	4			3	1	2		3	1	2
20	1	4	2		1	4	2		3	1	4		3	1	4
21	1	4	3		1	4	3		3	2	1		3	2	1
22	1	4	4		1	4			3	2	4		3	2	4
23	2	1	1		2	1			3	4	1		3	4	1
24	2	1	2		2	1			3	4	2		3	4	2
25	2	1	3		2	1	3		4	1	2		4	1	2
26	2	1	4		2	1	4		4	1	3		4	1	3
27	2	2	1		2	1			4	2	1		4	2	1
28	2	2	2		2				4	2	3		4	2	3
29	2	2	3		2	3			4	3	1		4	3	1
30	2	2	4		2	4			4	3	2		4	3	2
31	2	3	1		2	3	1
32	2	3	2		2	3
33	2	3	3		2	3
34	2	3	4		2	3	4
35	2	4	1		2	4	1
36	2	4	2		2	4
37	2	4	3		2	4	3
38	2	4	4		2	4
39	3	1	1		3	1
40	3	1	2		3	1	2
41	3	1	3		3	1
42	3	1	4		3	1	4
43	3	2	1		3	2	1
44	3	2	2		3	2
45	3	2	3		3	2
46	3	2	4		3	2	4
47	3	3	1		3	1
48	3	3	2		3	2
49	3	3	3		3
50	3	3	4		3	4
51	3	4	1		3	4	1
52	3	4	2		3	4	2
53	3	4	3		3	4
54	3	4	4		3	4
55	4	1	1		4	1
56	4	1	2		4	1	2
57	4	1	3		4	1	3
58	4	1	4		4	1
59	4	2	1		4	2	1
60	4	2	2		4	2
61	4	2	3		4	2	3
62	4	2	4		4	2
63	4	3	1		4	3	1
64	4	3	2		4	3	2
65	4	3	3		4	3
66	4	3	4		4	3
67	4	4	1		4	1
68	4	4	2		4	2
69	4	4	3		4	3
70	4	4	4		4
71
ARRG np3

Cell Formulas
Range	Formula
A6,M6,E6,I6	A6	=FORMULATEXT(A7)
A7:C70	A7	=T_PA(4,3)
E7:G70	E7	=AFUSBYROW(A7#,,1)
I7:K30	I7	=AHCLEAN(E7#)
M7:O30	M7	=T_PF(A7#)
Dynamic array formulas.

 

[Xlambda]

LAMBDA 1.2.1.xlsx
	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z
1	Task: Filter only the rows of an array that hold unique values, general use, all 3 methods T_P(a) (recursive),T_PN(a) (New lambda helper fctions),T_PF(a) (calls other Functions)
2	sample created with RANDARRAY(10,10,1,30,1)
3	sample											=AFUSBYROW(A4:J23,,1)
4	25	2	25	19	20	20	3	4	9	28		25	2	19	20	3	4	9	28
5	6	12	23	13	29	19	7	4	29	8		6	12	23	13	29	19	7	4	8
6	18	27	18	25	2	8	26	25	26	22		18	27	25	2	8	26	22
7	13	18	15	19	25	21	4	1	19	23		13	18	15	19	25	21	4	1	23
8	4	11	10	3	28	7	14	13	16	20		4	11	10	3	28	7	14	13	16	20
9	15	16	18	3	21	15	17	18	8	12		15	16	18	3	21	17	8	12
10	23	23	13	22	7	17	19	2	5	2		23	13	22	7	17	19	2	5
11	12	4	6	27	7	19	17	27	26	4		12	4	6	27	7	19	17	26
12	7	4	17	8	8	23	6	16	28	28		7	4	17	8	23	6	16	28
13	21	21	26	8	2	16	3	11	3	9		21	26	8	2	16	3	11	9
14	5	5	2	3	20	12	3	8	13	1		5	2	3	20	12	8	13	1
15	19	11	4	28	26	8	29	12	20	10		19	11	4	28	26	8	29	12	20	10
16	29	20	17	7	3	16	12	12	28	18		29	20	17	7	3	16	12	28	18
17	5	14	29	7	28	16	27	24	30	5		5	14	29	7	28	16	27	24	30
18	8	30	7	25	30	9	19	20	19	5		8	30	7	25	9	19	20	5
19	19	26	30	27	8	22	1	2	23	12		19	26	30	27	8	22	1	2	23	12
20	29	13	5	3	9	23	10	27	9	21		29	13	5	3	9	23	10	27	21
21	18	7	3	8	25	20	9	4	14	26		18	7	3	8	25	20	9	4	14	26
22	20	20	29	27	4	3	14	10	21	22		20	29	27	4	3	14	10	21	22
23	16	8	21	25	21	15	15	19	17	11		16	8	21	25	15	19	17	11
24
25	NEW lambda helper functions method											AFUSBYROW method, other Functions method
26	=T_PN(A4:J23)											=T_PF(A4:J23)
27	4	11	10	3	28	7	14	13	16	20		4	11	10	3	28	7	14	13	16	20
28	19	11	4	28	26	8	29	12	20	10		19	11	4	28	26	8	29	12	20	10
29	19	26	30	27	8	22	1	2	23	12		19	26	30	27	8	22	1	2	23	12
30	18	7	3	8	25	20	9	4	14	26		18	7	3	8	25	20	9	4	14	26
31
32	recursive method
33	=T_P(A4:J23)
34	4	11	10	3	28	7	14	13	16	20
35	19	11	4	28	26	8	29	12	20	10
36	19	26	30	27	8	22	1	2	23	12
37	18	7	3	8	25	20	9	4	14	26
38
ARRG np4

Cell Formulas
Range	Formula
L3,A33,L26,A26	L3	=FORMULATEXT(L4)
L4:U23	L4	=AFUSBYROW(A4:J23,,1)
A27:J30	A27	=T_PN(A4:J23)
L27:U30	L27	=T_PF(A4:J23)
A34:J37	A34	=T_P(A4:J23)
Dynamic array formulas.

 

[Xlambda]

Recap: Combinations
COMBINA(n,c) returns the number of combinations with repetitions for a given number of items.
COMBIN(n,c) returns the number of combinations for a given number of items (w/o repetitions).
For permutations order is important, for combinations order is not important.
If order is not important, if we choose only one type of order (ascending) and we filter by this condition any other permutations, will get the combinations indexes array.
T_CA(a) is a recursion function we created to filter only the rows of an array "a" that are in ascending order.
If we apply this to the array of permutations w repetitions will get an array of combinations w repetitions.
If we apply same function, but this time, to the array of permutations w/o repetitions, we will get an array of combinations w/o repetitions.
T_PA(n,c) = a = array of permutations w repetitions.
T_P(a)=T_P(T_PA(n,c)) = array of permutations w/o repetitions.
T_CA(T_PA(n,c)) = array of combinations w repetitions.
T_CA(T_P(a))=T_CA(T_P(T_PA(n,c))) = array of combinations w/o repetitions.
Note: If we already have the array of combinations w repetitions, let's say "b", to get array of combinations w/o repetitions we can also apply T_P(b)
In other words, T_CA(T_P(a))=T_P(T_CA(a))
T_CAN(a) will replace the recursive one using New REDUCE
T_CAF(a) will replace the recursive one with other existing Functions AFUSBYROW

LAMBDA 1.2.1.xlsx
	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T
1	Concept of T_CA(a), T_CAN(a)
2
3	T_CA(a)=LAMBDA(a,[ai ],[i ],LET(n,COLUMNS(a),j,IF(i="",1,i),aj,IF(ai="",1,ai),x,INDEX(a,,j),IF(j=n,FILTER(a,aj),T_CA(a,aj*(x<=INDEX(a,,j+1)),j+1))))
4
5	1. combinations with repetitions
6						clm 1<=clm 2		clm 2<=clm 3		clm 3<=clm 4		if we multiply all arrays			filter only rows in ascending order
7				a		=A8:A17<=B8:B17		=B8:B17<=C8:C17		=C8:C17<=D8:D17		=F8#*H8#*J8#			=FILTER(A8:D17,L8#)
8	1	1	2	3		TRUE		TRUE		TRUE		1			1	1	2	3
9	a	b	b	a		TRUE		TRUE		FALSE		0			2	2	2	2
10	c	d	c	e		TRUE		FALSE		TRUE		0			1	2	3	4
11	2	2	2	2		TRUE		TRUE		TRUE		1			a	b	c	d
12	1	2	3	4		TRUE		TRUE		TRUE		1			b	c	c	d
13	2	1	3	2		FALSE		TRUE		FALSE		0
14	3	2	1	1		FALSE		FALSE		TRUE		0			=T_CA(A8:D17)
15	a	b	c	d		TRUE		TRUE		TRUE		1			1	1	2	3
16	b	c	c	d		TRUE		TRUE		TRUE		1			2	2	2	2
17	b	a	c	d		FALSE		TRUE		TRUE		0			1	2	3	4
18															a	b	c	d
19						For i=1 to clms(a)-1 we do clm i<=clm i+1 and we multiply the results.									b	c	c	d
20						(clm 1<=clm2)*(clm 2<=clm 3)*(clm 3<=clm 4)
21						The rows that corespond to 1's values will be the rows in ascending order
22						T_CA does this recursively, T_CAN will use REDUCE
23
24	2. "combinations" w/o repetitions
25	Will have to apply same algoritm but this time , to an array that have no dups, OR, to apply T_P (keeps rows no dups) to array in T15
26
27	=T_P(A8:D17)					=T_CA(A28#)				OR	=T_P(O15#)
28	1	2	3	4		1	2	3	4		1	2	3	4
29	a	b	c	d		a	b	c	d		a	b	c	d
30	b	a	c	d
31
32	directly from "a"
33				a		=T_CA(T_P(A34:D43))				<=>	=T_P(T_CA(A34:D43))
34	1	1	2	3		1	2	3	4		1	2	3	4
35	a	b	b	a		a	b	c	d		a	b	c	d
36	c	d	c	e
37	2	2	2	2
38	1	2	3	4
39	2	1	3	2
40	3	2	1	1
41	a	b	c	d
42	b	c	c	d
43	b	a	c	d
44
ARRG np5

Cell Formulas
Range	Formula
F7,H7,J7,L7,K33,F33,K27,F27,A27,O14,O7	F7	=FORMULATEXT(F8)
F8:F17	F8	=A8:A17<=B8:B17
H8:H17	H8	=B8:B17<=C8:C17
J8:J17	J8	=C8:C17<=D8:D17
L8:L17	L8	=F8#*H8#*J8#
O8:R12	O8	=FILTER(A8:D17,L8#)
O15:R19	O15	=T_CA(A8:D17)
A28:D30	A28	=T_P(A8:D17)
F28:I29	F28	=T_CA(A28#)
K28:N29	K28	=T_P(O15#)
F34:I35	F34	=T_CA(T_P(A34:D43))
K34:N35	K34	=T_P(T_CA(A34:D43))
Dynamic array formulas.

 

[Xlambda]

T_CAN(a) Tool function calculating Combinations indexes, ( COMBINA ) using New lambda helper functions REDUCE.
If input array a=T_PA(n,c), T_CAN(a) returns combinations with repetitions indexes array of "n" by nr. chosen "c".
If input array a=T_P(T_PA(n,c)), T_CAN(a) returns combinations w/o repetitions indexes array of "n" by nr. chosen "c".

=LAMBDA(a,LET(c,COLUMNS(a),FILTER(a,REDUCE(1,SEQUENCE(c-1),LAMBDA(v,i,v*(INDEX(a,,i)<=INDEX(a,,i+1)))))))

LAMBDA 1.2.1.xlsx
	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z	AA	AB	AC	AD	AE	AF
1	T_CAN(a) , alternative of T_CA(a) (recursive) , using NEW lambda helper functions (REDUCE) - filters only rows in ascending order, order is not important
2
3	1. if a=T_PA(n,c) "prints" all PERMUTATIONA(n,c) (permutations w repetitions) , T_CAN(a)=T_CAN(T_PA(n,c)) will "print" all COMBINA(n,c) (combinations w repetitions)
4	2. if b=T_PN(a) "prints" all PERMUT(n,c) (permutations w/o repetitions) , T_CAN(b)=T_CAN(T_PN(a))=T_CAN(T_PN(T_PA(n,c))) will "print" all COMBIN(n,c) (combinations w/o repetitions)
5
6	1. combinations w repetitions
7	permutationa(4,3)				step 1 <=> for i=1 to clms(a)-1, 1*(clm i<=clm i+1)
8	n,4,c,3				=LET(a,A10#,c,COLUMNS(a),REDUCE(1,SEQUENCE(c-1),LAMBDA(v,i,v*(INDEX(a,,i)<=INDEX(a,,i+1)))))
9	=T_PA(4,3)		a		a'										check
10	1	1	1		1										=COMBINA(4,3)				2. combinations w/o repetitions								same result with recursion
11	1	1	2		1										20				b=T_PN(a)				T_CAN(b)				T_CA(b)
12	1	1	3		1										=ROWS(K17#)				=T_PN(A10#)				=T_CAN(S13#)				=T_CA(S13#)
13	1	1	4		1										20				1	2	3		1	2	3		1	2	3
14	1	2	1		0		step 2, FILTER(a,a')				step 3 single cell								1	2	4		1	2	4		1	2	4
15	1	2	2		1						NEW!! T_CAN(a)				recursive one T_CA(a)				1	3	2		1	3	4		1	3	4
16	1	2	3		1		=FILTER(A10#,E10#)				=T_CAN(A10#)				=T_CA(A10#)				1	3	4		2	3	4		2	3	4
17	1	2	4		1		1	1	1		1	1	1		1	1	1		1	4	2
18	1	3	1		0		1	1	2		1	1	2		1	1	2		1	4	3		check
19	1	3	2		0		1	1	3		1	1	3		1	1	3		2	1	3		=COMBIN(4,3)
20	1	3	3		1		1	1	4		1	1	4		1	1	4		2	1	4		4
21	1	3	4		1		1	2	2		1	2	2		1	2	2		2	3	1		=ROWS(W13#)
22	1	4	1		0		1	2	3		1	2	3		1	2	3		2	3	4		4
23	1	4	2		0		1	2	4		1	2	4		1	2	4		2	4	1
24	1	4	3		0		1	3	3		1	3	3		1	3	3		2	4	3		or directly from "a"
25	1	4	4		1		1	3	4		1	3	4		1	3	4		3	1	2		=T_CAN(T_PN(A10#))				=T_PN(T_CAN(A10#))
26	2	1	1		0		1	4	4		1	4	4		1	4	4		3	1	4		1	2	3		1	2	3
27	2	1	2		0		2	2	2		2	2	2		2	2	2		3	2	1		1	2	4		1	2	4
28	2	1	3		0		2	2	3		2	2	3		2	2	3		3	2	4		1	3	4		1	3	4
29	2	1	4		0		2	2	4		2	2	4		2	2	4		3	4	1		2	3	4		2	3	4
30	2	2	1		0		2	3	3		2	3	3		2	3	3		3	4	2
31	2	2	2		1		2	3	4		2	3	4		2	3	4		4	1	2
32	2	2	3		1		2	4	4		2	4	4		2	4	4		4	1	3
33	2	2	4		1		3	3	3		3	3	3		3	3	3		4	2	1
34	2	3	1		0		3	3	4		3	3	4		3	3	4		4	2	3
35	2	3	2		0		3	4	4		3	4	4		3	4	4		4	3	1
36	2	3	3		1		4	4	4		4	4	4		4	4	4		4	3	2
37	2	3	4		1
38	2	4	1		0
39	2	4	2		0
40	2	4	3		0
41	2	4	4		1
42	3	1	1		0
43	3	1	2		0
44	3	1	3		0
45	3	1	4		0
46	3	2	1		0
47	3	2	2		0
48	3	2	3		0
49	3	2	4		0
50	3	3	1		0
51	3	3	2		0
52	3	3	3		1
53	3	3	4		1
54	3	4	1		0
55	3	4	2		0
56	3	4	3		0
57	3	4	4		1
58	4	1	1		0
59	4	1	2		0
60	4	1	3		0
61	4	1	4		0
62	4	2	1		0
63	4	2	2		0
64	4	2	3		0
65	4	2	4		0
66	4	3	1		0
67	4	3	2		0
68	4	3	3		0
69	4	3	4		0
70	4	4	1		0
71	4	4	2		0
72	4	4	3		0
73	4	4	4		1
74
ARRG np6

Cell Formulas
Range	Formula
E8	E8	=FORMULATEXT(E10)
A9,W25,AA25,W21,W19,G16,K16,O16,W12,AA12,O12,S12,O10	A9	=FORMULATEXT(A10)
A10:C73	A10	=T_PA(4,3)
E10:E73	E10	=LET(a,A10#,c,COLUMNS(a),REDUCE(1,SEQUENCE(c-1),LAMBDA(v,i,v*(INDEX(a,,i)<=INDEX(a,,i+1)))))
O11	O11	=COMBINA(4,3)
O13	O13	=ROWS(K17#)
S13:U36	S13	=T_PN(A10#)
W13:Y16	W13	=T_CAN(S13#)
AA13:AC16	AA13	=T_CA(S13#)
G17:I36	G17	=FILTER(A10#,E10#)
K17:M36	K17	=T_CAN(A10#)
O17:Q36	O17	=T_CA(A10#)
W20	W20	=COMBIN(4,3)
W22	W22	=ROWS(W13#)
W26:Y29	W26	=T_CAN(T_PN(A10#))
AA26:AC29	AA26	=T_PN(T_CAN(A10#))
Dynamic array formulas.