1 2 3 4 5 6 7 8 9=158中填入合适+,-,*,或者不填，使得等式成立具体要求如下：1.输出所有可能结果2.考虑算法效率注意事项：该等式符合四则运算规则，先乘后加减这题是我自己改编的，百度上应该没有
发布下所有结果，以便校对.
* 1+2+3*4+56+78+9=1581+2+34+5*6*7-89=1581+2+34+56+7*8+9=1581+2+34+56-7+8*9=1581+2*3+4*5+6*7+89=1581+2*34+5+67+8+9=1581+23+4*5+6*7+8*9=1581+23-4+5*6*7-8*9=1581+23-4+56-7+89=1581+234-5*6-7*8+9=1581-2+3+4+56+7+89=1581-2+34+56+78-9=1581-2-34+5*6*7-8-9=1581-23*4*5-6+7*89=1581-234+56*7+8-9=1581*2+3*4+5+67+8*9=1581*2+34*5-6-7+8-9=1581*2-3+4*5+67+8*9=1581*2-3+4*56+7-8*9=1581*2-3+4*56-7*8-9=1581*2-3+45+6*7+8*9=1581*2*3*4-5+67+8*9=1581*2*34+5+6+7+8*9=1581*23+45-6+7+89=1581*23*4+56-7+8+9=1581*23*4-5+6+7*8+9=1581*23*4-5+6-7+8*9=1581*23*4-5*6+7+89=1581*234+5+6-78-9=1581*234-5-6+7-8*9=1581*234-5-6-7*8-9=15812+3*4-5+67+8*9=15812+34+5*6-7+89=15812*3+4*5+6+7+89=15812*3-4+5*6+7+89=15812*3-4-5+6*7+89=158123+4-56+78+9=158123-4-5*6+78-9=158123*4-5*67-8+9=158
该问题被发起重新开启投票
投票剩余时间：
之前被关闭原因：
该问题被发起删除投票
投票剩余时间：
距离悬赏到期还有：
参与关闭投票者：
关闭原因：
该问题已经被锁定
锁定原因：（）
保护原因：避免来自新用户不合宜或无意义的致谢、跟帖答案。
该问题已成功删除，仅对您可见，其他人不能够查看。
这个问题直接穷举的效率可以接受，但毫无疑问是有更高效率的算法的，类似于动态规划这个问题妙就秒在两点上：1. 不能加括号 2. 没有除法（所以运算结果都是整数）
这个问题有个很有趣的性质：对于任意连续的m个数字来说，怎样让这m个数字构成的结果最大？答案很简单，什么符号都不填的时候最大。证明很简单，就不详细说了。这个称为性质X。
首先考虑只有乘号的情况，设从第k位开始的m个数字，通过加乘号或不写，能组成的表达式和值的集合，记为G(k,m)比如G(1,1) = {"1"=&1}G(1,2) = {"12"=&2, "12"=&12}
G(k,m) = Union{n_(k,m), G(k,m-a) * n_(k+m-a, a)}
a = 1,...,m-1
n_(k+m-a, a)是从第k+m-a个开始连续a个数字组成的整数。
G(1,3) = Union{G(1,2) * 3, G(1,1) * 23}
= {"123" =& 6, "123" =& 36, "1*23" =& 23}用程序怎么实现相信大家都能想到。
如果单纯这么计算的话，G的量会很大，并不见得会快很多。这时候就需要用性质X剪枝了：要求最终的结果为158（或者其他某个数R）即xxxxx +/- G(k,m) +/-/* xxxxxx... = RG(k,m)中的结果当然都是正数。如果G前面的符号是+，那么整个表达式有：R = xxxxx + G(k,m) +/-/* xxxxxx... & -n_(1,k-1) + G(k,m) - n_(k+m, 10-k-m)因此必须有G(k,m) & R + n_(1,k-1) + n_(k+m, 10-k-m)除此以外的G的值不可能形成有效的表达式，可以从G里面移除。这样可以剪去很多无效的结果。G前是负号的情况同样有R = xxxxx - G(k,m) +/-/* xxxxxx... & n_(1,k-1) - G(k,m) + n_(k+m, 10-k-m)即G(k,m) & n_(1,k-1) + n_(k+m, 10-k-m) - R。因此综合起来，只需要保留满足G(k,m) & |R| + n_(1,k-1) + n_(k+m, 10-k-m)的结果即可。
记前m个数字通过添加任意符号或不填，能组成的表达式和值的集合为F(m)则F(m) = Union{G(1,m), F(m-k) + G(m-k+1, k), F(m-k) - G(m-k+1, k)}同样利用：F(m) +- xxxxxxxxxxxxxxx = R因而-n_(m+1, 10 - m) + F(m) & R & n_(m+1, 10 - m) + F(m)确定F(m)的范围在-n_(m+1, 10 - m) + R & F(m) & n_(m+1, 10 - m) + R之间利用这个条件剪枝，可以确保中间不会出现太多的可行结果。最后F(10)即为所求。参考程序（这是C#的，不知道和Java差多少）：
using Susing System.Collections.Gusing System.Lusing System.Tusing System.Text.RegularEnamespace NumberExp{
class Program
//保存乘法子表达式的表达式树：包括最后一个乘数，和指向前半部分乘法子表达式树的指针。
class MulExpPointer
public List&MulExpPointer& AppendFrom { }
//可能有多个返回同样值的不同表达式
public string AppendExp { }
//穷举所有可能的表达式
public IEnumerable&string& GetAllExpressions()
if (AppendFrom == null)
//没有前项表达式的时候，直接返回最后一个数
yield return AppendE
foreach (var item in AppendFrom)
foreach (var exp in item.GetAllExpressions())
yield return exp + AppendE
//乘号已经包括在AppendExp里面了
//计算表达式的数目
public long GetExpressionCount()
if (AppendFrom == null)
long count = 0;
foreach (var item in AppendFrom)
count += item.GetExpressionCount();
//保存完整表达式的表达式树：包括指向最后一个乘法子表达式树的指针，和指向前半部分子表达式树的指针，还有中间的符号
class ExpPointer
public List&ExpPointer& AppendFrom { }
public List&MulExpPointer& AppendExp { }
public string AppendOperator { }
public IEnumerable&string& GetAllExpressions()
if (AppendFrom == null)
foreach (var item in AppendExp)
foreach (var exp in item.GetAllExpressions())
List&string& mulexps = new List&string&();
foreach (var item in AppendExp)
mulexps.AddRange(item.GetAllExpressions());
foreach (var item in AppendFrom)
foreach (var exp in item.GetAllExpressions())
foreach (var appendexp in mulexps)
yield return exp + AppendOperator +
public long GetExpressionCount()
if (AppendFrom == null)
long count = 0;
foreach (var item in AppendExp)
count += item.GetExpressionCount();
long c1 = 0, c2 = 0;
foreach (var item in AppendExp)
c1 += item.GetExpressionCount();
foreach (var item in AppendFrom)
c2 += item.GetExpressionCount();
return c1 * c2;
//找出所有表达式的主程序
static void OutputAllResults(string digits, Int64 result)
int len = digits.L
//G[i,j]: i开始长度为j+1的字符串，不填符号或填乘号，能得到的所有结果的列表。按照结果的数值分类并排序。
var G = new SortedDictionary&Int64, List&MulExpPointer&&[len, len];
//F[i]: 字符串开头开始长度为i+1的字符串，不填符号或填+-*，能得到的所有结果的列表。按照结果的数值分类并排序。
var F = new SortedDictionary&Int64, List&ExpPointer&&[len];
//N[i,j]: i开始，长度为j+1的字符串代表的数字
var N = new Int64[len, len];
//计算N：连续数字串对应的数
for (int i = 0; i & i++)
N[i, 0] = digits[i] - '0';
for (int j = 1; j + i & j++)
N[i, j] = N[i, j - 1] * 10 + (digits[i + j] - '0');
for (int i = 0; i & i++)
//初始化G[i,0]
G[i, 0] = new SortedDictionary&long, List&MulExpPointer&&();
//只有一个字符，只有一种情况：一个乘号都不填的情况
G[i, 0].Add(N[i, 0], new List&MulExpPointer&(new MulExpPointer[] { new MulExpPointer { AppendFrom = null, AppendExp = digits.Substring(i, 1) } }));
//按长度从小到大计算
for (int j = 1; j + i & j++)
//利用特性X剪枝：考虑前后的数字，只有在符合条件的范围内才需要保留
long limit = Math.Abs(result);
if (i & 0)
limit += N[0, i - 1];
if (i + j + 1 & len)
limit += N[i + j + 1, len - i - j - 2];
G[i, j] = new SortedDictionary&long, List&MulExpPointer&&();
var currentDic = G[i, j];
//一个乘号都不添加的情况
currentDic.Add(N[i, j], new List&MulExpPointer&(new MulExpPointer[] { new MulExpPointer { AppendFrom = null, AppendExp = digits.Substring(i, j + 1) } }));
//穷举最后一个数的长度
for (int k = 0; k & k++)
//乘数已经在N里面算过了
long mul = N[i + j - k, k];
//可以通过G[i, j - k - 1] * N[i + j - k, k]来计算
foreach (var item in G[i, j - k - 1])
long v = item.Key *
//由于item.Key从小到大排序，超过之后就可以不再计算
if (v & limit)
List&MulExpPointer&
if (currentDic.TryGetValue(v, out list))
//当前表里面已经有这个结果了。添加到Dictionary对应的List里面
list.Add(new MulExpPointer() { AppendFrom = item.Value, AppendExp = @"*" + digits.Substring(i + j - k, k + 1) });
//一个新的可以算出的数，添加到Dictionary里面
currentDic.Add(v, new List&MulExpPointer&(new MulExpPointer[] { new MulExpPointer { AppendFrom = item.Value, AppendExp = @"*" + digits.Substring(i + j - k, k + 1) } }));
for (int i = 0; i & i++)
var currDic = F[i] = new SortedDictionary&long, List&ExpPointer&&();
//剪枝条件：因为后面所有的数最大不超过一个符号不加的值，如果加上这个值仍然小于，或者减去这个值仍然大于需要的结果，就可以剪枝
long floorVal =
long ceilVal =
if (i & len - 1)
floorVal -= N[i + 1, len - i - 2];
ceilVal += N[i + 1, len - i - 2];
//没有添加+或-的情况
//不允许前置负号
foreach (var g in G[0, i])
if (g.Key & ceilVal)
//超出范围剪枝
if (floorVal &= g.Key)
currDic.Add(g.Key, new List&ExpPointer&(new ExpPointer[] { new ExpPointer() { AppendFrom = null, AppendExp = g.Value } }));
//加入Dictionary。由于g不重复，这里不需要判重。
for (int j = 0; j & j++)
foreach (var f in F[i - j - 1])
if (f.Key - N[i - j, j] & ceilVal)
if (f.Key + N[i - j, j] & floorVal)
if (f.Key &= floorVal)
//剪枝条件：超过最小值之后才能减，否则越减越小了，不在范围内
foreach (var g in G[i - j, j])
long v = f.Key - g.K //F[i - j - 1] - G[i - j ,j]，在第i - j - 1个数后面加减号，可能得到的结果
if (v & floorVal)
if (v &= ceilVal)
List&ExpPointer&
if (currDic.TryGetValue(v, out list))
list.Add(new ExpPointer() { AppendFrom = f.Value, AppendOperator = "-", AppendExp = g.Value });
currDic.Add(v, new List&ExpPointer&() { new ExpPointer() { AppendFrom = f.Value, AppendOperator = "-", AppendExp = g.Value } });
if (f.Key &= ceilVal)
foreach (var g in G[i - j, j])
long v = f.Key + g.K
if (v & ceilVal)
if (v &= floorVal)
List&ExpPointer&
if (currDic.TryGetValue(v, out list))
list.Add(new ExpPointer() { AppendFrom = f.Value, AppendOperator = "+", AppendExp = g.Value });
currDic.Add(v, new List&ExpPointer&() { new ExpPointer() { AppendFrom = f.Value, AppendOperator = "+", AppendExp = g.Value } });
//需要求的结果都存在了F[len-1][result]里面。首先判断有没有合法的值，如果有，穷举所有结果。
List&ExpPointer&
if (!F[len - 1].TryGetValue(result, out exps))
Console.WriteLine("没有找到符合条件的表达式");
long count = 0;
foreach (var item in exps)
foreach (var exp in item.GetAllExpressions())
Console.WriteLine(exp);
count += item.GetExpressionCount();
Console.WriteLine("共有{0}种不同的表达式", count);
static void Main(string[] args)
string digits = Console.ReadLine();
if (!Regex.IsMatch(digits, @"^[0-9]+$"))
Console.Error.WriteLine(@"无效的数字串。");
Int64 r = Int64.Parse(Console.ReadLine());
OutputAllResults(digits, r);
运行结果：
1*23*4+56-7+8+91+2*34+5+67+8+9123*4-5*67-8+91+2+3*4+56+78+9123+4-56+78+91*23*4-5+6+7*8+91+2+34+56+7*8+91+234-5*6-7*8+91*2+34*5-6-7+8-91-234+56*7+8-91-2-34+5*6*7-8-91-2+34+56+78-9123-4-5*6+78-91*234-5-6-7*8-91*2-3+4*56-7*8-91*234+5+6-78-912*3+4*5+6+7+891*23+45-6+7+891-2+3+4+56+7+8912*3-4+5*6+7+891*23*4-5*6+7+891+23-4+56-7+8912+34+5*6-7+8912*3-4-5+6*7+891+2*3+4*5+6*7+891*2*34+5+6+7+8*91*23*4-5+6-7+8*91+2+34+56-7+8*91*2+3*4+5+67+8*91*2*3*4-5+67+8*912+3*4-5+67+8*91*2-3+4*5+67+8*91*2-3+45+6*7+8*91+23+4*5+6*7+8*91*234-5-6+7-8*91*2-3+4*56+7-8*91+23-4+5*6*7-8*91+2+34+5*6*7-891-23*4*5-6+7*89
顺便用同样的程序可以算出：456789 = 316共有3450789种不同的表达式（耗时5秒以内）
可以从分割入手
然后填写符号 例如 先分割1,2,3,4,5,6,7,8,9是一种12,3,4,5,6,7,8,9第二种123,4,5,6,7,8,9第三种...//虽然不合法 但是也算一种 1,23,4,5,6,7,8,9'''1,//虽然不合法 但是也算一种 1,2,34,5,6,7,8,91,2,345,6,7,8,9'''1,2,3456789别忘记 还有一种组合12,34,5,6,7,8,912,345,6,7,8,9'''12,3456789用此方法
分割出所有的字符串序列的组合 然后排除肯定不会..有的例如1,2,3456789序列最大数与（其他数字之和 ）的差的绝对值
如果小于 158则排除（其实还有很多方法可以判断出来
例如定个上界 超过连续一半包括一半
就可以视为不符合要求 例如或者1，234，56789）然后合格的
用符号插入
..验证是否为158
遍历所有表达式判断结果
import java.util.Spublic class StringTest {
int sum = 158;
int[] element = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int num = 1;
// 计算一个运算符号的计算结果
public void calculator(Stack&Integer& numStack, Stack&String& symbolStack) {
String symbol = symbolStack.pop();
int a = numStack.pop();
int b = numStack.pop();
b = "+".equals(symbol) ? numStack.push(a + b)
: "-".equals(symbol) ? numStack.push(b - a) : "*"
.equals(symbol) ? numStack.push(a * b) :
* 计算表达式值，逻辑为判断运算符优先级 优先级分别为： （*） & （+） = （-） 计算规则为，下一个运算符&栈顶运算符，则下个运算符入栈
* 下一个运算符&=栈顶运算符，则先取出栈顶运算符计算，计算结果重新入栈
* @param expression
public int checkValue(String expression) {
Stack&Integer& numStack = new Stack&Integer&();
// 运算符栈
Stack&String& symbolStack = new Stack&String&();
int numTmp = 0;
String peek = "";
for (int i = 0; i & expression.length(); i++) {
char c = expression.charAt(i);
if (c &= '0' && c &= '9') {
numTmp = (numTmp == 0) ? c - 48 : numTmp * 10 + c - 48;
} else {// 运算符
// 上一个数字入栈
numStack.push(numTmp);
numTmp = 0;
// 若栈顶不为空，判断运算符优先级
if (!symbolStack.empty()) {
peek = symbolStack.peek();
if ("*".equals(peek)) {
calculator(numStack, symbolStack);
if (!(c == '*') && !symbolStack.empty()) {
calculator(numStack, symbolStack);
symbolStack.push(c + "");
// 最后一个数字入栈
numStack.push(numTmp);
// 剩余的运算符计算
while (!symbolStack.empty()) {
calculator(numStack, symbolStack);
// 判断结果
int result = numStack.pop();
if (result == sum) {
System.out.println(num++ + "：" + expression + "=" + sum);
// 递归所有表达式
public void getExpression(String expression, int cursor) {
if (cursor &= element.length) {
checkValue(expression);
for (int i = 0; i & 4; i++) {
getExpression(expression
+ ((i == 0) ? "+" + element[cursor] : (i == 1) ? "-"
+ element[cursor] : (i == 2) ? "*"
+ element[cursor] : element[cursor]), cursor + 1);
public static void main(String[] args) {
StringTest stringTest = new StringTest();
stringTest.getExpression(stringTest.element[0] + "", 1);
package com.public class Main {
static String exp = "";
static String[] c = { "+", "-", "*", "" };
static IExpression expression = new IExpression(null);;
static int i = 0;
static String exp1;
static String exp2;
static String exp3;
static String exp4;
static String exp5;
static String exp6;
static String exp7;
static String exp8;
public static void main(String[] args) {
for (int j1 = 0; j1 & 4; j1++) {
exp1 = exp.substring(0, 1) + c[j1] + exp.substring(1);
for (int j2 = 0; j2 & 4; j2++) {
exp2 = exp1.substring(0, exp1.length() - 7) + c[j2]
+ exp1.substring(exp1.length() - 7, exp1.length());
for (int j3 = 0; j3 & 4; j3++) {
exp3 = exp2.substring(0, exp2.length() - 6) + c[j3]
+ exp2.substring(exp2.length() - 6, exp2.length());
for (int j4 = 0; j4 & 4; j4++) {
exp4 = exp3.substring(0, exp3.length() - 5)
+ exp3.substring(exp3.length() - 5,
exp3.length());
for (int j5 = 0; j5 & 4; j5++) {
exp5 = exp4.substring(0, exp4.length() - 4)
+ exp4.substring(exp4.length() - 4,
exp4.length());
for (int j6 = 0; j6 & 4; j6++) {
exp6 = exp5.substring(0, exp5.length() - 3)
+ exp5.substring(exp5.length() - 3,
exp5.length());
for (int j7 = 0; j7 & 4; j7++) {
exp7 = exp6.substring(0, exp6.length() - 2)
+ exp6.substring(exp6.length() - 2,
exp6.length());
for (int j8 = 0; j8 & 4; j8++) {
exp8 = exp7.substring(0,
exp7.length() - 1)
+ exp7.substring(
exp7.length() - 1,
exp7.length());
expression = new IExpression(null);
int sum = getAnswer(exp8);
// System.out.println("sum = " + sum);
//此处的158可随意更改为其他值
if (sum == 158) {
System.out.println("第" + (++i)
+ "个 exp = " + exp8);
// System.out.println("*9 == " + Anally("*9"));
// expression = new IExpression(null);
// System.out.println(" == " + Anally(""));
// expression = new IExpression(null);
// System.out.println(" == " + Anally(""));
System.exit(0);
* 解析表达式
* @param exp
public static int getAnswer(String exp2) {
char[] chars = exp2.toCharArray();
char lastChar = '0';
int num = 0;
for (char c1 : chars) {
if (c1 &= '0' && c1 &= '9') {
if (lastChar + 1 == c1) {
num = num * 10 + Integer.parseInt(c1 + "");
lastChar = c1;
expression.b =
if (expression instanceof Mul) {
expression.a.b = expression.a.b *
expression = expression.a;
switch (c1) {
expression = new Add(expression);
expression = new Sub(expression);
expression = new Mul(expression);
expression.b =
if (expression instanceof Mul) {
expression = expression.a;
expression.b = expression.b *
// 表达式解析完了，返回表达式的值
return expression.doExpression();
package com./** * 加法表达式 * @author Administrator * */public class Add extends IExpression{
public Add(IExpression a) {
// TODO Auto-generated constructor stub
public int doExpression() {
// TODO Auto-generated method stub
return a.doExpression()+b;
package com./** * 表达式的基类，不弄成抽象类是为了方便作为链表的头 * @author Administrator * */public class IExpression {
public IExpression(IExpression a) {
public int doExpression() {
package com./** * 乘 * @author Administrator * */public class Mul extends IExpression{
public Mul(IExpression a) {
public int doExpression() {
return a.doExpression()*b;
package com./** * 减法 * @author Administrator * */public class Sub extends IExpression{
public Sub(IExpression a) {
// TODO Auto-generated constructor stub
public int doExpression() {
return a.doExpression()-b;
运行结果：
第1个 exp = 1+2-3+4*56-7-8-9第2个 exp = 1+2-3*4+5*6*7+8-9第3个 exp = 1+2*3*45-6+7-8*9第4个 exp = 1+2*3*45-6-7*8-9第5个 exp = 1+23+4*5+67+89第6个 exp = 1+23+45+6*7+89第7个 exp = 1+23*4+5+6+7+89第8个 exp = 1+234+5*6+7-8*9第9个 exp = 1+234+5*6-7*8-9第10个 exp = 1+234-5+6*7-8*9第11个 exp = 1+234-5-6-7-8-9第12个 exp = 1-2+3*45+67+8-9第13个 exp = 1-2*3+45*6+7-8*9第14个 exp = 1-2*3+45*6-7*8-9第15个 exp = 1-2*3-4+5*6*7+8-9第16个 exp = 1*2+3*45-6+78-9第17个 exp = 1*2-3+45+67+89第18个 exp = 1*2-3+45*6-78+9第19个 exp = 1*23+4*56-7*8+9第20个 exp = 12+3+4*5*6+7*8+9第21个 exp = 12+3+4*5*6-7+8*9第22个 exp = 12+3*45+6+7*8-9第23个 exp = 12+34*5-6+7+8+9第24个 exp = 12-3+45*6-7-8*9第25个 exp = 123+4+5+67-8+9第26个 exp = 123-4+5-6-7+89
上面是我写的一个实现方式，效率就不知道了。基本思路是：自动根据题目生成一个表达式，然后再计算这个表达式的值，再判断是否跟想要的相等。
不是您所需，查看更多相关问题与答案
德问是一个专业的编程问答社区，请
后再提交答案
关注该问题的人
共被浏览 (5385) 次1+2+3+4+5+6+7+8+9＝多少？_百度知道
1+2+3+4+5+6+7+8+9＝多少？
1+2+3+4+5+6+7+8+9=（1+9）+（2+8）+（3+7）+（4+6）+5=10+10+10+10+5=45
来自团队：
其他类似问题
为您推荐：
其他4条回答
原式=(1+9)*9/2=45
（1+9）x9除2＝45
根据首项加尾项乘项数除二等于连续加数的和
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁当前位置：
＞＞＞观察下列各式并填空：1=1，2+3+4=9，3+4+5+6+7=，4+5+6+7+8+9+10=..
观察下列各式并填空：1=1，2+3+4=9，3+4+5+6+7=&&&&&&&，4+5+6+7+8+9+10=49，…，由此可归纳出=&&&&&&&&。
题型：填空题难度：中档来源：不详
马上分享给同学
据魔方格专家权威分析，试题“观察下列各式并填空：1=1，2+3+4=9，3+4+5+6+7=，4+5+6+7+8+9+10=..”主要考查你对&&数列求和的其他方法（倒序相加，错位相减，裂项相加等）&&等考点的理解。关于这些考点的“档案”如下：
现在没空？点击收藏，以后再看。
因为篇幅有限，只列出部分考点，详细请访问。
数列求和的其他方法（倒序相加，错位相减，裂项相加等）
数列求和的常用方法：
1.裂项相加法：数列中的项形如的形式，可以把表示为，累加时抵消中间的许多项，从而求得数列的和； 2、错位相减法：源于等比数列前n项和公式的推导，对于形如的数列，其中为等差数列，为等比数列，均可用此法； 3、倒序相加法：此方法源于等差数列前n项和公式的推导，目的在于利用与首末两项等距离的两项相加有公因式可提取，以便化简后求和。4、分组转化法：把数列的每一项分成两项，或把数列的项“集”在一块重新组合，或把整个数列分成两个部分，使其转化为等差或等比数列，这一求和方法称为分组转化法。5、公式法求和：所给数列的通项是关于n的多项式，此时求和可采用公式求和，常用的公式有：& 数列求和的方法多种多样，要视具体情形选用合适方法。 数列求和特别提醒：
（1）对通项公式含有的一类数列，在求时，要注意讨论n的奇偶性；（2）在用等比数列前n项和公式时，一定要分q=1和q≠1两种情况来讨论。
发现相似题
与“观察下列各式并填空：1=1，2+3+4=9，3+4+5+6+7=，4+5+6+7+8+9+10=..”考查相似的试题有：
432334491831272851846036432626339562整型数组处理算法（八）插入（+、-、空格）完成的等式：1 2 3 4 5 6 7 8 9=N[华为面试题] - 推酷
整型数组处理算法（八）插入（+、-、空格）完成的等式：1 2 3 4 5 6 7 8 9=N[华为面试题]
有一个未完成的等式：1&2&3&4&5&6&7&8&9=N
当给出整数N的具体值后，请你在2，3，4，5，6，7，8，9这8个数字的每一个前面，或插入运算符号“+”，或插入一个运算符号“-”，或不插入任何运算符号，使等式成立，并统计出能使等式成立的算式总数，若无解，则输出0。
例如：取N为108时，共能写出15个不同的等式，以下就是其中的二个算式：
1+23+4+56+7+8+9=108
123-45+6+7+8+9=108
输入一个数N
输出一个数，表示能使等式成立的算式总数。
#include &stdafx.h&
#include &iostream&
#include &string&
#include &fstream&
#include &sstream&
#include &stdio.h&
#define N 9
//把数字转换为字符串
string convertstrtoint(int j){
tempstream&&j;
tempstream&&i;
tempstream.clear();
tempstream.str(&&);
void init(int*a,int num){
int temp=10;
for(int i=1;i&i++)
temp=temp*10;
int garr[]={1,2,3,4,5,6,7,8,9};
int mulnumi[10];
//将数组中的数，组合成整数
int GetNumFromArr(int* b,int num)
int tempsum=0;
int tempnum=0;
for(int i=num-1;i&=0;i--)
tempnum=b[i]*mulnumi[num-i-1];
void GetExpressResult(int* arr,int num,int expectval,int curval,int* pnum,string rstr)
int temp=0;
for(int i=0;i&i++){
temp=GetNumFromArr(arr,i+1);
if(i+1==num)
if(curval==temp)
cout&&rstr&&&+&+convertstrtoint(temp)&&
(*pnum)++;
if(curval==-temp){
cout&&rstr&&&-&+convertstrtoint(temp)&&
(*pnum)++;
//cout&&rstr&&
else if(i+1&num)
GetExpressResult(arr+1+i,num-1-i,expectval,curval-temp,pnum,rstr+&+&+convertstrtoint(temp));
GetExpressResult(arr+1+i,num-1-i,expectval,curval+temp,pnum,rstr+&-&+convertstrtoint(temp));
int _tmain(int argc, _TCHAR* argv[])
init(mulnumi,10);
int res=0;//存放有多少个表达式
int *p=garr+N;
GetExpressResult(garr,N,5,5,&res,string(&&));
cout&&&total:&&&res&&
getchar();
#include &iostream&
#include &cmath&
int func (const char* str, int num);
bool calc (const char* result, int num);
void display(const char* result);
int main()
const char str[] = &&;
cout && &input num: &;
cout && &result: & && func(str, num) &&
int func(const char* str, int num)
//初始化输出数组
int len = strlen(str);
char* result = new char[len*2];
for (int i = 0; i & i++)
result[i*2] = str[i];
result[len*2-1] = '\0';
//模拟3进制的运算
char key[3] = {' ', '+', '-'};
int n = pow(3.0, len - 1);
int ret = 0;
for (int i = 0; i & i++)
//把i转换成3进制，计算每一位，转换成字符，填入字符串相应位置
int pos = len * 2 - 3; //个位数填入位置
int temp = i,
mod = temp % 3;
temp /= 3;
result[pos] = key[mod];
}while (temp & 0);
while (pos & 0)
result[pos] = key[0];
if (calc(result, num)) //计算结果并输出
bool calc(const char* result, int num)
int sum = 0, sign = 1, i = 0;
int temp = 0;
while (result[i] != '\0')
if (result[i] == ' ')
temp *= 10;
else if(result[i] == '+' || result[i] == '-')
sign = (result[i] == '+') ? 1 : -1;
temp += sign * (result[i] - '0');
if (sum == num)
display(result);
//输出结果
void display(const char* result)
for (int i = 0; i & strlen(result); i++)
if (result[i] != ' ')
cout && result[i];
#include &stdio.h&
/*返回两个数合并的情况*/
int HeBin(int arry[],int i,int j)
int num=0;
for(;i&=j;i++)
num = num*10 + arry[i];
//a为装载1~9的数组，n为当前数组所用到的数字顺序 ,g为输入的值
int Digui(int a[],int n,int g)
static int sum1=0;
for(i =i &=0;i--)
if(i != 0)
Digui(a,i-1,g-HeBin(a,i,n));
//数字合并加减的情况
Digui(a,i-1,g+HeBin(a,i,n));
if(g - HeBin(a,0,n) == 0)
printf(&%d - %d (0 , %d)\n&,g,HeBin(a,0,n),n);
//符合条件的情况时，sum1加一
return sum1;
Digui(a,n-1,g-a[i]);
//单个数字的加减的情况
Digui(a,n-1,g+a[i]);
}else if(n == 0)
if(0 == g - a[n])
//符号情况时加一
return sum1;
int main()
int a[] = {1,2,3,4,5,6,7,8,9};
while(1 != (scanf(&%d&,&goal)));
goal = Digui(a,8,goal);
printf(&%d\n&,goal);
/*---------------------------------------
函数型计算器(VC++6.0,Win32 Console)程序由 yu_hua 于设计完成
目前提供了10多个常用数学函数:
⑷开平方sqrt
⑸反正弦arcsin
⑹反余弦arccos
⑺反正切arctan
⑻常用对数lg
⑼自然对数ln
⑽ｅ指数exp
⑾乘幂函数∧
如果要求2的32次幂，可以打入2^32&回车&
如果要求30度角的正切可键入tan(Pi/6)&回车&
注意不能打入：tan(30)&Enter&
如果要求1.23弧度的正弦，有几种方法都有效：
sin(1.23)&Enter&
sin 1.23 &Enter&
如果验证正余弦的平方和公式,可打入sin(1.23)^2+cos(1.23)^2 &Enter&或sin1.23^2+cos1.23^2 &Enter&
此外两函数表达式连在一起,自动理解为相乘如：sin1.23cos0.77+cos1.23sin0.77就等价于sin(1.23)*cos(0.77)+cos(1.23)*sin(0.77)
当然你还可以依据三角变换，再用sin(1.23+0.77)也即sin2验证一下。
本计算器充分考虑了运算符的优先级因此诸如：2+3*4^2 实际上相当于：2+(3*(4*4))
另外函数名前面如果是数字,那么自动认为二者相乘.
同理，如果某数的右侧是左括号，则自动认为该数与括弧项之间隐含一乘号。
如：3sin1.2^2+5cos2.1^2 相当于3*sin2(1.2)+5*cos2(2.1)
又如：4(3-2(sqrt5-1)+ln2)+lg5 相当于4*(3-2*(√5 -1)+loge(2))+log10(5)
此外，本计算器提供了圆周率 Pi键入字母时不区分大小写,以方便使用。
----------------------------------------*/
#include &iostream&
#include &iomanip&
#include &cstdlib&
#include &cstring&
#include &cctype&
#include &cmath&
#include &stdio.h&
#include &string.h&
#include &windows.h&
const char Tab=0x9;
const int MAXLEN=16384;
char s[MAXLEN],*
int pcs=15;
double fun(double x,char op[],int *iop) {
while (op[*iop-1]&32) //本行使得函数嵌套调用时不必加括号,如 arc sin(sin(1.234)) 只需键入arc sin sin 1.234&Enter&
switch (op[*iop-1]) {
7: x=sin(x);
8: x=cos(x);
9: x=tan(x);
case 10: x=sqrt(x); (*iop)--;
case 11: x=asin(x); (*iop)--;
case 12: x=acos(x); (*iop)--;
case 13: x=atan(x); (*iop)--;
case 14: x=log10(x);(*iop)--;
case 15: x=log(x);
case 16: x=exp(x);
double calc(char *expr,char **addr) {
//递归深度
static char *fname[]={ &sin&,&cos&,&tan&,&sqrt&,&arcsin&,&arccos&,&arctan&,&lg&,&ln&,&exp&,NULL};
double ST[10]={0.0}; //数字栈
char op[10]={'+'}; //运算符栈
char c,*rexp,*pp,*
int ist=1,iop=1,last,i;
if (!deep) {
c = *pp++;
if (c!=' '&& c!=Tab)
} while (c!='\0');
if ((c=*pp)=='-'||c=='+') {
last = !DIGIT;
while ((c=*pp)!='\0') {
if (c=='(') {//左圆括弧
ST[ist++]=calc(++pp,addr);
ST[ist-1]=fun(ST[ist-1],op,&iop);
last = DIGIT;
if (*pp == '('||isalpha(*pp) && strnicmp(pp,&Pi&,2)) {//目的是：当右圆括弧的右恻为左圆括弧或函数名字时，默认其为乘法
op[iop++]='*';
last = !DIGIT;
c = op[--iop];
else if (c==')') {//右圆括弧
} else if (isalpha(c)) {
if (!strnicmp(pp,&Pi&,2)) {
if (last==DIGIT) {
cout&& &π左侧遇）& &&exit(1);
ST[ist++]=3.38328;
ST[ist-1]=fun(ST[ist-1],op,&iop);
last = DIGIT;
if (!strnicmp(pp,&Pi&,2)) {
cout&& &两个π相连& &&exit(2);
if (*pp=='(') {
cout&& &π右侧遇（& &&exit(3);
for (i=0; (pf=fname[i])!=NULL; i++)
if (!strnicmp(pp,pf,strlen(pf)))
if (pf!=NULL) {
op[iop++] = 07+i;
pp += strlen(pf);
cout&& &陌生函数名& &&exit(4);
} else if (c=='+'||c=='-'||c=='*'||c=='/'||c=='^') {
if (last != DIGIT) {
cout&& &运算符粘连& &&exit(5);
if (c=='+'||c=='-') {
cc = op[--iop];
switch (cc) {
ST[ist-1] += ST[ist];
ST[ist-1] -= ST[ist];
ST[ist-1] *= ST[ist];
ST[ist-1] /= ST[ist];
ST[ist-1] = pow(ST[ist-1],ST[ist]);
} while (iop);
op[iop++] =
} else if (c=='*'||c=='/') {
cc = op[iop-1];
if (cc=='+'||cc=='-') {
op[iop++] =
op[iop-1] =
switch (cc) {
ST[ist-1] *= ST[ist];
ST[ist-1] /= ST[ist];
ST[ist-1] = pow(ST[ist-1],ST[ist]);
cc = op[iop-1];
if (cc=='^') {
cout&& &乘幂符连用& &&exit(6);
op[iop++] =
last = !DIGIT;
if (last == DIGIT) {
cout&& &两数字粘连& &&exit(7);
ST[ist++]=strtod(pp,&rexp);
ST[ist-1]=fun(ST[ist-1],op,&iop);
if (pp == rexp) {
cout&& &非法字符& &&exit(8);
last = DIGIT;
if (*pp == '('||isalpha(*pp)) {
op[iop++]='*';
last = !DIGIT;
c = op[--iop];
if (iop&=ist) {
cout&& &表达式有误& &&exit(9);
while (iop) {
switch (op[--iop]) {
ST[ist-1] += ST[ist];
ST[ist-1] -= ST[ist];
ST[ist-1] *= ST[ist];
ST[ist-1] /= ST[ist];
ST[ist-1] = pow(ST[ist-1],ST[ist]);
return ST[0];
int main(int argc,char **argv) {
//1 2 3 4 5 6 7 8 9 ＝110 中间可以挿＋ － 或者不挿 如果1 2 不挿的话 就是12
char op[4]=& +-&;
for (g1=0;g1&3;g1++)
for (g2=0;g2&3;g2++)
for (g3=0;g3&3;g3++)
for (g4=0;g4&3;g4++)
for (g5=0;g5&3;g5++)
for (g6=0;g6&3;g6++)
for (g7=0;g7&3;g7++)
for (g8=0;g8&3;g8++) {
strcpy(s,&1 2 3 4 5 6 7 8 9&);
s[ 1]=op[g1];
s[ 3]=op[g2];
s[ 5]=op[g3];
s[ 7]=op[g4];
s[ 9]=op[g5];
s[11]=op[g6];
s[13]=op[g7];
s[15]=op[g8];
if (110.0==calc(s,&endss)) printf(&%s=110\n&,s);
if (argc&=1) {
if (GetConsoleOutputCP()!=936) system(&chcp 936&NUL&);//中文代码页
cout && &计算函数表达式的值。&&&endl&&&支持(),+,-,*,/,^,Pi,sin,cos,tan,sqrt,arcsin,arccos,arctan,lg,ln,exp&&&
while (1) {
cout && &请输入表达式：&;
if (s[0]==0)//
cout && s &&&=&;
cout && setprecision(15) && calc(s,&endss) &&
strncpy(s,argv[1],MAXLEN-1);s[MAXLEN-1]=0;
if (argc&=3) {
pcs=atoi(argv[2]);
if (pcs&0||15&pcs) pcs=15;
printf(&%.*lf\n&,pcs,calc(s,&endss));
printf(&%.15lg\n&,calc(s,&endss));
//123+4+5+67-89=110
//123+4-5-6-7-8+9=110
//123-4+5-6-7+8-9=110
//123-4-5+6+7-8-9=110
//12+34+56+7-8+9=110
//12+3+45+67-8-9=110
//12-3+4-5+6+7+89=110
//1+234-56-78+9=110
//1+2+34+5+67-8+9=110
//1-2+3+45-6+78-9=110
来源与贴子：
http://bbs.csdn.net/topics/，觉得不错，就整理出来了，没有进行验证与测试，有兴趣的朋友可以试试。
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
主题不准确
没有分页内容
图片无法显示
视频无法显示
与原文不一致