Question

我有一个带有一组元素（超过100个元素）的数组a []，当给出输入'N'和'M'时，它必须忽略数组中'N'个元素的数量，' M'应为1或2是否忽略第一组或第二组'N'元素并继续执行直到数组结束..并将此O / P写入新数组b []。

例如，如果

a[]= {10,20,30,40,60,70,80,90,100}

if N=2, M=1
    O/p should be b[] = {30,40,80,90}

if N=2, M=2
    O/p should be b[] = {10,20,60,70,100}

我怎么能在TCL或C？ TCL代码将受到高度赞赏，我将数组索引设置为“1”而不是“0”。

Answer 1

Tcl列表的索引编号为0。

set a [list 10 20 30 40 60 70 80 90 100]
set N 2
foreach M {1 2} {
    set b [list]
    for {set i [expr {$M==1 ? $N : 0}]} {$i < [llength $a]} {incr i [expr {2*$N}]} {
        set b [concat $b [lrange $a $i [expr {$i+$N-1}]]]
    }
    puts "$M: $b"
}

输出

1: 30 40 80 90
2: 10 20 60 70 100

Answer 2

在C中，你可以这样做：

char * getShorterArray(char * my_array, size_t size, int n, int m) {
    char * res_arr;
    res_arr = malloc(sizeof(char) * (size - n)); 
    //                               ^ calculate the size of the result array
    if (res_arr == NULL)
        return res_arr;
    if (m > 0)
        memcpy(res_arr, my_array, m); // copy elements before m
    if (size - (m+n) > 0)
        memcpy(&res_arr[m], &my_array[m+n], size - (m+n)); //copy elements at the end
    return res_arr; 
}

请注意，我从索引0开始，而不是1.此外，一旦完成，内存应该free。

Answer 3

用于比较的JavaScript版本：

function neglect(arr, size, skip)
{
  var result = [];
  for (var i = 0; i < arr.length; i++)
    if (!(((i / size) ^ skip) & 1))
      result.push(arr[i]);
  return result;
}

我对C版本的考虑（在适当的位置改变数组，返回新的长度）：

int neglect(int[] arr, int len, int size, int skip)
{
  int result = 0;
  int i;
  for (i = 0; i < len; i++)
    if (!(((i / size) ^ skip) & 1))
      arr[result++] = arr[i];
  return result;
}

请注意，我的算法在设计时没有考虑到效率。

Answer 4

int neglect(int n, int m, int *a, int alen) {
    int *b = a;
    int src = 0;
    int dst = 0;

    a = (m == 1 ? a + n : a)
    alen = (m == 1 ? alen - n : alen)
    while (src < alen) {
        if (m == 2 && src % (n * 2) < n)
            b[dst++] = a[src++];
        else
            src++;
    }
    return dst;
}

Answer 5

                     set N 3
                     set dic [array size dnlink]
                 set h 1    
    for { set i $N} {$i <= [expr $dic - 1] } {incr i [expr {2*$N}]} {

                    for {set j $i} {$j <= [expr {$i+$N-1}] } {incr j} {

                set k [expr {$i+$N-1}]
                                if { $k <= [expr $dic - 1] } {

                                         set dn($h) $dnlink($j) 
                     incr h 
                                      } 
                                                                                      }

                                                                                      }

从数组中省略'N'个元素集

5 个答案: