Question

假设我有[2,4,6,7,7,4,4]的阵列我想要一个可以迭代的程序，然后打印出这样的东西：

Value:     Count:
2          1
4          3
6          1
7          2

我不希望它打印出ex 4三次。到目前为止我得到了什么：

for (int i = 0; i < numberOfInts; i++)
{
    dub[i] = 0;
    for (int y = 0; y < numberOfInts; y++)
    {
        if (enarray[i] == enarray[y])
        {

            dub[i]++;
        }
    }

}

所以基本上我会针对所有元素检查数组中的每个元素，并且对于每个重复，我将一个添加到新数组dub []中的索引。所以，如果我使用上面的示例数组运行此代码，然后将其打印出来，我会得到这样的结果： 1,3,1,2,2,3,3。这些数字非常令人困惑，因为我真的不知道它们属于哪个数字。特别是当我随机化数组中的数字时。然后我必须删除数字，所以我只有一个。有人有更好的解决方案吗？

Answer 1

你可以在检查每个元素的同时迭代数组，如果它已被重复，在这种情况下你增加它的计数（循环检查只值头节省处理时间）。这使您可以在不创建任何额外缓冲区阵列或结构的情况下完成所需。

布尔＆＃39;＆＃39;防止重复打印

int main() {

    int arr[] = { 2, 4, 6, 7, 7, 4, 4 };
    int size = (sizeof(arr) / sizeof(int));

    printf("Value:\tCount\n");
    for (int i = 0; i < size; i++) {
        int count = 0, bl = 1; //or 'true' for print
        //check elements ahead and increment count if repeated value is found 
        for (int j = i; j < size; j++) {
            if (arr[i] == arr[j]) {
                count++;
            }
        }
        //check if it has been printed already
        for (int j = i-1; j >= 0; j--) {
            if (arr[i] == arr[j]) {
                bl = 0; //print 'false'
            }
        }
        if (bl) { printf("%d\t\t%d\n", arr[i], count); } 
    }

    return 0;
}

Answer 2

鉴于char数组只包含＆＃39; 0＆＃39;对于＆＃39; 9＆＃39;，你可以使用这样一个简单的查找表：

public class SampleActivity extends Activity {


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_datepicker);


        final EditText text1 = (EditText) findViewById(R.id.text1);
        final EditText text2 = (EditText) findViewById(R.id.text2);


        text1.addTextChangedListener(new TextWatcher() {
            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
    **text2.addTextChangedListener(null);**
                try {
                    int total = Integer.parseInt(s.toString()) + 1;
                    text2.setText(String.valueOf(total));
                }catch (Exception e){
                    e.printStackTrace();
                }


            }
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) { }
            @Override
            public void afterTextChanged(Editable s) {
    **text2.addTextChangedListener(this);**
            }
        });

        text2.addTextChangedListener(new TextWatcher() {
            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) 
{
                    text1.addTextChangedListener(null);
                try {
                    int total = Integer.parseInt(s.toString()) + 2;
                    text1.setText(String.valueOf(total));
                } catch (Exception e) {
                    e.printStackTrace();
                }

            }

            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
            }

            @Override
            public void afterTextChanged(Editable s) 
{
                **text1.addTextChangedListener(this);**

            }
        });


    }


    }

输出：

#include <stdio.h>

typedef struct
{
    char c;
    int  num;
} TSet;

TSet my_set[] =
{
    { '0', 0 },
    { '1', 0 },
    { '2', 0 },
    { '3', 0 },
    { '4', 0 },
    { '5', 0 },
    { '6', 0 },
    { '7', 0 },
    { '8', 0 },
    { '9', 0 },
};

int main()
{
    char a[] = {'2','4','6','7','7', '4','4'};
    int i;
    for( i = 0; i < sizeof(a) / sizeof(char); i++ )
    {
        my_set[ a[i] - '0' ].num++;
    }

    printf( "%-10s%-10s\n", "Value:", "Count:" );
    for( i = 0; i < sizeof(my_set) / sizeof(TSet); i++ )
    {
        if( my_set[i].num != 0 )
        {
            printf( "%-10c%-10d\n", my_set[i].c, my_set[i].num );
        }
    }
}

Answer 3

我不明白这里的复杂性。我认为有两种方法具有高性能且易于实现：

计算排序

需要数组中最大元素大小的int数组
总体复杂度O（n + m）其中m是数组中最大的元素

qsort和enumeration

qsort在O（n * log（n））中工作，并为您提供排序数组
一旦数组被排序，您可以简单地迭代它并计算
总体复杂度O（n * log（n））

Answer 4

通常使用qsort()函数
迭代连续计算相等元素的所有元素，如果检测到下一个不同的元素，则打印前者的计数

这适用于任何数量的不同元素。也不需要第二个数组。

Answer 5

在外部 for循环中放置一个print语句，以打印值和重复

eval env (NewArrayC len el) = do
    lenVal <- eval env len
    elVal  <- eval env el
    case lenVal of
        NumV lenNum -> allocateMany lenNum elVal
        _           -> throwError "expected number in new-array length"

Answer 6

你有一般的想法。除了你的输入数组，我还会建议另外三个数组：

一个used数组，用于跟踪输入中的哪些条目已被计算。
一个value数组，用于跟踪input数组中的不同数字。
一个count数组，用于跟踪数字出现的次数。

例如，在处理输入数组中的2和4之后，数组内容将是

input[] = { 2,4,6,7,7,4,4 };
used[]  = { 1,1,0,0,0,1,1 };  // all of the 2's and 4's have been used
value[] = { 2,4           };  // unique numbers found so far are 2 and 4
count[] = { 1,3           };  // one '2' and three '4's

Answer 7

你要求的是奇怪的。通常情况下，我会创建一个包含2个成员的结构，例如＆＃39; number＆＃39;和＆＃39;计算＆＃39;。但是，让我们尝试一下您所要求的内容（一维数组，每个数字后面跟着它计算）：

int 
   i,
   numberOfInts = 7,
   numberOfDubs = 0,
   enarray[7] = {2,4,6,7,7,4,4},
   dub[14]; // sizeof(enrray) * 2 => maximum number of dubs (if there are no duplicates)

// For every number on enarray
for(i = 0; i < numberOfInts; i++)
{
    int jump = 0;

    // Check if we have already counted it
    // Only check against pairs: Odds are the dub counter
    for(int d = 0; d < numberOfDubs && !jump; d += 2)
    {
       if(dub[d] == enarray[i])
       {
          jump = 1;
       }
    }

    // If not found, count it
    if(!jump)
    {
       // Assign the new number
       dub[numberOfDubs] = enarray[i];
       dub[numberOfDubs + 1] = 1;

       // We can begin from 'i + 1'
       for(int y = i + 1; y < numberOfInts; y++)
       {
          if(enarray[i] == enarray[y])
          {
               dub[numberOfDubs + 1]++;
          }
       }

       // Increment dub's counter by 2: number and it's counter
       numberOfDubs += 2;
    }
}

// Show results
for(i = 0; i < numberOfDubs; i += 2)
{
   printf("%d repeated %d time%s\n", dub[i], dub[i + 1], (dub[i + 1] == 1 ? "" : "s"));
}

计算和删除数组中的重复项c

7 个答案: