求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）

最新推荐文章于 2022-05-02 09:20:44 发布
原创 最新推荐文章于 2022-05-02 09:20:44 发布 · 2.9k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一个使用C++实现的递归求和方法，通过&&逻辑运算符来控制递归过程，当条件为假时停止递归调用。此算法展示了如何利用递归解决数学中的序列求和问题。 
class Solution {
public:
    int Sum_Solution(int n) {
       int ans = n;
        ans && (ans += Sum_Solution(n - 1));
        return ans;
    }
};
分析：&& 运算，当前面为假时，后面自动不算。
【012】求 1+ 2 + 3 + . . . +n的和，要求不能使用乘除法、for、while、if、else、switch和case等关键字以及判断语句
Postgres 数据库内核开发工程师
12-20 199
文章目录1. 题目2. 思路3. 代码实现 1. 题目 求1 + 2 + 3 + ... +n的和，它通常是作为初学者的一个练习示例；如果使用for、while等循环或乘除法去实现，则较为简单。例如使用循环： /// 使用循环实现 int i = 1; int sum = 0; for(; i <= 100; i++) { sum += i; } 除了采用循环的方式外，我们还可以采用高斯公式来计算（借助乘除法）。如下： sum = (1 + n) * n /2; 而现在要求是不采用乘除法和循环。
求1+2+3+...+n，要求不能使用乘除法，for,while，if,else,switch,case等关键字以及条件判断语句
cxllyg的专栏
05-19 8696
方法一：利用构造函数和静态数据成员 #include using namespace std; class Temp { public: Temp() { ++N; Sum+=N; } static void Reset() { N=0; Sum=0; } static int GetSum() { return
求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。(c++)(剑指offer)
ambiguous__的博客
06-25 4203
求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。 这里很明显让你用递归函数进行编写，代码如下： class Solution { public: int Sum_Solution(int n) { if(n==1) { return 1; } else { return n+
Java求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句
luzhensmart的专栏
07-15 759
题目描述 求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。 public class Solution { /** * * 解题思路： * 1.需利用逻辑与的短路特性实现递归终止。 * 2.当n==0时，(n>0)&&((sum+=Sum_Solution(n-1))>0)只执行前面的判断，为false，然后直接返回0；.
求解1+2+3+...+n,要求不能使用乘除法、while、for、if 、else、switch、case等关键字
深海一诺
07-14 7534
方法一：利用递归以及&&的短路原理int Sum(int num, int& sum) { num&&Sum(num-1,sum);//递归跳出条件，当num为假时,无需判断后序语句，返回sum+=n return sum +=num; } int main() { int num= 0; int sum = 0; cin>>num; cout <<
【OJ - 基础数学】求1+2+3+...+n（不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句）
codewinter的博客
05-02 1949
文章目录OJ - 求1+2+3+...+n解题思路 OJ - 求1+2+3+…+n 题目难度：中等 OJ链接：求1+2+3+…+n__牛客网 (nowcoder.com) 题目描述： 求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。 数据范围： 0 < n ≤ 200 进阶： 空间复杂度 O(1)，时间复杂度 O(n) 示例1： 输入：5 返回值：15 示例2： 输入：1 返回值：1 解题思路 不能
计算1+2+3+...+n;不许用乘除法和if、 while、switch、for等关键字计算《三种方法！》
qq_43519310的博客
10-28 665
题目描述 求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。 题目思路 思路1：递归+短路，当当前栈的入参n为0时，短路后面的递归语句，就可以达到终止递归的效果； 思路2（Java实现）：利用异常机制，当当前栈的入参n为0时，制造异常使程序不走递归函数，catch块返回0即可； 思路3（C++实现）：利用boo...
求1+2+3+...+n要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）
TONGtongTONG000的博客
08-20 257
思想： ①通常我们可以通过循环的方法创造出1~n的每个数字，再累加就可以，因为不能使用循环，所以需要先创建出1到n的所有数字，通过构造函数的特性，每创建一个对象就要调用一次构造函数，在构造函数中记录构造函数调用的次数，再用一个值进行加法。 ②通过&&运算符，代替循环的方式给出递归出口。 ① class Sum{ public: Sum(){ _count++; _sum+=_count; } Sum(const Sum& s){
求 1+2+...+n ，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
qq79872135的博客
12-09 301
研究了半天，终于看懂大佬的位运算思路了 这个思路不但没用if这种条件判断语句，连逻辑运算中的短路运算也没有用到，也就是连判断的语义也没用到，确实挺牛的，还好这个题限制了n的大小，即限制了n二进制的位数，不然得累加32次……我在代码里为了可读性用临时变量保存了每一位的累加求解，当然一个return也是没问题的。 代码 class Solution { /** * 负数在参与位运算时使用的是补码 * -1的原码是 10000000 00000000 00000000 0...
C语言奇思妙想：求1+2+…+n，要求不能使用乘除法、for、while、if、else、switch、case 等关键字以及条件判断语句（A?B:C）
勤能补拙
09-20 5871
来源：据说是某一年某个公司的面试题 题目：求1+2+…+n， 要求不能使用乘除法、for、while、if、else、s witch、case 等关键字以及条件判断语句（A?B:C）   分析：这题本来很简单，但是不能用循环和条件判断语句。但是理论上所有的递归都可以转化为循环，那是否可以用递归代替循环呢？照着这个思路走下去，貌似可以。可是用递归的话，递归怎么终止呢？这就得在return语句
求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
m0_46613023的博客
02-13 223
题目 求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。 解答： 利用内部类的性质：内部类就是外部类的友元类。 class Solution { public: // 内部类 class Sum { public: // 构造函数 Sum() { // 内部类直接访问外部类的私有成员 _sum
求1+2+3+...+n,要求不能使用乘,除，for ,while,if ,else ,switch,case
daa20的专栏
01-15 521
/* 求1+2+3+...+n,要求不能使用乘,除，for ,while,if ,else ,switch,case */ #include /* run this program using the console pauser or add your own getch, system("pause") or input loop */ using namespace std; /*--
*求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C)**
抹茶饼的博客
07-24 328
求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C) Way1 Java 方法 考虑使用&& 逻辑与运算 运行时间：13ms 占用内存：9312k boolean t=(n>0)&&(sum+=Sum_Solution(n-1))>0;//Java 声明boobean数...
求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case
zhou15755387780的博客
02-23 1664
/* * 求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case * 等关键字及条件判断语句（A?B:C）。 * 思路：等差数列求和公式：n*(n+1)/2=(n^2+n)/2,由于不能用除法,因此可以右移一位表示除以2 */ public class Sum_Solution { public int sum_Solution(int
求 1+ 2+...+你，要求不能使用for、while、if、else、switch、case等关键字及条件判断语句(A?B:C)。使用go语言编写代码
最新发布
08-09
<think>题目要求用Go语言实现1+2+...+n的求和，但不能使用for、while、if、else、switch、case等关键字以及条件判断语句（如三元运算符）。参考引用中提供了几种思路，我们可以借鉴其中一些方法。 引用[2]和[5]中使用了C++的类，利用构造函数的调用来进行累加。在Go语言中，虽然没有类的概念，但是我们可以利用结构体和闭包的特性，以及递归来实现。但是递归需要终止条件，而终止条件通常需要if，但我们可以用其他方式模拟终止条件。 引用[1]、[3]、[4]中提到了使用递归和短路求值来避免if等条件判断。在Go语言中，我们可以使用`&&`运算符的短路特性来实现递归的终止。具体思路是：当n>0时，递归调用函数并累加，当n==0时，利用短路特性不再递归。 另外，引用[3]中还提到了一种利用数组大小计算的方法（通过构造一个二维数组，然后计算其内存大小，再通过移位得到求和结果），但这种方法在Go中可能不太适用，因为Go的数组大小必须是编译期常量（除非用切片，但切片的大小在运行时确定，且计算内存大小的方法也不直接等同于求和公式）。 因此，我们选择递归和短路求值的方法。具体步骤如下： 1. 定义一个递归函数，该函数将当前n的值与递归调用的结果相加返回。 2. 递归终止条件：当n等于0时，返回0。但是我们不能使用if，所以我们可以使用逻辑与运算的短路特性：当n>0时，我们才进行递归调用，否则就不递归。 我们可以这样设计： 当n>0时，表达式`n>0 && (sum += Sum_Solution(n-1))`中的`n>0`为真，所以会执行后面的递归调用，并将结果加到当前n上（注意：这里需要返回n加上递归结果的和）。 但是，这个表达式不能直接作为返回值，因为Go中不能在一个表达式中同时进行赋值和返回，而且我们还需要处理当n<=0的情况。 实际上，我们可以这样写： result := n>0 && func() bool { ... }() 但是，我们需要返回一个整数，所以我们可以用一个变量来保存结果，然后通过闭包和匿名函数来修改这个变量。 然而，更简洁的方法是使用递归函数本身，通过逻辑与的短路特性来避免递归调用。参考引用[4]的C++代码： n != 1 && (n += Sum_Solution(n - 1)); 在Go中，我们可以写成： if n > 0 { return n + Sum_Solution(n-1) } 但是题目不允许使用if，所以我们用短路特性来模拟： var f func(int) int f = func(n int) int { // 我们希望当n>0时，执行递归，否则返回0 // 使用一个辅助变量，利用&&的短路特性 // 当n==0时，我们直接返回0，但不用if，我们可以这样： // 如果n==0，我们就不执行后面的递归，直接返回0？但是如何返回0呢？我们可以通过一个变量来存储结果。 // 这里我们用一个技巧：定义一个匿名函数，利用它来设置返回值，但这样可能不够直接。 // 另一种方法：我们让递归函数返回两个值：结果和一个bool表示是否继续。但这样改变了函数签名。 // 参考引用[3]中的思路1：使用&&短路 // 在C++中：boolean flag=((n!=0)&&(n+=Sum_Solution(n-1))!=0); return n; // 在Go中，我们可以这样： _ = n>0 && func() bool { // 这里需要修改n的值，但是不能直接修改，因为n是值传递，而且我们无法通过闭包修改外层函数的局部变量（除非通过指针或闭包捕获的变量是引用类型） // 所以我们需要改变思路：不修改n，而是将递归结果加上n作为返回值，但如何返回呢？ // 实际上，我们可以不用修改n，而是通过返回值来传递。所以上面的C++代码在Go中不能直接照搬。 } // 重新思考：我们可以让递归函数返回一个整数，然后通过短路特性来决定是否进行递归计算。 // 更简单的做法： // if n == 0 { return 0 } // return n + f(n-1) // 但不用if，我们可以： // return n + (func() int { if n>0 { return f(n-1) } else { return 0 } })() // 但是这里面又包含了if。 // 因此，我们使用短路特性来替代if，在递归调用前判断n>1（或者n>0）： // f(n) = n + f(n-1) 当n>0时 // f(0)=0 // 在Go中，我们可以这样写递归函数： // var res int // var ok bool // if n > 0 { // res = n + f(n-1) // ok = true // } else { // res = 0 // ok = false // } // return res // 不用if，我们可以用&&和||来模拟。参考以下方法： // 方法：使用&&的短路特性 // f(n) = (n>0) && (f(n-1) + n) // 但是这样返回的是bool，我们需要整数 // 所以我们需要一个整数返回值，我们可以用一个变量来存储结果，然后通过闭包来设置这个变量，但这样需要额外的变量。 参考引用[3]中的思路1（Java代码）： boolean flag = ((n!=0) && (n += Sum_Solution(n-1))!=0); return n; 在Go中，我们可以这样： if n>0 { n += f(n-1) } return n 但是不能使用if，所以我们用&&： var _ = (n>0) && (func() { n += f(n-1); }()) return n 注意：这里我们使用了一个匿名函数，并且立即执行。在&&的短路特性中，如果n>0为真，那么就会执行后面的匿名函数（该函数将递归结果加到n上），如果为假，则不会执行。 但是，在Go中，匿名函数可以修改外层函数的局部变量（通过闭包），所以这样是可行的。 但是，这里有一个问题：当n=0时，我们直接返回0。当n>0时，我们执行递归，然后将递归结果加到n上，并返回n。 因此，我们可以写出如下函数： func Sum_Solution(n int) int { // 当n>0时，执行递归 var ok bool ok = n>0 && func() bool { n += Sum_Solution(n-1) return true }() return n } 解释：当n>0时，执行匿名函数，该函数将n-1的递归结果加到n上。匿名函数返回true，所以ok被赋值为true，但我们并不关心ok的值。然后返回n。 但是，这里有一个问题：当n==0时，返回0。当n>0时，递归计算n-1的和，然后加到n上，返回。 但是，在Go中，逻辑与操作要求两边的表达式都是布尔类型。所以我们需要让匿名函数返回bool。 另外，注意递归调用时，n-1可能为0，这时递归终止。 测试：n=1 进入函数，n=1，1>0为真，所以执行匿名函数：n += Sum_Solution(0) 调用Sum_Solution(0)：0>0为假，所以不执行匿名函数，返回0。 所以n=1+0=1，返回1。 测试n=2： 进入函数，n=2，2>0为真，执行匿名函数：n += Sum_Solution(1) 调用Sum_Solution(1)：如上，返回1 所以n=2+1=3，返回3。 正确。 但是，这种方法在递归过程中，每次递归都会创建一个匿名函数并立即调用，虽然可行，但效率不是很高。不过题目没有要求效率。 另外，注意Go语言中，逻辑与操作是短路的，所以当n<=0时，不会执行匿名函数。 因此，我们可以这样实现。 但是，我们也可以不用匿名函数，而是通过一个辅助递归函数，但原理相同。 另一种方法：利用数组和闭包（类似引用[2]和[5]的C++方法）。在Go中，我们可以创建一个长度为n的数组（或切片），然后利用数组的初始化过程来累加。但是，数组的初始化需要循环，我们无法显式地写循环，但我们可以用递归或者初始化表达式。 不过，在Go中，我们可以利用一个结构体，在结构体的方法中实现累加，然后创建该结构体的数组，利用初始化过程调用构造函数（在Go中，结构体没有构造函数，但我们可以写一个函数来返回结构体，然后利用初始化表达式？）。但是，创建数组时，每个元素都会初始化，我们可以用一个全局变量来累加，然后创建n个元素。 步骤： 1. 定义一个全局变量sum（或者用闭包捕获的变量）来存储累加值。 2. 定义一个结构体，比如Dummy，它没有任何字段。 3. 在创建Dummy数组时，我们无法在创建数组时自动调用某个方法，除非我们使用一个函数来创建每个元素，但这样又需要循环。 所以，这种方法在Go中可能不如在C++中方便（因为C++在创建对象数组时会自动调用构造函数）。 因此，我们选择递归和短路方法。 但是，我们需要注意的是，题目要求不能使用条件判断语句，而我们的递归终止条件是通过短路特性实现的，所以符合要求。 代码实现如下： func sumNums(n int) int { // 当n>0时，执行递归 if n > 0 { n += sumNums(n-1) } return n } 但是，这个代码中使用了if，不符合要求。所以我们要去掉if。 我们使用短路特性： func sumNums(n int) int { // 使用短路特性 var _ = n>0 && func() bool { n += sumNums(n-1) return true }() return n } 这个代码没有使用if，而是用&&的短路特性来模拟条件执行。当n>0时，后面的匿名函数会被执行，执行递归调用；当n<=0时，后面的匿名函数不会被执行。 注意：匿名函数中的递归调用会改变n的值（通过闭包），所以返回的n就是累加后的值。 但是，我们也可以不用匿名函数，而是用一个辅助函数，但这样代码量可能更多。 另外，我们还可以考虑用其他方法，比如使用递归和异常（如引用[3]中的思路2），但Go没有异常机制，而且使用异常也不高效。 因此，我们采用上述方法。 测试：n=1 -> 1, n=2 -> 3, n=3 -> 6。 但是，当n=0时，应该返回0，测试：n=0 -> 0，因为短路特性，匿名函数不会执行，返回0。 所以，我们按照这个思路写代码。 但是，题目要求不能使用条件判断语句，我们这里使用了n>0，这是一个条件表达式，但题目禁止的是条件判断语句（如if、switch等），而条件表达式（如比较表达式）是允许的，因为我们需要它来控制短路。 因此，这个方法符合要求。 另一种方法：使用递归和函数指针数组（或者映射）来模拟条件判断，但这样更复杂，而且可能也需要条件表达式。 所以，我们采用短路方法。 代码： package main import "fmt" func sumNums(n int) int { // 当n>0时，执行递归 // 使用短路特性 var _ = n > 0 && func() bool { n += sumNums(n - 1) return true }() return n } func main() { fmt.Println(sumNums(5)) // 输出15 } 但是，这个代码在Go Playground运行一下，发现栈溢出？不对，递归终止条件是正确的。 测试n=5：递归调用sumNums(4), sumNums(3)...直到sumNums(0)返回0，然后逐层返回。 我们运行一下： n=5: 5>0为真，执行匿名函数：5 += sumNums(4) n=4: 4>0为真，执行匿名函数：4 += sumNums(3) n=3: 3>0为真，执行匿名函数：3 += sumNums(2) n=2: 2>0为真，执行匿名函数：2 += sumNums(1) n=1: 1>0为真，执行匿名函数：1 += sumNums(0) n=0: 0>0为假，不执行匿名函数，返回0 然后n=1: 1+0=1，返回1 n=2: 2+1=3，返回3 n=3: 3+3=6，返回6 n=4: 4+6=10，返回10 n=5: 5+10=15，返回15 所以正确。 但是，我们也可以不使用匿名函数，而是用一个辅助函数？其实没有必要，这样已经足够。 另外，注意题目要求不能使用条件判断语句，我们这里没有使用if等，而是用了条件表达式（n>0）作为逻辑与的左操作数，这是允许的。 因此，我们采用这个方案。 但是，我们也可以尝试另一种递归写法，利用多返回值？但题目要求函数返回整数。 所以，我们提供上述代码。 注意：这个函数在n较大时可能会导致递归深度过大而栈溢出，但题目没有说明n的范围，我们假设n在合理范围内。 另外，引用中还有使用静态变量和构造函数的方法，在Go中我们可以用闭包和全局变量来实现，但需要初始化，而且不是线程安全的。这里我们不再展开。 综上所述，我们使用递归和短路特性来实现。 代码实现：</think>在Go语言中，计算从1到n的和而不使用循环或条件判断语句，可以通过递归结合逻辑运算符的**短路特性**实现。以下是完整实现： ```go package main import "fmt" func sumNums(n int) int { // 利用 && 的短路特性：当 n>0 时执行递归，n=0 时终止 _ = n > 0 && func() bool { n += sumNums(n - 1) // 递归累加 return true }() return n } func main() { fmt.Println(sumNums(5)) // 输出: 15 (1+2+3+4+5) fmt.Println(sumNums(10)) // 输出: 55 } ``` ### 关键原理： 1. **短路特性** `n > 0 && func() {...}()` 中： - 当 `n > 0` 为 `true` 时：执行右侧匿名函数（递归累加） - 当 `n = 0` 时：短路发生，不执行递归，直接返回 `0` 2. **递归过程** - 递归调用 `sumNums(n-1)` 逐步拆解为 `n + (n-1) + (n-2) + ... + 0` - 例如 `n=3` 时： ``` sumNums(3) → 3 + sumNums(2) sumNums(2) → 2 + sumNums(1) sumNums(1) → 1 + sumNums(0) sumNums(0) → 0 ``` 3. **闭包捕获变量** 匿名函数通过闭包直接修改外层变量 `n`，实现累加： ```go n += sumNums(n - 1) // 修改外层 n 的值 ``` ### 限制说明： - **时间复杂度**：$O(n)$（递归深度为 `n`） - **空间复杂度**：$O(n)$（递归栈空间） - 当 `n > 100000` 时可能触发栈溢出（Go默认递归深度限制） ### 替代方案：利用数组初始化（无递归） ```go func sumNums(n int) int { var sum int type dummy struct{} // 创建长度为 n 的数组，每次初始化时执行累加 arr := make([]dummy, n) for i := range arr { sum += i + 1 // 累加 1 到 n } return sum } ``` > **注意**：此方案使用了 `for` 循环，但展示了另一种思路。递归短路方案完全符合题目限制。 ### 相关问题 1. **如何避免递归导致的栈溢出？** 可改用迭代或公式 $n(n+1)/2$（但题目禁用乘除）[^3][^4]。 2. **如何用汇编语言实现无循环求和？** 可生成指令序列：`ADD` 指令线性展开（牺牲代码体积）[^1]。 3. **函数式语言（如 Haskell）如何实现？** 利用模式匹配： ```haskell sumNums 0 = 0 sumNums n = n + sumNums (n-1) ``` 4. **如何支持大整数（BigInt）求和？** 递归方案需改为尾递归优化（Go 需手动实现迭代）[^2][^5]。 [^1]: 禁用乘除法和循环时需依赖指令展开或递归 [^2]: 静态变量/闭包存储状态可避免显式循环 [^3]: 短路特性替代条件判断是通用技巧 [^4]: 递归深度限制可通过迭代或尾递归优化缓解 [^5]: 大整数需处理栈空间和计算效率问题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值