复制功能
从"P"函数
>输入是G系列和P系列的两个数据集，它们是真实数据中的字符串。
X = 3,
G series
G1
G2
G3
Y = 2,
P series
P1
P2
G 系列的 X 个始终> = Y 个 P 系列。
我想将可用 P 值与 G 值的所有可能匹配项返回，除了所有相同的 P 值分配给 G。在每个组中，G 值的序列是固定的，始终为 G1、G2、G3。
预期成果之一：
1 G1 P1
1 G2 P1
1 G3 P2
---------------
2 G1 P2
2 G2 P2
2 G3 P1
---------------
3 G1 P1
3 G2 P2
3 G3 P1
---------------
4 G1 P2
4 G2 P1
4 G3 P2
---------------
5 G1 P1
5 G2 P2
5 G3 P2
---------------
6 G1 P2
6 G2 P1
6 G3 P1
正如你所看到的，对于 X = 3、Y = 2，我想要 6 或 X*Y 组的可能配对排列：
| Group 1 | Group 2 | Group 3 | Group 4 | Group 5 | Group 6 |
-----------------------------------------------------------
| G1 P1 | G1 P2 | G1 P1 | G1 P2 | G1 P1 | G1 P2 |
| G2 P1 | G2 P2 | G2 P2 | G2 P1 | G2 P2 | G2 P1 |
| G3 P2 | G3 P1 | G3 P1 | G3 P2 | G3 P2 | G3 P1 |
P 值到 G1 - G3 的模式：换句话说，需要像 112,221,121,212,122,211 这样的 P 组合。但是不需要 111、222 的 P 值。对六个组进行排序的任何方法都开放，只要列出所有排列即可。
不需要以下内容的组合，因为所有相同的 P 都分配给同一组中的 G：
1 G1 P1
1 G2 P1
1 G3 P1
-----------
2 G1 P2
2 G2 P2
2 G3 P2
我的计划：首先做两个数据集的笛卡尔乘积：
1 G1 P1
2 G1 P2
3 G2 P1
4 G2 P2
5 G3 P1
6 G3 P2
并希望创建笛卡尔乘积的组合序列以获得预期的结果，但我无法从中找到模式。
1 G1 P1
2 G2 P1
3 G3 P2
4 G1 P2
5 G2 P2
6 G3 P1
7 G1 P1
8 G2 P2
9 G3 P1
10 G1 P2
11 G2 P1
12 G3 P2
13 G1 P1
14 G2 P2
15 G3 P2
16 G1 P2
17 G2 P1
18 G3 P1
在上述情况下，当 X = 3 且 Y = 2 时，它是 3*(2^3-2( = 18 行和 6 组或 (Y^X - Y( 。
此过程创建不需要的序列：
Create or replace Procedure Permutation ( X in Number, Y in Number )
AS j Number:=1;
Begin
For k in 1 .. X
Loop
For i in 1 .. X*Y
Loop
CASE
WHEN i = 1 THEN
Insert into Table_1 ("INJECTION") values ( j );
Commit;
WHEN mod(i,2)= 0 Then
j := j + X ;
Insert into Table_1 ("INJECTION") values ( j );
Commit;
WHEN mod(i,2)<>0 then
j := j - Y ;
Insert into Table_1 ("INJECTION") values ( j );
Commit;
End CASE;
End Loop;
j := j + 1;
Commit;
End Loop;
EXCEPTION
WHEN OTHERS
THEN
null;
End;
结果：1,4,2,5,3,6,7,10,8,11,9,12,13,16,14,17,15,18
1 G1 P1 1
2 G1 P2 4
3 G2 P1 2
4 G2 P2 5
5 G3 P1 3
6 G3 P2 6
7 G1 P1 7
8 G1 P2 10
9 G2 P1 8
10 G2 P2 11
11 G3 P1 9
12 G3 P2 12
13 G1 P1 13
14 G1 P2 16
15 G2 P1 14
16 G2 P2 17
17 G3 P1 15
18 G3 P2 18
对你拥有的数字进行排序，并且正是不想要的结果：
1 G1 P1 1
3 G2 P1 2
5 G3 P1 3
2 G1 P2 4
4 G2 P2 5
6 G3 P2 6
7 G1 P1 7
9 G2 P1 8
11 G3 P1 9
8 G1 P2 10
10 G2 P2 11
12 G3 P2 12
13 G1 P1 13
15 G2 P1 14
17 G3 P1 15
14 G1 P2 16
16 G2 P2 17
18 G3 P2 18
我想知道是否有更好的方法来解决这个问题？阵 列？水平？
感谢您的投入，非常感谢。
更新：
我在考虑算法，本质上，它是关于从中选择一个 P 阵列[P1,P2,P3,..PY]成 G 阵列[G1,G2,G3...GX]
Python 3.5.2,
Create When X = 3, Y = 2, p = [1,2]
import itertools
for product in itertools.product([1,2],repeat=3):
print (product)
(1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 2, 2)
(2, 1, 1)
(2, 1, 2)
(2, 2, 1)
(2, 2, 2)
这正是我想要的结果，除了所有重复项目，(1,1,1( 和 (2,2,2(......
我建议构建一种分支树。每次添加"G"时，实际上都会向树添加一个级别。
您想要以有序方式获得的结果是通往树叶的路径，除了外部的路径(下图(。
G1 G2 G3
p1 ****************NO (p1 p1 p1)
/
p1
/
/ p2 (p1 p1 p2)
p1
p1 (p1 p2 p1)
/
p2
p2 (p1 p2 p2)
p1 (p2 p1 p1)
/
p1
/
/ p2 (p2 p1 p2)
p2
p1 (p2 p2 p1)
/
p2
p2 **************NO (p2 p2 p1)
每次添加关卡时，复制每个 P 的元组，并将每个 P 添加到相同的元组。这是一种在这样的数组(l_ttab(中构建它的方法，您可以删除第一个和最后一个元素(+每个G的交叉乘积(以满足您的需要。
类型
CREATE OR REPLACE TYPE t_list AS TABLE OF VARCHAR2(100);
CREATE OR REPLACE TYPE tt_list AS TABLE OF t_list;
复制功能cpy_node：
CREATE OR REPLACE FUNCTION cpy_node(p_list in t_list)
RETURN t_list
AS
l_tab t_list := t_list();
BEGIN
for i in 1..p_list.count loop
l_tab.extend;
l_tab(i):=p_list(i);
end loop;
RETURN l_tab;
END cpy_node;
从"P"函数cto_table的输入列表生成一个表：
CREATE OR REPLACE FUNCTION cto_table(p_sep in Varchar2, p_list IN VARCHAR2)
RETURN t_list
AS
l_string VARCHAR2(32767) := p_list || p_sep;
l_sep_index PLS_INTEGER;
l_index PLS_INTEGER := 1;
l_tab t_list := t_list();
BEGIN
LOOP
l_sep_index := INSTR(l_string, p_sep, l_index);
EXIT
WHEN l_sep_index = 0;
l_tab.EXTEND;
l_tab(l_tab.COUNT) := TRIM(SUBSTR(l_string,l_index,l_sep_index - l_index));
l_index := l_sep_index + 1;
END LOOP;
RETURN l_tab;
END cto_table;
创建*有序节点列表：
declare
l_ttab tt_list :=tt_list();
l_ttab_next tt_list :=tt_list();
l_tab_p t_list;
l_tab t_list;
p_nb_lvl pls_integer:=2;
begin
l_tab_p := cto_table(',', 'p1, p2');
-- initiate table with single nodes
for i in 1..l_tab_p.count loop
l_ttab.extend;
l_tab :=t_list();
l_tab.extend;
l_tab(l_tab.count):=l_tab_p(i);
l_ttab(l_ttab.count):=l_tab;
end loop;
-- ( p1 ) ( p2 )
for k in 1..p_nb_lvl-1 loop
l_ttab_next := tt_list();
for j in 1..l_ttab.count loop
for i in 1..l_tab_p.count loop
-- copy from current list
l_ttab_next.extend;
l_ttab_next(l_ttab_next.count):=cpy_node(l_ttab(j));
-- add node at the end
l_ttab_next(l_ttab_next.count).extend;
l_ttab_next(l_ttab_next.count)(k+1):=l_tab_p(i);
end loop;
end loop;
l_ttab := l_ttab_next;
end loop;
-- display result
for i in 1..l_ttab.count loop
for j in 1..l_ttab(i).count loop
dbms_output.put(l_ttab(i)(j)||' ');
end loop;
dbms_output.put_line(chr(13)||'--');
end loop;
-- e.g. if p_nb_lvl=2:
--(p1 p1) (p1 p2) (p2 p1) (p2 p2) (p1 p1) (p1 p2) ( p2 p1) ( p2 p2)
end;
*我并不是说上述是最佳的，因为我每次都会重新复制树，但对我来说听起来更容易。