2023-10-21：用go语言，一共有三个服务A、B、C，网络延时分别为a

2023-10-21：用go语言，一共有三个服务A、B、C，网络延时分别为a、b、c

并且一定有：1 <= a <= b <= c <= 10^9

但是具体的延时数字丢失了，只有单次调用的时间

一次调用不可能重复使用相同的服务，

一次调用可能使用了三个服务中的某1个、某2个或者全部3个服务

比如一个调用的时间，T = 100

100的延时可能来自以下7种情况：

a = 100，这次调用可能单独使用了A

b = 100，这次调用可能单独使用了B

c = 100，这次调用可能单独使用了C

a + b = 100，这次调用可能组合使用了A、B

a + c = 100，这次调用可能组合使用了A、C

b + c = 100，这次调用可能组合使用了B、C

a + b + c = 100，这次调用可能组合使用了A、B、C全部服务

那么可想而知，如果给的调用时间足够多，是可以猜测出a、b、c的

给定一个数组times，长度为n，并且一定有4 <= n <= 7

times[i] = s，表示i号调用用时s，而且times中一定都是正数且没有重复值。

请根据n次调用，猜测出a、b、c三元组可能的情况数。

如果任何a、b、c都无法匹配上给定的调用耗时，返回0，

测试的次数T <= 100，

也就是说，一共最多给定100个数组，每一次让你返回a、b、c三元组可能的情况数。

来自招商银行。

来自左程云。

答案2023-10-21：

为什么用讯飞星火？

这次代码生成用的讯飞星火，生成完后，要略微修改下代码才能通过。另外c代码的生成，一直有问题，索性就不管了。

之前一直用的chatgpt，但那个地址不能用了，所以用讯飞星火试水。

文心一言以及其他产品，我也试了下，java代码太多，文心一言无法转换成其他代码，都有各自的问题，所以只能放弃。

大体过程如下：

1.首先，定义一个函数，接受一个整数数组作为参数，并返回可能的情况数。

ways

times

2.在函数中，创建一个长度为7的整数数组，用于记录服务的延时情况。初始化为全0。

ways

status

3.创建一个空的map，用于存储可能的三元组情况。

ans

4.调用函数，传入、0、和作为参数。

process

times

status

ans

5.返回的长度，即为可能的情况数。

ans

6.在函数中，判断是否已经遍历完了数组，如果是，则进行下面的操作：

process

times

6.1.创建三个变量、、，用于存储可能的延时情况。

a

b

c

6.2.调用函数，获取当前数组中非零元素的个数，存储在变量中。

counts

status

count

6.3.根据的值，进行不同的情况判断：

count

6.3.1.如果为0，说明三个服务都没有使用过，根据给定的关系式计算出、、的值。

count

a

b

c

6.3.2.如果为1，说明只有一个服务被使用过，根据给定的关系式计算出、、的值。

count

a

b

c

6.3.3.如果为2，说明有两个服务被使用过，根据给定的关系式计算出、、的值。

count

a

b

c

6.3.4.如果为3，说明三个服务都被使用过，直接将数组中的值赋给、、。

count

status

a

b

c

6.4.调用函数，判断当前的、、是否满足条件，如果满足，则将其作为键存入中。

verify

a

b

c

ans

7.如果没有遍历完数组，则进行递归操作：

times

7.1.遍历数组，找到第一个为0的位置。

status

7.2.将当前遍历到的元素赋值给数组的该位置。

times

status

7.3.递归调用函数，传入更新后的数组，，作为参数。

process

status

i+1

ans

7.4.将数组的该位置重新置为0，进行下一次遍历。

status

8.在函数中，遍历数组，统计非零元素的个数，并返回该个数。

counts

status

9.在函数中，根据给定的条件，判断、、是否满足条件，如果满足则返回true，否则返回false。

verify

a

b

c

go完整代码如下：

packagemain
import"fmt"
funcways(times[]int)int{
status:=[]int{0,0,0,0,0,0,0}
ans:=make(map[string]struct{})
process(times,0,status,ans)
returnlen(ans)
}
funcprocess(times[]int,iint,status[]int,ansmap[string]struct{}){
ifi==len(times){
a,b,c:=0,0,0
count:=counts(status)
ifcount==0{
a=(status[3]+status[4]-status[5])/2
b=(status[3]+status[5]-status[4])/2
c=(status[4]+status[5]-status[3])/2
}elseifcount==1{
ifstatus[0]!=0{
a=status[0]
ifstatus[3]!=0{
b=status[3]-a
}
ifstatus[4]!=0{
c=status[4]-a
}
ifstatus[5]!=0{
ifb!=0&&c==0{
c=status[5]-b
}
ifc!=0&&b==0{
b=status[5]-c
}
}
}elseifstatus[1]!=0{
b=status[1]
ifstatus[3]!=0{
a=status[3]-b
}
ifstatus[5]!=0{
c=status[5]-b
}
ifstatus[4]!=0{
ifa!=0&&c==0{
c=status[4]-a
}
ifc!=0&&a==0{
a=status[4]-c
}
}
}else{
c=status[2]
ifstatus[4]!=0{
a=status[4]-c
}
ifstatus[5]!=0{
b=status[5]-c
}
ifstatus[3]!=0{
ifa!=0&&b==0{
b=status[3]-a
}
ifb!=0&&a==0{
a=status[3]-b
}
}
}
}elseifcount==2{
ifstatus[0]!=0{
a=status[0]
}
ifstatus[1]!=0{
b=status[1]
}
ifstatus[2]!=0{
c=status[2]
}
ifa==0{
ifstatus[3]!=0{
a=status[3]-b
}elseifstatus[4]!=0{
a=status[4]-c
}else{
a=status[6]-b-c
}
}elseifb==0{
ifstatus[3]!=0{
b=status[3]-a
}elseifstatus[5]!=0{
b=status[5]-c
}else{
b=status[6]-a-c
}
}else{
ifstatus[4]!=0{
c=status[4]-a
}elseifstatus[5]!=0{
c=status[5]-b
}else{
c=status[6]-a-b
}
}
}else{
a=status[0]
b=status[1]
c=status[2]
}
ifverify(status,a,b,c){
ans[fmt.Sprint(a)+"_"+fmt.Sprint(b)+"_"+fmt.Sprint(c)]=struct{}{}
}
}else{
forj:=0;j<7;j++{
ifstatus[j]==0{
status[j]=times[i]
process(times,i+1,status,ans)
status[j]=0
}
}
}
}
funccounts(status[]int)int{
count:=0
fori:=0;i<3;i++{
ifstatus[i]!=0{
count++
}
}
returncount
}
funcverify(status[]int,a,b,cint)bool{
ifa<=0||b<=0||c<=0||a>b||b>c{
returnfalse
}
ifstatus[0]!=0&&status[0]!=a{
returnfalse
}
ifstatus[1]!=0&&status[1]!=b{
returnfalse
}
ifstatus[2]!=0&&status[2]!=c{
returnfalse
}
ifstatus[3]!=0&&status[3]!=a+b{
returnfalse
}
ifstatus[4]!=0&&status[4]!=a+c{
returnfalse
}
ifstatus[5]!=0&&status[5]!=b+c{
returnfalse
}
ifstatus[6]!=0&&status[6]!=a+b+c{
returnfalse
}
returntrue
}
funcmain(){
times:=[]int{1,2,3,4,5,6,7}
fmt.Println(ways(times))
}

rust完整代码如下：

usestd::collections::HashSet;
fnmain(){
letstatus=[1,2,3,4,5,6,7];
letans=ways(&status);
println!("Hello,World{}",ans);
}
fnways(times:&[i32])->usize{
letmutstatus=[0;7];
letmutans=std::collections::HashSet::new();
process(times,0,&mutstatus,&mutans);
ans.len()
}
fnprocess(times:&[i32],i:usize,status:&mut[i32],ans:&mutHashSet){
ifi==times.len(){
leta=ifstatus[0]!=0{
status[0]
}else{
(status[3]+status[4]-status[5])/2
};
letb=ifstatus[1]!=0{
status[1]
}else{
(status[3]+status[5]-status[4])/2
};
letc=ifstatus[2]!=0{
status[2]
}else{
(status[4]+status[5]-status[3])/2
};
ifverify(status,a,b,c){
leta_str=a.to_string();
letb_str=b.to_string();
letc_str=c.to_string();
ans.insert(format!("{}-{}-{}",a_str,b_str,c_str));
}
}else{
forjin0..7{
ifstatus[j]==0{
status[j]=times[i];
process(times,i+1,status,ans);
status[j]=0;
}
}
}
}
fnverify(s:&[i32],a:i32,b:i32,c:i32)->bool{
ifa<=0||b<=0||c<=0||a>b||b>c{
returnfalse;
}
ifs[0]!=0&&s[0]!=a{
returnfalse;
}
ifs[1]!=0&&s[1]!=b{
returnfalse;
}
ifs[2]!=0&&s[2]!=c{
returnfalse;
}
ifs[3]!=0&&s[3]!=a+b{
returnfalse;
}
ifs[4]!=0&&s[4]!=a+c{
returnfalse;
}
ifs[5]!=0&&s[5]!=b+c{
returnfalse;
}
ifs[6]!=0&&s[6]!=a+b+c{
returnfalse;
}
true
}

c++完整代码如下：

#include
#include
#include
#include
usingnamespacestd;
boolverify(std::vectors,inta,intb,intc);
intcounts(vectorstatus);
voidprocess(vectortimes,inti,vector&status,unordered_set

&ans);
intways(vectortimes){
vectorstatus(7);
unordered_set

ans;
process(times,0,status,ans);
returnans.size();
}
voidprocess(vectortimes,inti,vector&status,unordered_set

&ans){
if(i==times.size()){
inta=0;
intb=0;
intc=0;
intcnt=counts(status);
if(cnt==0){
a=(status[3]+status[4]-status[5])/2;
b=(status[3]+status[5]-status[4])/2;
c=(status[4]+status[5]-status[3])/2;
}
elseif(cnt==1){
if(status[0]!=0){
a=status[0];
if(status[3]!=0){
b=status[3]-a;
}
if(status[4]!=0){
c=status[4]-a;
}
if(status[5]!=0){
if(b!=0&&c==0){
c=status[5]-b;
}
if(c!=0&&b==0){
b=status[5]-c;
}
}
}
elseif(status[1]!=0){
b=status[1];
if(status[3]!=0){
a=status[3]-b;
}
if(status[5]!=0){
c=status[5]-b;
}
if(status[4]!=0){
if(a!=0&&c==0){
c=status[4]-a;
}
if(c!=0&&a==0){
a=status[4]-c;
}
}
}
else{
c=status[2];
if(status[4]!=0){
a=status[4]-c;
}
if(status[5]!=0){
b=status[5]-c;
}
if(status[3]!=0){
if(a!=0&&b==0){
b=status[3]-a;
}
if(b!=0&&a==0){
a=status[3]-b;
}
}
}
}
elseif(cnt==2){
if(status[0]!=0){
a=status[0];
}
if(status[1]!=0){
b=status[1];
}
if(status[2]!=0){
c=status[2];
}
if(a==0){
if(status[3]!=0){
a=status[3]-b;
}
elseif(status[4]!=0){
a=status[4]-c;
}
else{
a=status[6]-b-c;
}
}
elseif(b==0){
if(status[3]!=0){
b=status[3]-a;
}
elseif(status[5]!=0){
b=status[5]-c;
}
else{
b=status[6]-a-c;
}
}
else{
if(status[4]!=0){
c=status[4]-a;
}
elseif(status[5]!=0){
c=status[5]-b;
}
else{
c=status[6]-a-b;
}
}
if(verify(status,a,b,c)){
ans.insert(to_string(a)+"_"+to_string(b)+"_"+to_string(c));
}
}
else{
a=status[0];
b=status[1];
c=status[2];
}
if(verify(status,a,b,c)){
ans.insert(to_string(a)+"_"+to_string(b)+"_"+to_string(c));
}
}
else{
for(intj=0;j<7;j++){
if(status[j]==0){
status[j]=times[i];
process(times,i+1,status,ans);
status[j]=0;
}
}
}
}
intcounts(vectorstatus){
intcnt=0;
for(inti=0;i<3;i++){
if(status[i]!=0){
cnt++;
}
}
returncnt;
}
boolverify(std::vectors,inta,intb,intc){
if(a<=0||b<=0||c<=0||a>b||b>c){
returnfalse;
}
if(s[0]!=0&&s[0]!=a){
returnfalse;
}
if(s[1]!=0&&s[1]!=b){
returnfalse;
}
if(s[2]!=0&&s[2]!=c){
returnfalse;
}
if(s[3]!=0&&s[3]!=a+b){
returnfalse;
}
if(s[4]!=0&&s[4]!=a+c){
returnfalse;
}
if(s[5]!=0&&s[5]!=b+c){
returnfalse;
}
if(s[6]!=0&&s[6]!=a+b+c){
returnfalse;
}
returntrue;
}
intmain(){
std::vectorstatus={1,2,3,4,5,6,7};
intans=ways(status);
std::cout<<"Hello,World"<return0;
}