C++ C++；，对数字数组进行排序以找到唯一性

假设我有一个由4个不同数字组成的数组

整数[4]={50234、50356、50454、50934}

如何在C++中为嵌套for循环排序这些数字，以识别所需的数字的唯一性？< /P> 从这个例子中，你可以看出，你需要从后面的3位数字，以确保没有数字包含类似的数字尾。50234、50934=3个数字，使其分别唯一=502和509

for循环会是什么样子的？一个接一个、一个接一个地遍历这些数字，然后对相同的数字进行排序，以获得3的输出

它是这样的：

四,

6-丢弃此号码，它不相同

四,

四,

然后：

三,

5-放弃此号码

三,

然后：

二,

9万岁！不再有类似的数字，打印出3作为答案

我被难住了，弄不明白

任何帮助都将不胜感激，谢谢。

说你从

#include <unordered_set>
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    const std::vector<int> numbers{50234, 50356, 50454, 50934};

在每次迭代中，我们将创建一个

无序集

        std::unordered_set<std::string> partials;

如果集合的大小是向量的大小，我们完成了：

        if(partials.size() == numbers.size()) {
                std::cout << digits << " required" << std::endl;
                return 0;
            }

---

完整代码：

#include <unordered_set>
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    const std::vector<int> numbers{50234, 50356, 50454, 50934};

    std::vector<std::string> string_numbers;
    std::for_each(std::begin(numbers), std::end(numbers), [&](int n){ string_numbers.push_back(std::to_string(n)); });

    size_t digits = 1;
    while(true) {
        std::unordered_set<std::string> partials;
        for(const auto &s: string_numbers) {
            if(s.size() <= digits) {
                std::cout << "not unique" << std::endl;
                return 0;
            } 
            partials.insert(s.substr(0, digits));
        }
        if(partials.size() == numbers.size()) {
                std::cout << digits << " required" << std::endl;
                return 0;
            }
        ++digits;
    }
}

#包括
#包括
#包括
#包括
int main（）{
常数std：：向量数{50234、50356、50454、50934}；
std：：向量字符串_数；
std:：for_each（std:：begin（numbers），std:：end（numbers），[&]（int n）{string_numbers.push_back（std:：to_string（n））；}）；
数字大小=1；
while（true）{
std：：无序集合部分；
用于（常量自动&s：字符串编号）{
如果（s.size（）说你从

#include <unordered_set>
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    const std::vector<int> numbers{50234, 50356, 50454, 50934};

在每次迭代中，我们将创建一个
无序集

        std::unordered_set<std::string> partials;

如果集合的大小是向量的大小，我们完成了：

        if(partials.size() == numbers.size()) {
                std::cout << digits << " required" << std::endl;
                return 0;
            }


完整代码：

#include <unordered_set>
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    const std::vector<int> numbers{50234, 50356, 50454, 50934};

    std::vector<std::string> string_numbers;
    std::for_each(std::begin(numbers), std::end(numbers), [&](int n){ string_numbers.push_back(std::to_string(n)); });

    size_t digits = 1;
    while(true) {
        std::unordered_set<std::string> partials;
        for(const auto &s: string_numbers) {
            if(s.size() <= digits) {
                std::cout << "not unique" << std::endl;
                return 0;
            } 
            partials.insert(s.substr(0, digits));
        }
        if(partials.size() == numbers.size()) {
                std::cout << digits << " required" << std::endl;
                return 0;
            }
        ++digits;
    }
}

#包括
#包括
#包括
#包括
int main（）{
常数std：：向量数{50234、50356、50454、50934}；
std：：向量字符串_数；
std:：for_each（std:：begin（numbers），std:：end（numbers），[&]（int n）{string_numbers.push_back（std:：to_string（n））；}）；
数字大小=1；
while（true）{
std：：无序集合部分；
用于（常量自动&s：字符串编号）{
如果（s.size（）如果要对数字进行排序，请使用一种排序算法，比如气泡排序。然后检查唯一性并将唯一值存储在新数组中，然后打印它们：

我们编写代码是为了理解和实践，但在实际程序中，我们使用的库功能太强大，速度太快：

#include <iostream>
using std::cout;
using std::endl;



int main()
{

    int numbers[4] = {50234, 50356, 50454, 50934};
//  int numbers[4] = {50234, 50356, 50454, 50356};

    for(int i(0); i < 4; i++)
    {
        for(int j(i + 1); j < 4; j++)
        {
            if(numbers[i] > numbers[j])
            {
                numbers[i] ^= numbers[j];
                numbers[j] ^= numbers[i];
                numbers[i] ^= numbers[j];
            }
        }
    }

    for(int i = 0; i < 4; i++)
        cout << numbers[i] << ", ";

    int  nUniq = 0;
    bool isUniq = true;

    for(int i = 0; i < 4; i++)
    {
        isUniq = true;

        for(int j(i + 1); j < 4; j++)
        {
            if(numbers[i] == numbers[j])
            {
                isUniq = false;
                break;
            }
        }
        if(isUniq)
            nUniq++;
    }

    cout << nUniq << endl;

    int* ptrUniq = new int[nUniq];
    int k = 0;

    for(int i = 0; i < 4; i++)
    {
        isUniq = true;

        for(int j(i + 1); j < 4; j++)
        {
            if(numbers[i] == numbers[j])
            {
                isUniq = false;
                break;
            }
        }
        if(isUniq)
        {
            ptrUniq[k] = numbers[i];
            k++;
        }
    }

    cout << "\nhere are uniq values:\n\n";
    for(int i = 0; i < nUniq; i++)
        cout << ptrUniq[i] << ", ";

    delete[] ptrUniq;
    ptrUniq = NULL;


    cout << endl << endl;
    return 0;
}

#包括
使用std：：cout；
使用std：：endl；
int main（）
{
整数[4]={50234、50356、50454、50934}；
//整数[4]={50234，50356，50454，50356}；
for（int i（0）；i<4；i++）
{
对于（intj（i+1）；j<4；j++）
{
如果（数字[i]>数字[j]）
{
数字[i]^=数字[j]；
数字[j]^=数字[i]；
数字[i]^=数字[j]；
}
}
}
对于（int i=0；i<4；i++）
cout如果要对数字进行排序，请使用一种排序算法，比如气泡排序。然后检查唯一性并将唯一值存储在新数组中，然后打印它们：

我们编写代码是为了理解和实践，但在实际程序中，我们使用的库功能太强大，速度太快：

#include <iostream>
using std::cout;
using std::endl;



int main()
{

    int numbers[4] = {50234, 50356, 50454, 50934};
//  int numbers[4] = {50234, 50356, 50454, 50356};

    for(int i(0); i < 4; i++)
    {
        for(int j(i + 1); j < 4; j++)
        {
            if(numbers[i] > numbers[j])
            {
                numbers[i] ^= numbers[j];
                numbers[j] ^= numbers[i];
                numbers[i] ^= numbers[j];
            }
        }
    }

    for(int i = 0; i < 4; i++)
        cout << numbers[i] << ", ";

    int  nUniq = 0;
    bool isUniq = true;

    for(int i = 0; i < 4; i++)
    {
        isUniq = true;

        for(int j(i + 1); j < 4; j++)
        {
            if(numbers[i] == numbers[j])
            {
                isUniq = false;
                break;
            }
        }
        if(isUniq)
            nUniq++;
    }

    cout << nUniq << endl;

    int* ptrUniq = new int[nUniq];
    int k = 0;

    for(int i = 0; i < 4; i++)
    {
        isUniq = true;

        for(int j(i + 1); j < 4; j++)
        {
            if(numbers[i] == numbers[j])
            {
                isUniq = false;
                break;
            }
        }
        if(isUniq)
        {
            ptrUniq[k] = numbers[i];
            k++;
        }
    }

    cout << "\nhere are uniq values:\n\n";
    for(int i = 0; i < nUniq; i++)
        cout << ptrUniq[i] << ", ";

    delete[] ptrUniq;
    ptrUniq = NULL;


    cout << endl << endl;
    return 0;
}

#包括
使用std：：cout；
使用std：：endl；
int main（）
{
整数[4]={50234、50356、50454、50934}；
//整数[4]={50234，50356，50454，50356}；
for（int i（0）；i<4；i++）
{
对于（intj（i+1）；j<4；j++）
{
如果（数字[i]>数字[j]）
{
数字[i]^=数字[j]；
数字[j]^=数字[i]；
数字[i]^=数字[j]；
}
}
}
对于（int i=0；i<4；i++）
难道你真的需要检查整个数字吗？<代码> 502123456789 < /代码>和<代码> 503123456789 > /代码>有很多相同的数字从后面，但它们是不同的数字。没有逻辑的逻辑是新的C++，只是初学者。我不需要检查整个数字。我只是想让它通过每个位置的数字。从后面到前面。它可以丢弃没有数字相似的数字，并在到达没有数字相似的数字位置时停止。这有意义吗？：/I我尝试了一个嵌套的for循环，其中有3个循环。第一个循环遍历数字的长度（因此为5），下一个循环遍历数字的数量（这是4），最后一个循环将每个数字与下一个数字进行比较，以查看数字是否完全相同。这对我不起作用。查看该代码会有帮助。您真的不需要检查整个数字吗？
502123456789
和
503123456789
后面有很多相同的数字，但它们是不同的数字。无登录C是一个新的C++，只是一个初学者。我不需要检查整个数字。我只是希望它能从后面到前面的数字的每一个位置。它可以丢弃没有数字相似的数字，一旦它到达了一个没有数字相似的数字的位置就停止。这有意义吗？尝试了一个嵌套的for循环，其中包含3个循环。第一个循环遍历数字的长度（因此为5），下一个循环遍历数字的数量（即4）最后一个循环比较每个数字和下一个数字，看看数字是否相同。我不知道这个代码会有什么帮助。嗨，Ami，我只想说谢谢你的解决方案。我对C++仍然很陌生，这超出了我能理解的水平，但是它让我得到了我需要的答案。谢谢。嗨，Ami，只是想说谢谢你的解决方案。我对C++仍然很陌生，这超出了我能理解的水平，但是它让我得到了我需要的答案。谢谢。