Question

我想编写一个返回true的函数当且仅当在大小为n的数组t中我有1,2中的每一个数字时，... n

我的想法是：

bool g(int* t, int n){
    for(int i = 0; i < n; i++){
        for(int j = n; j > 0; j--){
           if(t[i] == n)
              break;
           else
              return false;
        }
    }
    return true;
}

然而，int t[6] = {6, 2, 3, 4, 5, 1};的这个返回零，这是错误的，因为从1到6的所有数字都在一个数组中。

如何改进？此外，如何改善这个问题？

Answer 1

我的解决方案是为值提供权重，例如二进制数字权重。例如：

值1 =＆gt;重量1
值2 =＆gt;重量2
值3 =＆gt;重量4
值4 =＆gt;重量8
值x =＆gt;重量1 << x-1

然后对所有权重求和，并检查是否满足sum = 2 ^ n-1

#include <iostream>
#include <iomanip>
#include <cmath>

bool g( const int a[], int n )
{
    int long long sum = 0;
    int i = 0;
    long long int target = (1<<n)-1;

    for ( ; i < n && a[i] > 0 ; i++ ) sum += 1<<a[i]-1;

    return i == n && sum == target;
}   

int main() 
{
    const int N = 6;        
    int t[N] = { 6, 2, 3, 4, 5, 1 }; 

    std::cout << std::boolalpha << g( t, N ) << std::endl;
}

此处的工作代码：http://ideone.com/DscXJH

这个可能的解决方案受到了OP的评论的启发。

Answer 2

你在这里

true

程序输出

    for(int j=n;j>0;j--){
    if(t[i]==n)
      break;
    else
      return false;
    }

如果数组的所有元素都不同，此函数将起作用。

至于你的代码然后这个循环

{{1}}

没有意义。

Answer 3

这是使用STL算法函数的另一种解决方案：

#include <iostream>
#include <algorithm>
#include <numeric>
using namespace std;

bool g(int *t, int n)
{
    if ( n == 0 ) 
       return false;
    std::sort(t, t + n);
    return (t[0] == 1) &&  // first number must be 1
            (std::distance(t, std::unique(t, t + n)) == n) &&  // all must be unique
            (std::accumulate(t, t + n, 0) == (n * (n + 1)) / 2); // has to add up correctly
}

int main()
{
   int arr[] = {1,2,3,4,5,6,7};
   std::cout << g(arr, 7);
}

Live Example

对数字列表进行排序后，std::unique算法函数用于将非唯一项移动到数组的末尾，然后给我们一个指向这个非唯一序列的开头的指针项目。如果所有值都是唯一的，那么std::unique将返回超过数组末尾的一个位置。

这就是std::distance的原因 - 它告诉我们非唯一序列的开头和开头之间的数字是否等于整个列表中的数字数。

std::accumulate只是将序列中的所有数字相加，并查看结果是否为(n * (n+1)) / 2，这是找到第一个n个连续整数之和的经典公式（从1开始）。

这是一个更短的解决方案：

#include <iostream>
#include <algorithm>
using namespace std;

bool g(int *t, int n)
{
    if ( n == 0 ) 
       return false;
    std::sort(t, t + n);
    return (t[0] == 1) &&  // first number must be 1
            (t[n-1] == n) && // last must be n
            (std::distance(t, std::unique(t, t + n)) == n); // all must be unique
}

又一种方法：

#include <iostream>
#include <algorithm>
#include <set>
using namespace std;

bool g(int *t, int n)
{
    if ( n == 0 ) 
       return false;
    std::sort(t, t + n);
    return (t[0] == 1) &&  // first number must be 1
            (t[n-1] == n) && // last must be n
            (std::set<int>(t, t+n).size() == n); // all must be unique
}

int main()
{
   int arr[] = {1,2,3,4,5,6,7};
   std::cout << g(arr, 7);
}

Live Example

在此方法中，从数字列表中创建临时std::set。由于std::set仅存储唯一数字，因此插入所有项目后，集合的size()必须等于n，以确定所有数字是否都是唯一的。

Answer 4

让STL完成工作.. tf.einsum()是非负面的

Answer 5

试试这个。

#include <set>

typedef int data;
typedef std::set<data> set;

template<typename Iterator>
bool g(Iterator begin, const Iterator end) {

    set elements, expected;
    data i = 1;
    for (; begin != end; ++begin, ++i) {
        elements.insert(*begin);
        expected.insert(i);
    }

    return elements == expected;

}

Answer 6

我认为，最简单的方法是计算出现次数。初始化n + 1大小的数组＆＃34; a＆＃34;用零和增量a [t [i]]。它会在重复时退出。还要确保t [i]处于有效范围内。

db.adminCommand( { setFeatureCompatibilityVersion: "3.4" } )

检查数组中的数字

6 个答案: