我的代码错了可以帮我看一下怎么写吗


#include <bits/stdc++.h>
using namespace std; 
int main()
{
    int n;
    cin>>n;
    do{
        cout<<n%10;
        if(n-1){
         cout<<",";
        }
        n=n/10;
    }
    while(n!=0);
    return 0;
}

给定一个整数，要求从个位开始分离出它的每一位数字。给定一个整数，要求从个位开始分离出它的每一位数字。我的代码错了可以帮我看一下怎么写吗

#include <bits/stdc++.h>
using namespace std; 
int main()
{
    int n;
    int flag = 0;
    cin>>n;
    do{
        if(flag)
         cout<<"," << n%10;
        else
          cout<<n%10;
        flag = 1;
        n=n/10;
    }
    while(n!=0);
    return 0;
}

n = n/10 这句应该是整除，我不会c仅会python，所以不明白您那句的含义。
python 表达式是 n //= 10，表示把n整除10的值赋给n。如n是45，执行语句后n为4；n是45678，执行语句后n是4567。

python代码运行效果截屏图片
python 代码

#!/sur/bin/nve python
# coding: utf-8


def sever_num(n):
    
    while n > 0: # n等于0退出循环。
        print(n%10) # 模10取余，打印个位数字。
        n //= 10 # 除10取整，获取个位以前的数字。


if __name__ == '__main__':
    
    for i in (345, 67, 89, 105):
        print('\n给定整数：', i)
        sever_num(i) # 调用函数打印整数各数位数字。

第10行：if(n-1) 修改为：if(n/10) 即可。

修改后的代码：

#include <iostream>
using namespace std;

int main()
{
    int n;
    cin >> n;
    
    do {
        cout << n % 10;
        if (n / 10 != 0) {
            cout << ", ";
        }
        n = n / 10;
    } while (n != 0);
    
    return 0;
}

这个问题的回答你可以参考下: https://ask.csdn.net/questions/2742010
我还给你找了一篇非常好的博客，你可以看看是否有帮助，链接：写一个函数，参数为1.一个字符，2.一个字符串，根据这个字符将传入的字符串分割成多个字符串，并用数组返回这些分割的字符串
除此之外, 这篇博客: 算法复杂度分析中的渐近分析（基于输入大小）中的 给定一个任务的两种算法，我们如何找出哪一种更好？ 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
一种天真的方法是 - 实现两种算法并在计算机上运行两个程序以获得不同的输入，看看哪个花费更少的时间。这种方法在算法分析中存在许多问题。
- 对于某些输入，第一种算法的性能可能优于第二种算法。对于某些输入，第二表现更好。
- 对于某些输入，第一种算法在一台计算机上的性能更好，而第二种算法在另一台计算机上对于其他一些输入的性能更好。
渐进分析是在分析算法时处理上述问题的大思想。在渐近分析中，我们根据输入大小评估算法的性能（我们不测量实际运行时间）。我们计算算法所花费的时间（或空间）如何随着输入大小的增加而增加。
例如，让我们考虑排序数组中的搜索问题（搜索给定项目）。
上述搜索问题的解决方案包括：
- 线性搜索（增长顺序为线性）
- 二叉搜索（增长顺序是对数）。
为了理解渐近分析如何解决上述分析算法中提到的问题，
- 让我们说：
  - 我们在快速计算机 A 上运行线性搜索，并且
  - 在慢速计算机 B 和
  - 选择两台计算机的常量值，以便它准确地告诉我们给定计算机在几秒钟内执行搜索所需的时间。
- 假设 A 的常数是 0.2，B 的常数是 1000，这意味着 A 比 B 强大 5000 倍。
- 对于输入数组大小 n 的小值，快速计算机可能需要更少的时间。
- 但是，在输入数组大小达到一定值后，与线性搜索相比，二叉搜索肯定会开始花费更少的时间，即使二叉搜索是在一台慢速机器上运行的。
输入大小在 A 上的运行时间 B 上的运行时间
10 2 秒 ~ 1 小时
100 20 秒 ~ 1.8小时
10^6 ~ 55.5 小时 ~ 5.5小时
10^9 ~ 6.3 年 ~ 8.3小时
- 原因是二叉搜索相对于输入大小的增长顺序是对数的，而线性搜索的增长顺序是线性的。
- 因此，在输入大小的某个值之后，始终可以忽略与机器相关的常量。
此示例的运行时间：
- 线性搜索运行时间（以秒为单位）：0.2 * n
- 二进制搜索运行时间（以秒为单位）：1000*log（n）

输入大小	在 A 上的运行时间	B 上的运行时间
10	2 秒	~ 1 小时
100	20 秒	~ 1.8小时
10^6	~ 55.5 小时	~ 5.5小时
10^9	~ 6.3 年	~ 8.3小时

以下回答由chatgpt基于相关博客总结生成:

问题分析: 给定一个整数，需要将其每一位数字分离出来，并输出。代码中给出的方法一、方法二、方法三分别是三种实现的方式。方法一通过冒泡排序将数组排序，然后遍历排序后的数组，判断相邻两个数字是否相同，如果不同则停止遍历，并输出第一个数字作为结果。方法二使用了键值对的方式，将数字作为键，出现次数作为值，遍历数组并插入键值对中，最后输出值为1的键作为结果。方法三使用嵌套循环判断每个数字的出现次数，如果出现次数为1，则输出作为结果。

解决方案：以上三种方法都是可以实现分离整数各位数字的目的，具体选择哪种方法取决于个人的实际需求和偏好。如果对排序没有要求，可以选择方法二或方法三，它们的时间复杂度都较低，方法二通过HashMap插入键值对判断出现次数，方法三通过嵌套循环判断出现次数。

下面是方法二和方法三的代码实现：方法二：

int[] separateDigits(int num) {
    int[] digits = new int[String.valueOf(num).length()];
    int i = 0;
    Map<Integer, Integer> map = new HashMap<>();

    while (num != 0) {
        int digit = num % 10;
        digits[i++] = digit;

        if (map.containsKey(digit)) {
            map.put(digit, 2);
        } else {
            map.put(digit, 1);
        }

        num /= 10;
    }

    for (int j = 0; j < digits.length; j++) {
        if (map.get(digits[j]) == 1) {
            System.out.println(digits[j]);
        }
    }

    return digits;
}

方法三：

int[] separateDigits(int num) {
    int[] digits = new int[String.valueOf(num).length()];
    int i = 0;

    while (num != 0) {
        int digit = num % 10;
        digits[i++] = digit;
        num /= 10;
    }

    for (int j = 0; j < digits.length; j++) {
        boolean unique = true;

        for (int k = 0; k < digits.length; k++) {
            if (k != j && digits[k] == digits[j]) {
                unique = false;
                break;
            }
        }

        if (unique) {
            System.out.println(digits[j]);
        }
    }

    return digits;
}

这两种方法都可以将整数各位数字分离出来，并输出结果。根据实际需求选择其中一种方法即可。