有这样一个数组
string[] arr = {"a", "b", "c", "d", "e", "f", "g", "h"};要的结果是
a
b
c
d
e
f
g
ab
bc
cd
de
ef
fg
gh
abc
bcd
cde
def
efg
fgh
abcd
bcde
cdef
defg
efgh
abcde
bcdef
cdefg
defgh
abcdef
bcdefg
cdefgh
abcdefg
bcdefgh
=======================
abcdefgh 大于7字的串不要
求解
string[] arr = {"a", "b", "c", "d", "e", "f", "g", "h"};要的结果是
a
b
c
d
e
f
g
ab
bc
cd
de
ef
fg
gh
abc
bcd
cde
def
efg
fgh
abcd
bcde
cdef
defg
efgh
abcde
bcdef
cdefg
defgh
abcdef
bcdefg
cdefgh
abcdefg
bcdefgh
=======================
abcdefgh 大于7字的串不要
求解
void Main()
{
Dictionary<string, int> dic = new Dictionary<string, int>();
for (int i = 0; i < m_Data.Length; i++)
{
Console.WriteLine(m_Data[i]);//如果不需要打印单元素的组合，将此句注释掉
dic.Add(m_Data[i], i);
}
GetString(dic);
/*
a
b
c
d
e
f
g
h
ab
ac
ad
ae
af
ag
ah
bc
bd
be
bf
bg
bh
cd
ce
cf
cg
ch
de
df
dg
dh
ef
eg
eh
fg
fh
gh
abc
abd
abe
abf
abg
abh
acd
ace
acf
acg
ach
ade
adf
adg
adh
aef
aeg
aeh
afg
afh
agh
bcd
bce
bcf
bcg
bch
bde
bdf
bdg
bdh
bef
beg
beh
bfg
bfh
bgh
cde
cdf
cdg
cdh
cef
ceg
ceh
cfg
cfh
cgh
def
deg
deh
dfg
dfh
dgh
efg
efh
egh
fgh
abcd
abce
abcf
abcg
abch
abde
abdf
abdg
abdh
abef
abeg
abeh
abfg
abfh
abgh
acde
acdf
acdg
acdh
acef
aceg
aceh
acfg
acfh
acgh
adef
adeg
adeh
adfg
adfh
adgh
aefg
aefh
aegh
afgh
bcde
bcdf
bcdg
bcdh
bcef
bceg
bceh
bcfg
bcfh
bcgh
bdef
bdeg
bdeh
bdfg
bdfh
bdgh
befg
befh
begh
bfgh
cdef
cdeg
cdeh
cdfg
cdfh
cdgh
cefg
cefh
cegh
cfgh
defg
defh
degh
dfgh
efgh
abcde
abcdf
abcdg
abcdh
abcef
abceg
abceh
abcfg
abcfh
abcgh
abdef
abdeg
abdeh
abdfg
abdfh
abdgh
abefg
abefh
abegh
abfgh
acdef
acdeg
acdeh
acdfg
acdfh
acdgh
acefg
acefh
acegh
acfgh
adefg
adefh
adegh
adfgh
aefgh
bcdef
bcdeg
bcdeh
bcdfg
bcdfh
bcdgh
bcefg
bcefh
bcegh
bcfgh
bdefg
bdefh
bdegh
bdfgh
befgh
cdefg
cdefh
cdegh
cdfgh
cefgh
defgh
abcdef
abcdeg
abcdeh
abcdfg
abcdfh
abcdgh
abcefg
abcefh
abcegh
abcfgh
abdefg
abdefh
abdegh
abdfgh
abefgh
acdefg
acdefh
acdegh
acdfgh
acefgh
adefgh
bcdefg
bcdefh
bcdegh
bcdfgh
bcefgh
bdefgh
cdefgh
abcdefg
abcdefh
abcdegh
abcdfgh
abcefgh
abdefgh
acdefgh
bcdefgh */
}
static string[] m_Data = {"a", "b", "c", "d", "e", "f", "g", "h"};
static void GetString(Dictionary<string,int> dd)
{
Dictionary<string, int> dic = new Dictionary<string, int>();
foreach (KeyValuePair<string, int> kv in dd)
{
for (int i = kv.Value + 1; i < m_Data.Length; i++)
{
string temp=kv.Key + m_Data[i];
if(temp.Length<=7)
{
Console.WriteLine(temp);
dic.Add(kv.Key + m_Data[i], i);
}
}
}
if(dic.Count>0) GetString(dic);
}
比如ag跳开了中间的bcdef?
然后手里有不同大小的框,可以在盒子里滑动.透过这些框分别可以一次性看到1张~7张的牌.
框最初在最左边也就是"a"的位置.自左向右移.但框不能移超出盒子.ok.现在选取一个大小为3的框.每次向右滑动一个牌位.一直滑到结束.
整个过程中每一步框中看到的牌就是长度为3的一个结果.以此类推只要把大小为1~大小为7的框全部滑一次就能得到所要的结果.不知道lz看明白没有.暂时没时间写代码.
等有时间过来看没人回答就丢段代码
acdghi
acdghj
acdghk
acdgij
acdgik
acdgjk
acdhij
acdhik
acdhjk
acdijk
acefgh
acefgi
acefgj
acefgk
acefhi
acefhj
acefhk
acefij
acefik
acefjk
aceghi
aceghj
aceghk
acegij
acegik
acegjk
acehij
acehik
acehjk
aceijk
acfghi
acfghj
acfghk
acfgij
acfgik
acfgjk
acfhij
acfhik
acfhjk
acfijk
acghij
acghik
acghjk
acgijk
achijk
adefgh
adefgi
adefgj
adefgk
adefhi
adefhj
adefhk
adefij
adefik
adefjk
adeghi
adeghj
adeghk
adegij
adegik
adegjk
adehij
adehik
adehjk
adeijk
adfghi
adfghj
adfghk
adfgij
adfgik
adfgjk
adfhij
adfhik
adfhjk
adfijk
adghij
adghik
adghjk
adgijk
adhijk
aefghi
aefghj
aefghk
aefgij
aefgik
aefgjk
aefhij
aefhik
aefhjk
aefijk
aeghij
aeghik
aeghjk
aegijk
aehijk
afghij
afghik
afghjk
afgijk
afhijk
aghijk
bcdefg
bcdefh
bcdefi
bcdefj
bcdefk
bcdegh
bcdegi
bcdegj
bcdegk
bcdehi
bcdehj
bcdehk
bcdeij
bcdeik
bcdejk
bcdfgh
bcdfgi
bcdfgj
bcdfgk
bcdfhi
bcdfhj
bcdfhk
bcdfij
bcdfik
bcdfjk
bcdghi
bcdghj
bcdghk
bcdgij
bcdgik
bcdgjk
bcdhij
bcdhik
bcdhjk
bcdijk
bcefgh
bcefgi
bcefgj
bcefgk
bcefhi
bcefhj
bcefhk
bcefij
bcefik
bcefjk
bceghi
bceghj
bceghk
bcegij
bcegik
bcegjk
bcehij
bcehik
bcehjk
bceijk
bcfghi
bcfghj
bcfghk
bcfgij
bcfgik
bcfgjk
bcfhij
bcfhik
bcfhjk
bcfijk
bcghij
bcghik
bcghjk
bcgijk
bchijk
bdefgh
bdefgi
bdefgj
bdefgk
bdefhi
bdefhj
bdefhk
bdefij
bdefik
bdefjk
bdeghi
bdeghj
bdeghk
bdegij
bdegik
bdegjk
bdehij
bdehik
bdehjk
bdeijk
bdfghi
bdfghj
bdfghk
bdfgij
bdfgik
bdfgjk
bdfhij
bdfhik
bdfhjk
bdfijk
bdghij
bdghik
bdghjk
bdgijk
bdhijk
befghi
befghj
befghk
befgij
befgik
befgjk
befhij
befhik
befhjk
befijk
beghij
beghik
beghjk
begijk
behijk
bfghij
bfghik
bfghjk
bfgijk
bfhijk
bghijk
cdefgh
cdefgi
cdefgj
cdefgk
cdefhi
cdefhj
cdefhk
cdefij
cdefik
cdefjk
cdeghi
cdeghj
cdeghk
cdegij
cdegik
cdegjk
cdehij
cdehik
cdehjk
cdeijk
cdfghi
cdfghj
cdfghk
cdfgij
cdfgik
cdfgjk
cdfhij
cdfhik
cdfhjk
cdfijk
cdghij
cdghik
cdghjk
cdgijk
cdhijk
cefghi
cefghj
cefghk
cefgij
cefgik
cefgjk
cefhij
cefhik
cefhjk
cefijk
ceghij
ceghik
ceghjk
cegijk
cehijk
cfghij
cfghik
cfghjk
cfgijk
cfhijk
cghijk
defghi
defghj
defghk
defgij
defgik
defgjk
defhij
defhik
defhjk
defijk
deghij
deghik
deghjk
degijk
dehijk
dfghij
dfghik
dfghjk
dfgijk
dfhijk
dghijk
efghij
efghik
efghjk
efgijk
efhijk
eghijk
abcdefg
abcdefh
abcdefi
abcdefj
abcdefk
abcdegh
abcdegi
abcdegj
abcdegk
abcdehi
abcdehj
abcdehk
abcdeij
abcdeik
abcdejk
abcdfgh
abcdfgi
abcdfgj
abcdfgk
abcdfhi
abcdfhj
abcdfhk
abcdfij
abcdfik
abcdfjk
abcdghi
abcdghj
abcdghk
abcdgij
abcdgik
abcdgjk
abcdhij
abcdhik
abcdhjk
abcdijk
abcefgh
abcefgi
abcefgj
abcefgk
abcefhi
abcefhj
abcefhk
abcefij
abcefik
abcefjk
abceghi
abceghj
abceghk
abcegij
abcegik
abcegjk
abcehij
abcehik
abcehjk
abceijk
abcfghi
abcfghj
abcfghk
abcfgij
abcfgik
abcfgjk
abcfhij
abcfhik
abcfhjk
abcfijk
abcghij
abcghik
abcghjk
abcgijk
abchijk
abdefgh
abdefgi
abdefgj
abdefgk
abdefhi
abdefhj
abdefhk
abdefij
abdefik
abdefjk
abdeghi
abdeghj
abdeghk
abdegij
abdegik
abdegjk
abdehij
abdehik
abdehjk
abdeijk
abdfghi
abdfghj
abdfghk
abdfgij
abdfgik
abdfgjk
abdfhij
abdfhik
abdfhjk
abdfijk
abdghij
abdghik
abdghjk
abdgijk
abdhijk
abefghi
abefghj
abefghk
abefgij
abefgik
abefgjk
abefhij
abefhik
abefhjk
abefijk
abeghij
abeghik
abeghjk
abegijk
abehijk
abfghij
abfghik
abfghjk
abfgijk
abfhijk
abghijk
acdefgh
acdefgi
acdefgj
acdefgk
acdefhi
acdefhj
acdefhk
acdefij
acdefik
acdefjk
acdeghi
acdeghj
acdeghk
acdegij
acdegik
acdegjk
acdehij
acdehik
acdehjk
acdeijk
acdfghi
acdfghj
acdfghk
acdfgij
acdfgik
acdfgjk
acdfhij
acdfhik
acdfhjk
acdfijk
acdghij
acdghik
acdghjk
acdgijk
acdhijk
acefghi
acefghj
acefghk
acefgij
acefgik
acefgjk
acefhij
acefhik
acefhjk
acefijk
aceghij
aceghik
aceghjk
acegijk
acehijk
acfghij
acfghik
acfghjk
acfgijk
acfhijk
acghijk
adefghi
adefghj
adefghk
adefgij
adefgik
adefgjk
adefhij
adefhik
adefhjk
adefijk
adeghij
adeghik
adeghjk
adegijk
adehijk
adfghij
adfghik
adfghjk
adfgijk
adfhijk
adghijk
aefghij
aefghik
aefghjk
aefgijk
aefhijk
aeghijk
afghijk
bcdefgh
bcdefgi
bcdefgj
bcdefgk
bcdefhi
bcdefhj
bcdefhk
bcdefij
bcdefik
bcdefjk
bcdeghi
bcdeghj
bcdeghk
bcdegij
bcdegik
bcdegjk
bcdehij
bcdehik
bcdehjk
bcdeijk
bcdfghi
bcdfghj
bcdfghk
bcdfgij
bcdfgik
bcdfgjk
bcdfhij
bcdfhik
bcdfhjk
bcdfijk
bcdghij
bcdghik
bcdghjk
bcdgijk
bcdhijk
bcefghi
bcefghj
bcefghk
bcefgij
bcefgik
bcefgjk
bcefhij
bcefhik
bcefhjk
bcefijk
bceghij
bceghik
bceghjk
bcegijk
bcehijk
bcfghij
bcfghik
bcfghjk
bcfgijk
bcfhijk
bcghijk
bdefghi
bdefghj
bdefghk
bdefgij
bdefgik
bdefgjk
bdefhij
bdefhik
bdefhjk
bdefijk
bdeghij
bdeghik
bdeghjk
bdegijk
bdehijk
bdfghij
bdfghik
bdfghjk
bdfgijk
bdfhijk
bdghijk
befghij
befghik
befghjk
befgijk
befhijk
beghijk
bfghijk
cdefghi
cdefghj
cdefghk
cdefgij
cdefgik
cdefgjk
cdefhij
cdefhik
cdefhjk
cdefijk
cdeghij
cdeghik
cdeghjk
cdegijk
cdehijk
cdfghij
cdfghik
cdfghjk
cdfgijk
cdfhijk
cdghijk
cefghij
cefghik
cefghjk
cefgijk
cefhijk
ceghijk
cfghijk
defghij
defghik
defghjk
defgijk
defhijk
deghijk
dfghijk
Press any key to continue . . .
学习算法基本知识应该从哪里学起啊