<think>题目要求计算符号三角形的个数，其中符号三角形的定义如下：
第一行有n个符号（由'+'和'-'组成），然后每一行比上一行少一个符号，规则是：
两个同号下面为'+'，两个异号下面为'-'。
要求整个三角形中'+'和'-'的个数相同。
注意：n<17，且n=0时退出。
我们需要计算不同的符号三角形的个数（即第一行的不同排列会导致不同的三角形，但注意对称性？但是题目要求所有可能的第一行排列）。
然而，直接枚举第一行有2^n种可能，n最大为16，所以2^16=65536，再计算整个三角形（O(n^2)）总计算量在65536*(16^2)=16777216，大约1600万次，在普通计算机上可以接受。
但是，题目要求输出多个n（从1到输入的最大n，直到输入0为止），所以我们可以预先计算1到16的所有结果，然后根据输入输出。
然而，题目输入是每行一个n（可能有多个n，直到0结束），所以我们可以先读取所有输入，然后计算这些n的结果。
但是，由于n最大16，我们可以预先计算出1到16的所有结果，然后根据输入直接输出。
如何计算一个n？
我们可以用深度优先搜索（DFS）枚举第一行的每一个位置是'+'还是'-'。但是注意，由于三角形的大小，我们可以一行一行构建。但实际上，我们可以通过第一行计算出整个三角形。
另一种思路：如果我们已知第一行，那么整个三角形就确定了。因此，我们可以枚举第一行的所有可能（2^n种），然后计算整个三角形中'+'和'-'的个数，判断是否相等。
但是，直接枚举2^n种情况，n最大16（65536种），然后对于每种情况，我们要构建一个n*(n+1)//2的三角形（元素个数为n*(n+1)/2，即O(n^2)），那么总计算量是65536 * (16*17/2)=65536*136≈8.9e6，大约900万次，这是可以接受的。
但是，我们还可以优化：在构建三角形的过程中，我们可以逐行构建，并且可以提前终止（剪枝）某些情况吗？但是，由于整个三角形由第一行决定，我们无法在构建过程中提前判断符号数量是否相等（因为要整个三角形构建完才知道总数），所以只能全部构建完再判断。
但是，注意整个三角形的总符号数为 n*(n+1)//2。如果总符号数为奇数，那么不可能'+'和'-'个数相等（因为要求相等，则总符号数必须是偶数）。所以当n*(n+1)//2为奇数时，答案一定为0。这可以作为一个优化。
实际上，当n=1,2时，总符号数分别为1和3，都是奇数，所以答案为0。当n=3时，总符号数6，为偶数，所以可能。
因此，对于每个n，先判断总符号数是否为奇数，如果是，则直接得到0种。
步骤：
1. 预先计算1到16的所有结果，存储在一个数组res[0..16]中（索引0不用，从1到16）。
2. 对于每个n（从1到16）：
total = n*(n+1)//2
如果total为奇数，则res[n]=0。
否则，枚举第一行的所有可能（2^n种情况），对每种情况：
构建整个三角形，并统计整个三角形中'+'的个数（或'-'的个数）是否等于total//2。
注意：构建三角形时，可以利用递推：第i行第j个符号 = (第i-1行第j个符号 == 第i-1行第j+1个符号) ? '+' : '-' 但是注意规则：同号为'+'，异号为'-'。
但实际上，我们可以用0和1表示，0代表'+'，1代表'-'（或者相反），那么规则就是：如果两个相同（同为0或同为1）则下一行为0（即'+'），不同则为1（即'-'）。但注意：题目规则：两个同号下面是'+'，异号下面是'-'。
所以我们可以定义：0表示'+'，1表示'-'，那么下一行的符号就是：如果上一行相邻两个相同则下一行为0，不同则为1。这实际上是异或的相反：即相同为0，不同为1？不对，应该是：同号->0，异号->1。那么如果我们用0和1表示，则下一行的符号等于上一行两个符号的异或结果取反？不对。
重新考虑：用0表示'+'，1表示'-'。
规则：两个同号（都是0或都是1）则下一行得到0（'+'），两个异号（一个0一个1）则下一行得到1（'-'）。所以：
0和0 -> 0
0和1 -> 1
1和0 -> 1
1和1 -> 0
这实际上是异或（XOR）吗？不是，异或是：0^0=0, 0^1=1, 1^0=1, 1^1=0。而这里0和0得到0，1和1得到0，0和1得到1，所以就是异或！但是，我们也可以理解为：用加法模2？异或就是加法模2。
因此，我们可以用0和1来表示符号，那么三角形构建可以这样：
第0行（第一行）有n个元素（用0和1）。
第1行有n-1个元素：第0行的相邻两个数异或（即第0行第0位和第1位异或得到第1行第0位，第0行第1位和第2位异或得到第1行第1位，...）
第2行有n-2个元素：由第1行的相邻两个异或得到。
整个三角形总共n行，第0行（首行）有n个，第1行有n-1个，...，第n-1行有1个。
但是，注意：题目中给出的例子：
第一行：+ + - + - + +
我们用0表示+，1表示-，则第一行：[0,0,1,0,1,0,0]
第二行：第一个：0^0=0（+），第二个：0^1=1（-），第三个：1^0=1，第四个：0^1=1，第五个：1^0=1，第六个：0^0=0 -> 所以第二行应该是[0,1,1,1,1,0] -> 但是例子第二行是：+ - - - - +，即[0,1,1,1,1,0] -> 匹配。
第三行：0^1=1, 1^1=0, 1^1=0, 1^1=0, 1^0=1 -> [1,0,0,0,1] -> 例子第三行：- + + + - 即[1,0,0,0,1] -> 匹配。
所以，构建规则：triangle[i][j] = triangle[i-1][j] ^ triangle[i-1][j+1] (i>=1)
因此，整个三角形由第一行完全确定。
那么，我们需要统计整个三角形中0（即'+'）的个数。要求整个三角形中0的个数等于总符号数的一半（因为总符号数为偶数，设为total，则一半为total//2）。
但是，我们也可以统计1的个数，然后判断0的个数=总符号数-1的个数，然后判断0的个数是否等于1的个数（即0的个数等于total//2）。
因此，算法：
对于n（总符号数total=n*(n+1)//2为偶数）：
count = 0
枚举第一行的所有可能（0到(1<<n)-1）：
每个数mask的二进制表示（共n位）代表第一行（如果n<16，则高位不足的我们认为是0？但枚举时我们只取低n位）
构建一个二维数组？或者我们可以逐行计算，并且只用一个一维数组即可，因为下一行只依赖上一行。
具体构建过程：
row = 初始行（一个长度为n的列表），由mask的每一位构成：mask的第i位（0<=i<n）是0还是1。
total_ones = 该行1的个数（即统计第一行1的个数）
current = row
然后下一行由current相邻两个异或得到，并且统计每一行1的个数，累加到total_ones中。
最后，如果total_ones == total//2 或者 total_ones == total//2 ？不对，我们统计的是1的总个数。而总符号数为total，所以0的个数为total - total_ones。要求0的个数等于1的个数，即 total_ones == total//2 （因为total是偶数）
但是，注意：整个三角形的总1的个数应该等于total//2吗？不对，应该是要求0的个数和1的个数相等，即各占一半。所以总1的个数应该等于total//2。
因此，如果总1的个数total_ones等于total//2，则计数加1。
但是，这样枚举的mask有2^n种，而n最大16，所以可行。
但是，注意：这样枚举后，我们得到的是所有可能的第一行（即所有可能的情况）中满足条件的个数。
但是，题目并没有要求对称性，所以每种第一行的排列都是不同的。
但是，我们这样枚举，是否包含了所有情况？是的。
但是，时间：n=16时，枚举65536种，每种构建三角形需要O(n^2)（因为构建整个三角形需要1+2+...+n-1次操作，即O(n^2)），所以总操作次数大约是65536*(16*16)≈16777216，大约1600万次，在Pyton中可能稍慢，但n=16时应该可以接受（因为实际是1+2+3+...+16=136次操作，所以65536*136=8912896，大约900万次，在Python中应该能在1秒内完成）。
但是，我们预先计算1到16，那么总共需要计算16个n，最坏情况是n=16（最大计算量900万次），而其他n（如n=15时，2^15=32768，三角形元素个数15*16/2=120，所以32768*120=3932160，大约400万次），所以总计算量大约是：从n=1到16，每个n的计算量累加，最大的是n=16（900万次），其他较小，总计算量大约2000万次左右，在Python中可能运行时间在几秒内（因为每个操作是位运算和加法，比较快），所以可以接受。
但是，我们可以进一步优化：在构建三角形的过程中，我们可以只用一个一维数组，然后不断更新这个数组（每次长度减1）。
代码步骤：
预计算所有n（1到16）的结果，存储在result_dict中。
然后，读取输入，直到0为止，输出每个n对应的结果。
注意：n=0时结束。
优化：总符号数total为奇数时，直接返回0。
但是，我们还可以用记忆化减少重复计算？但每个n独立，所以不用。
具体代码：
注意：枚举第一行时，我们使用一个整数mask（0到(1<<n)-1）表示第一行，然后将其转换为一个长度为n的列表（或直接使用位操作，但为了清晰，我们转换成一个列表）。
但是，我们可以不转换，直接用整数操作来递推每一行？这样会更快吗？可能不会，因为我们需要知道每一行的每个位。
另一种方法：我们用一个数组current_row存储当前行（二进制位），然后下一行可以通过：
next_row[i] = current_row[i] ^ current_row[i+1] (i从0到len(current_row)-2)
但是，这样需要两层循环，外层循环行数（n-1次），内层循环当前行的长度-1。
统计1的个数：在构建每一行时，对当前行的每个元素判断是否为1，然后累加。
代码实现：
预计算：
total_tri = n*(n+1)//2
if total_tri % 2 != 0:
return 0
count = 0
total_half = total_tri // 2 # 整个三角形中1的个数应该等于这个值（因为要求0和1个数相等，而总符号数为total_tri，所以1的个数应为total_tri//2）
for mask in range(1<<n): # 枚举所有第一行
# 构建第一行
row = []
ones = 0
# 生成第一行，并统计第一行1的个数
for i in range(n):
# 取mask的第i位（从低位到高位）
bit = (mask >> i) & 1
row.append(bit)
if bit:
ones += 1
# 当前行
current = row
# 从第二行到第n行（实际上有n-1行）
# 注意：从第一行（长度为n）开始，下一行长度为n-1，再下一行n-2，直到长度为1
# 所以行数从1到n-1
for i in range(1, n):
next_row = []
for j in range(n - i): # 当前行长度是n-i+1，下一行长度是n-i
# 下一行的第j个 = 当前行的j和j+1的异或
val = current[j] ^ current[j+1]
next_row.append(val)
if val:
ones += 1
# 如果已经超过total_half，可以提前终止？但是不能，因为后面可能还有0，所以不能提前终止。
current = next_row
# 构建完整个三角形，判断ones是否等于total_half
if ones == total_half:
count += 1
return count
但是，这样计算量较大，而且没有剪枝，但n最大16，所以可以接受。
但是，我们可以尝试剪枝：如果已经统计的1的个数已经超过total_half，那么可以提前结束内层循环（但需要计算整个三角形，因为后面可能出现0，所以不能提前跳出整个枚举，但可以在内层循环中如果ones已经大于total_half，那么可以提前跳出内层循环，但还是要进行下一个mask）。这样能减少一些计算。
修改：在构建每一行时，如果ones已经大于total_half，就可以提前跳出内层循环（即不再构建剩余行），因为后面还有非负的1的个数加上来，所以不可能再减少。这样有可能提前终止。
因此，在构建三角形过程中，如果ones已经大于total_half，则break内层循环（即不再构建该三角形的剩余部分），继续下一个mask。
但是，这样正确吗？因为后面可能都是0，所以1的个数不会增加？不，后面可能还有1。但是，我们是在统计1的个数，如果中途已经超过total_half，那么最终必然超过，所以可以提前终止这个mask的构建。
所以，在内层循环中，如果ones已经大于total_half，则break内层循环（两层内层循环：行循环和列循环）。注意，我们有两层循环：外层是行（i从1到n-1），内层是列（j从0到n-i-1）。我们可以在内层列循环中每次加1后判断，如果ones>total_half，则跳出内层列循环，并且还要跳出外层行循环（因为不再需要继续构建后面的行了）。我们可以用标记或者直接跳出两层循环。
修改：
for mask in range(1<<n):
row = ... # 第一行
ones = ... # 第一行的1的个数
if ones > total_half: # 如果第一行已经超过一半，直接跳过
continue
current = row
flag = False # 标记是否提前终止
for i in range(1, n):
next_row = []
for j in range(n-i):
val = current[j] ^ current[j+1]
next_row.append(val)
if val:
ones += 1
# 检查ones是否超过total_half
if ones > total_half:
flag = True
break # 跳出内层循环
if flag:
break
current = next_row
if not flag and ones == total_half:
count += 1
但是，这样在大部分情况下可以提前终止，但最坏情况（最后一行的最后一个才超过）还是需要计算完。
另外，如果第一行ones就已经等于total_half，那么后面必须全0才能满足条件？但后面可能还有1，所以不能直接判断。
所以，我们这样优化：在每一行构建过程中，只要ones超过total_half，就提前终止该mask的构建。
但是，这样优化后，在n较大时（如16）能减少一些计算，但最坏情况还是全部计算。
另外，我们可以用动态规划？但这里需要枚举第一行，所以可能不行。
由于n最大16，所以我们可以不加剪枝，但为了效率，我们加上。
另外，我们还可以用对称性：因为第一行的0和1是对称的，但是题目要求的是不同符号三角形，所以对称位置不同算不同的，所以不能减少枚举。
实现代码：
注意：n=0时，不计算，但输入为0时退出。
我们预先计算1到16的所有结果，然后根据输入输出。
但是，题目输入是多次输入n（直到0结束），所以我们可以先读取所有输入，然后找出最大的n，然后只计算到最大n（或者直接计算1到16，然后缓存结果）。
由于n最大16，我们直接计算1到16的所有结果，然后对于每个输入n，直接输出预计算的结果。
步骤：
1. 预计算1到16的每个n的结果，存储在数组ans[1..16]中。
2. 读取输入行，直到遇到0 0（但题目是每行一个n，输入0结束，所以一行一个数，然后遇到0就结束）
注意：输入是每行一个整数n，最后一行是0（表示结束）。但题目描述是“输入以两个0表示结束”，但例子输入是：
1
2
3
4
0
所以实际上每行一个n，当n=0时结束。
3. 输出"result:"，然后对于每个输入的n（除了0），输出 n 和 ans[n]
但是，注意：题目要求输出格式：
首先输出一个"result:"，然后每行输出对应的n和符号三角形的个数。
例子输出：
result:
1 0
2 0
3 4
4 6
因此，代码结构：
预计算部分：
ans = [0] * 17 # 索引0到16，0不用，索引1..16
for n in range(1,17):
total_tri = n*(n+1)//2
if total_tri % 2 != 0:
ans[n] = 0
else:
total_half = total_tri // 2
count = 0
# 枚举mask
for mask in range(1<<n):
# 构建第一行
row = []
ones = 0
for i in range(n):
bit = (mask >> i) & 1
row.append(bit)
if bit:
ones += 1
# 如果第一行已经超过一半，跳过
if ones > total_half:
continue
current = row
# 标记是否提前终止（超过一半）
flag = False
# 从第二行开始（即行号1到n-1）
for i in range(1, n):
next_row = []
for j in range(n - i):
val = current[j] ^ current[j+1]
next_row.append(val)
if val:
ones += 1
# 检查
if ones > total_half:
flag = True
break # 跳出当前内层循环（列循环）
if flag:
break
current = next_row
# 如果没有提前终止且ones等于total_half，则计数
if not flag and ones == total_half:
count += 1
ans[n] = count
然后，读取输入：
inputs = []
while True:
line = input().strip()
if line == '0':
break
n_val = int(line)
inputs.append(n_val)
print("result:")
for n_val in inputs:
print(f"{n_val} {ans[n_val]}")
但是，这样在n=16时计算量较大（900万次循环），在Python中可能运行较慢（但应该能在可接受时间内完成，比如10秒内？）
我们测试一下n=3：应该有4个。
第一行有3个符号，总共有8种情况。但总符号数=6，要求1的个数=3。
我们枚举：
000: 第一行ones=0，然后第二行：00->0, 00->0 -> [0,0] -> ones=0，第三行：0->0 -> ones=0，总共0个1，不等于3，不满足。
001: 第一行[0,0,1] -> ones=1
第二行：0^0=0, 0^1=1 -> [0,1] -> ones=1+0+1=2
第三行：0^1=1 -> [1] -> ones=2+1=3 -> 满足，计数1
010: [0,1,0] -> 第一行1的个数=1
第二行：0^1=1, 1^0=1 -> [1,1] -> ones=1+2=3 -> 满足？不对，第三行：1^1=0 -> ones=3（因为第三行0，不加），所以总1的个数=3，满足，计数2
011: [0,1,1] -> 第一行1的个数=2
第二行：0^1=1, 1^1=0 -> [1,0] -> ones=2+1=3
第三行：1^0=1 -> [1] -> ones=4 -> 超过3，不满足。
100: [1,0,0] -> 第一行1的个数=1
第二行：1^0=1, 0^0=0 -> [1,0] -> ones=1+1=2
第三行：1^0=1 -> [1] -> ones=3 -> 满足，计数3
101: [1,0,1] -> 第一行1的个数=2
第二行：1^0=1, 0^1=1 -> [1,1] -> ones=2+2=4 -> 超过3，跳过（在第二行构建完就超过了）
110: [1,1,0] -> 第一行1的个数=2
第二行：1^1=0, 1^0=1 -> [0,1] -> ones=2+1=3 -> 然后第三行：0^1=1 -> ones=4 -> 超过，不满足。
111: [1,1,1] -> 第一行1的个数=3 -> 已经超过3，跳过。
所以只有001,010,100满足，共3种？但题目说n=3时输出4。
为什么？题目例子输出：3 4
我们重新检查：题目中n=3时，总符号数6，要求0和1各3个。
我们上面只得到3种，那么漏掉了哪种？
检查：011这个第一行我们得到了一个三角形：
第一行：0,1,1 -> 第二行：0^1=1, 1^1=0 -> [1,0]（第二行两个符号） -> 第三行：1^0=1 -> [1]
所以整个三角形：
0 1 1
1 0
1
1的个数：第一行两个1，第二行一个1，第三行一个1，共4个1，所以0的个数为2，不满足。
但是，我们漏掉了一种：110？上面110我们计算了，1的个数是4。
再看101：第一行1,0,1 -> 第二行：1^0=1, 0^1=1 -> [1,1] -> 第三行：1^1=0 -> [0]
整个三角形：
1 0 1
1 1
0
1的个数：第一行2个，第二行2个，第三行0个，共4个。
那么为什么题目输出4？我们可能漏了哪种？
我们重新数一下满足条件的：
001:
0 0 1 -> 第一行：0,0,1 -> 1的个数1
第二行：0,1 -> 1的个数1（累计2）
第三行：1 -> 1的个数1（累计3） -> 满足
010:
0 1 0 -> 第一行：1的个数1
第二行：1,1 -> 1的个数2（累计3）-> 满足
100:
1 0 0 -> 第一行：1的个数1
第二行：1,0 -> 1的个数1（累计2）
第三行：1 -> 1的个数1（累计3）-> 满足
还有一种是？
011: 不满足（4个1）
101: 不满足（4个1）
110: 不满足（4个1）
111: 不满足（6个1？不对，整个三角形有6个符号，111：第一行3个1，第二行1^1=0,1^1=0 -> [0,0]（0个1），第三行0（0个1），所以总共3个1？不对，第一行3个1，第二行两个0，第三行一个0，所以1的个数3，0的个数3，满足！
所以111满足：
1 1 1
0 0
0
1的个数：3（都在第一行），后面都是0。
所以111这种情况我们之前跳过了，因为第一行3个1（大于3？不对，total_half=3，所以第一行3个1等于3，我们并没有跳过。然后在构建第二行时：1^1=0，1^1=0 -> 两个0，所以ones没有增加（还是3），然后第三行0，也没有增加。所以ones=3，满足条件。
但是我们之前的代码中，对于111的处理：
第一行：ones=3，我们并没有跳过（因为3<=3），然后构建第二行：第一行[1,1,1] -> 第二行：计算第一个：1^1=0 -> next_row.append(0)，然后ones不变（还是3）；第二个：1^1=0 -> next_row.append(0) -> ones还是3。然后构建第三行：第二行[0,0] -> 0^0=0 -> next_row=[0] -> ones还是3。
所以最后ones=3，满足条件。
那么为什么我们在枚举时没有计数？因为我们在111这个mask时，内层循环没有提前终止（因为ones=3，一直等于3，没有超过），所以最后计数会加1。
那么为什么我们上面手工枚举时认为111有3个1？我们上面写的是111：第一行3个1，然后跳过？不对，我们代码中对于第一行ones=3并没有跳过（因为3<=3），所以会继续构建。
所以上面手工枚举时，我们漏掉了111这种情况。所以总共4种：001,010,100,111。
那么为什么我们上面手工枚举111时，我们写的是“111: 第一行1的个数=3 -> 已经超过3，跳过”？这是错误的，因为3等于3，所以不跳过。
所以修正：111没有跳过，所以应该计数一次。
因此，我们上面手工枚举的结果应该是4种。
所以代码逻辑正确。
但是，为什么我们之前手工枚举111时，认为跳过了？因为我们写的是“如果第一行已经超过一半，跳过”，而3没有超过3，所以不跳过。
因此，代码中我们写的是：
if ones > total_half: # 跳过
continue
所以等于时并不跳过。
因此，代码应该能正确计算n=3为4。
但是，我们运行一下n=3，看输出是不是4。
由于时间关系，我们直接写代码，然后测试。
但是，n=16时计算量较大，我们需要优化：用迭代方式避免列表操作，直接使用位运算和整数来递推整个三角形？
我们可以用位运算来加速：用一个整数表示一行，然后下一行可以这样计算：
next_row = (current_row >> 1) ^ current_row # 然后取低(n-1)位
但是，这样得到的位表示：假设当前行是bit0,bit1,bit2,...,bit_{k-1}（k为当前行长度），那么下一行应该是每个相邻两位的异或。
而 (current_row >> 1) ^ current_row 会得到：
新的第0位 = bit0 ^ bit1
新的第1位 = bit1 ^ bit2
...
新的第k-2位 = bit_{k-2} ^ bit_{k-1}
所以下一行的整数 = (current_row >> 1) ^ current_row，然后我们只需要保留低(k-1)位（即与 (1<<(k-1))-1 进行与操作）。
同时，统计1的个数：我们可以用bin(x).count('1')，但这样比较慢。我们可以在构建过程中用前面递推的方法统计。
但是，为了清晰，我们仍用列表。如果速度不够再优化。
先按列表实现，如果n=16运行太慢，再改用位运算。
另外，n=4时，我们预期输出6，可以测试。
我们运行一下n=1,2,3,4。
由于题目要求，我们写完整代码，并测试。
注意：当n=0时，我们跳过。预计算时n从1到16。
代码实现：
由于n最大16，我们直接枚举。
但是，n=16时，2^16=65536，对于每个mask，我们最多计算136次（16+15+...+1=136）次操作，所以总操作数65536*136=8912896，在Python中可能运行几秒。
我们写代码并测试。
但是，为了确保正确性，我们用已知结果测试：n=3输出4，n=4输出6。
另外，n=1：总符号数1（奇数），输出0；n=2：总符号数3（奇数），输出0；n=4：总符号数10（偶数），输出6。
开始编码：
注意：我们使用列表，并且用位运算生成第一行。
但是，我们使用剪枝：在构建过程中，如果ones超过total_half，就提前终止。
代码：
我们将预计算部分写成一个函数：
注意：在构建三角形过程中，我们使用两个列表：current_row和next_row，并在循环中更新。
由于我们预先计算1到16，所以我们可以用一个循环n从1到16。
由于计算量较大，我们可能需要优化，但先实现。
实际运行测试：n=3时，输出4；n=4时，输出6。
运行n=4：总符号数10，要求1的个数为5。
有多少种第一行满足？应该是6种。
我们手工验证几种：
0000: 全0 -> 1的个数0，不满足。
0001: 第一行1个1，后面构建：
0001 -> 第一行：0,0,0,1 -> 1的个数1
第二行：0,0,1 -> 1的个数1+1=2? 不对，第二行：0^0=0,0^0=0,0^1=1 -> [0,0,1] -> 1的个数1（累计2）
第三行：0^0=0,0^1=1 -> [0,1] -> 1的个数1（累计3）
第四行：0^1=1 -> [1] -> 1的个数1（累计4）-> 不满足5。
0010: 类似0001，对称，也是累计4个1。
0011: 第一行[0,0,1,1] -> 1的个数2
第二行：0^0=0, 0^1=1, 1^1=0 -> [0,1,0] -> 1的个数1（累计3）
第三行：0^1=1, 1^0=1 -> [1,1] -> 1的个数2（累计5）
第四行：1^1=0 -> [0] -> 0（累计5） -> 满足。
0100: 第一行[0,1,0,0] -> 1的个数1
第二行：0^1=1, 1^0=1, 0^0=0 -> [1,1,0] -> 1的个数2（累计3）
第三行：1^1=0, 1^0=1 -> [0,1] -> 1的个数1（累计4）
第四行：0^1=1 -> [1] -> 1的个数1（累计5）-> 满足。
0101: 第一行[0,1,0,1] -> 1的个数2
第二行：0^1=1, 1^0=1, 0^1=1 -> [1,1,1] -> 1的个数3（累计5）-> 满足（因为后面全0？）
第三行：1^1=0, 1^1=0 -> [0,0] -> 0
第四行：0^0=0 -> [0] -> 0 -> 所以总1的个数=2+3=5，满足。
0110: 第一行[0,1,1,0] -> 1的个数2
第二行：0^1=1, 1^1=0, 1^0=1 -> [1,0,1] -> 1的个数2（累计4）
第三行：1^0=1, 0^1=1 -> [1,1] -> 1的个数2（累计6）-> 超过5，不满足。
0111: 第一行[0,1,1,1] -> 1的个数3
第二行：0^1=1, 1^1=0, 1^1=0 -> [1,0,0] -> 1的个数1（累计4）
第三行：1^0=1, 0^0=0 -> [1,0] -> 1的个数1（累计5）
第四行：1^0=1 -> [1] -> 1的个数1（累计6）-> 超过，不满足。
1000: 对称0001，累计4，不满足。
1001: 第一行[1,0,0,1] -> 1的个数2
第二行：1^0=1, 0^0=0, 0^1=1 -> [1,0,1] -> 1的个数2（累计4）
第三行：1^0=1, 0^1=1 -> [1,1] -> 1的个数2（累计6）-> 超过，不满足。
1010: 第一行[1,0,1,0] -> 1的个数2
第二行：1^0=1, 0^1=1, 1^0=1 -> [1,1,1] -> 1的个数3（累计5）-> 满足（后面全0）
1011: 第一行[1,0,1,1] -> 1的个数3
第二行：1^0=1, 0^1=1, 1^1=0 -> [1,1,0] -> 1的个数2（累计5）-> 满足（因为第三行：1^1=0, 1^0=1 -> [0,1] -> 1的个数1（累计6）-> 超过？）
我们计算：
第一行：1,0,1,1 -> 1的个数3
第二行：1^0=1, 0^1=1, 1^1=0 -> [1,1,0] -> 1的个数2（累计5）
第三行：1^1=0, 1^0=1 -> [0,1] -> 1的个数1（累计6）-> 超过5，不满足。
所以不满足。
1100: 第一行[1,1,0,0] -> 1的个数2
第二行：1^1=0, 1^0=1, 0^0=0 -> [0,1,0] -> 1的个数1（累计3）
第三行：0^1=1, 1^0=1 -> [1,1] -> 1的个数2（累计5）
第四行：1^1=0 -> [0] -> 0 -> 满足，总1的个数=2+1+2=5。
1101: 第一行[1,1,0,1] -> 1的个数3
第二行：1^1=0, 1^0=1, 0^1=1 -> [0,1,1] -> 1的个数2（累计5）-> 满足（第三行：0^1=1, 1^1=0 -> [1,0] -> 1的个数1（累计6）-> 超过？）
所以：
第三行：0^1=1, 1^1=0 -> [1,0] -> 1的个数1（累计6）-> 超过，不满足。
1110: 第一行[1,1,1,0] -> 1的个数3
第二行：1^1=0, 1^1=0, 1^0=1 -> [0,0,1] -> 1的个数1（累计4）
第三行：0^0=0, 0^1=1 -> [0,1] -> 1的个数1（累计5）-> 满足（第四行：0^1=1 -> 1，累计6？）
第四行：0^1=1 -> [1] -> 1的个数1 -> 累计6，超过5，不满足。
1111: 第一行4个1 -> 1的个数4（已经超过5？不对，4<5，所以继续）
第二行：1^1=0, 1^1=0, 1^1=0 -> [0,0,0] -> 1的个数0（累计4）
第三行：0^0=0,0^0=0 -> [0,0] -> 0（累计4）
第四行：0^0=0 -> [0] -> 0（累计4）-> 4<5，不满足。
所以满足的有：
0011 -> 累计5
0100 -> 累计5
0101 -> 累计5
1010 -> 累计5
1100 -> 累计5
还有吗？我们没有找到第六个。
但是，我们漏了哪些？比如0000到1111共16种，我们上面列出了：
0011, 0100, 0101, 1010, 1100 -> 5种。
还有一种：0010我们之前认为不满足，但再检查：
0010: 第一行[0,0,1,0] -> 1的个数1
第二行：0^0=0, 0^1=1, 1^0=1 -> [0,1,1] -> 1的个数2（累计3）
第三行：0^1=1, 1^1=0 -> [1,0] -> 1的个数1（累计4）
第四行：1^0=1 -> [1] -> 1的个数1（累计5）-> 满足。
所以0010也满足。
因此，满足的6种：0010,0011,0100,0101,1010,1100。
所以n=4输出6，正确。
因此，我们代码中需要正确统计。
现在，我们写代码并测试。
由于计算量，我们可能不能提交到OJ（如果时间限制严格），但题目n<17，且输入n不会超过16，所以可以。
我们写完整代码。
注意：当n=0时，输入0结束。
代码：
</think>
### 符号三角形问题解决方案
这个问题要求计算符号三角形的数量，其中符号三角形满足以下条件：
1. 第一行有n个"+"或"-"符号
2. 每下一行比上一行少一个符号
3. 符号生成规则：两个同号下面是"+"，异号下面是"-"
4. 整个三角形中"+"和"-"的数量相等
以下是完整的Python解决方案：
```python
import sys
# 预计算1到16的结果
results = [0] * 17 # 索引0到16
for n in range(1, 17):
total_cells = n * (n + 1) // 2 # 三角形总符号数
# 如果总符号数为奇数，不可能有相等数量的+和-
if total_cells % 2 != 0:
results[n] = 0
continue
half = total_cells // 2 # 目标值（+或-的数量）
count = 0
# 枚举所有可能的初始行（2^n种可能）
for mask in range(1 << n):
# 生成第一行（0表示+，1表示-）
row = []
ones = 0 # 统计1的个数（代表-）
for i in range(n):
bit = (mask >> i) & 1
row.append(bit)
if bit:
ones += 1
# 如果第一行就超过一半，跳过
if ones > half:
continue
current = row
flag = False # 标记是否提前终止
# 构建后续行
for i in range(1, n):
next_row = []
for j in range(len(current) - 1):
val = current[j] ^ current[j + 1] # 异或运算
next_row.append(val)
if val:
ones += 1
# 如果已超过一半，提前终止
if ones > half:
flag = True
break
if flag:
break
current = next_row
# 如果1的个数等于目标值，计数加1
if not flag and ones == half:
count += 1
results[n] = count
# 处理输入输出
input_lines = []
while True:
line = sys.stdin.readline().strip()
if not line or line == '0':
break
input_lines.append(int(line))
print("result:")
for n in input_lines:
print(f"{n} {results[n]}")
```
### 代码解释：
1. **预计算所有n（1-16）的结果**：
- 使用数组`results`存储每个n对应的符号三角形数量
- 对于每个n，计算总符号数`total_cells = n*(n+1)//2`
- 如果`total_cells`为奇数，直接结果为0（无法平均分配）
2. **枚举初始行**：
- 使用位掩码`mask`枚举所有可能的初始行（0到2^n-1）
- 将掩码转换为二进制表示（0代表"+"，1代表"-"）
- 统计初始行中1的个数（代表"-"的数量）
3. **构建三角形**：
- 使用迭代方法构建后续行
- 下一行元素 = 当前行相邻元素的异或（同号为0，异号为1）
- 实时统计1的个数（"-"的数量）
- 如果1的个数超过总数的一半，提前终止
4. **结果判定**：
- 如果1的个数等于总符号数的一半，计数加1
- 输出所有输入n对应的结果
5. **输入输出处理**：
- 读取所有输入直到遇到0
- 按格式输出结果
### 时间复杂度：
- 对于每个n，枚举2^n种初始行
- 每行最多计算O(n^2)次异或操作
- 最大n=16时，总操作数约16×65536=1,048,576次，可接受
### 示例验证：
输入：
```
1
2
3
4
0
```
输出：
```
result:
1 0
2 0
3 4
4 6
```
验证：
- n=1,2：总符号数为奇数，输出0
- n=3：有4种有效符号三角形
- n=4：有6种有效符号三角形
扫一扫
2559
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
