按特定順序或系列打印數字

Question

我正在嘗試用C語言編寫一個將在給定范圍（0-100）下打印的代碼。

x只會從0到3，然后從8到11，然后從16到19依次打印，依此類推。 y將只打印其余部分，例如4到7，然后12到15，然后20到23，依此類推。

輸出應如下所示：

x = 0 1 2 3 8 9 10 11 ... 92 93 94 95   
y = 4 5 6 7 12 13 14 15 ... 96 97 98 99

Answer 1

使用%不會使您走得更遠... k = i % divisor; 將確保k不在[0,4]之間（因為divisor = 4 ），這不是您想要的。

那使用2個循環呢？

int main(){
  int i,j;
  for(i = 0; i < 100; i+=8){   // increment by 8 to make 0 -> 8 -> 16 jumps
    for(j = 0; j < 4; j++){    // print 4 values for x and y, starting from the initial value i, and i+4
      printf("x = %d\ty = %d\n", i+j, i+j+4);
    }
  }
    return 0;
}

Answer 2

問題說明是自相矛盾的。 它指定：

x = 0 1 2 3 8 9 10 11 ... 93 94 95 96
y = 4 5 6 7 12 13 14 15 ... 97 98 99 100

至少有兩個問題：

1. 4組應該以偶數開頭，因此最后一組錯誤地分組。
2. x線應以96 97 98 99結尾， y線應以92 93 94 95結尾（如果在輸出中包括，則也可能為100 ）。

問題中的代碼存在缺陷，因為它使用k = i; k = i % divisor; k = i; k = i % divisor; 並且因為沒有必要的嵌套循環結構。 我想嚴格來說，您可以編寫沒有嵌套循環的代碼，但是使用嵌套循環更簡單。

這兩行對於顯示來說有點不方便，因此最好將它們以適當的長度包裹起來。 下面的代碼處理這些各種問題。 它利用了printf()返回打印的字符數這一事實。 它忽略了printf()返回錯誤（返回值為負printf()的可能性。

#include <stdio.h>
#include <string.h>

/*
** tag      = string at start of line
** start    = starting value
** finish   = last value to be printed
** major    = major increment
** minor    = number of elements in each sub-sequence
** num_wid  = width to use for numbers (1 for minimum width)
** line_wid = wrap lines after this width
*/
static void print_sequence(const char *tag, int start, int finish,
                    int major, int minor, int num_wid, int line_wid)
{
    int count = printf("%s =", tag);
    for (int i = start; i <= finish; i += major)
    {
        for (int j = 0; j < minor && i + j <= finish; j++)
        {
            if (count > line_wid)
            {
                putchar('\n');
                count = printf("%*s  ", (int)strlen(tag), "");
            }
            count += printf(" %*d", num_wid, i + j);
        }
    }
    putchar('\n');
}

int main(void)
{
    print_sequence("x", 0, 100, 8, 4, 2, 70);
    print_sequence("y", 4, 100, 8, 4, 2, 70);

    print_sequence("x", 0, 100, 8, 4, 2, 160);
    print_sequence("y", 4, 100, 8, 4, 2, 160);

    print_sequence("x", 0, 100, 8, 4, 3, 70);
    print_sequence("y", 4, 100, 8, 4, 3, 70);

    return 0;
}

輸出示例：

x =  0  1  2  3  8  9 10 11 16 17 18 19 24 25 26 27 32 33 34 35 40 41 42
    43 48 49 50 51 56 57 58 59 64 65 66 67 72 73 74 75 80 81 82 83 88 89
    90 91 96 97 98 99
y =  4  5  6  7 12 13 14 15 20 21 22 23 28 29 30 31 36 37 38 39 44 45 46
    47 52 53 54 55 60 61 62 63 68 69 70 71 76 77 78 79 84 85 86 87 92 93
    94 95 100
x =  0  1  2  3  8  9 10 11 16 17 18 19 24 25 26 27 32 33 34 35 40 41 42 43 48 49 50 51 56 57 58 59 64 65 66 67 72 73 74 75 80 81 82 83 88 89 90 91 96 97 98 99
y =  4  5  6  7 12 13 14 15 20 21 22 23 28 29 30 31 36 37 38 39 44 45 46 47 52 53 54 55 60 61 62 63 68 69 70 71 76 77 78 79 84 85 86 87 92 93 94 95 100
x =   0   1   2   3   8   9  10  11  16  17  18  19  24  25  26  27  32
     33  34  35  40  41  42  43  48  49  50  51  56  57  58  59  64  65
     66  67  72  73  74  75  80  81  82  83  88  89  90  91  96  97  98
     99
y =   4   5   6   7  12  13  14  15  20  21  22  23  28  29  30  31  36
     37  38  39  44  45  46  47  52  53  54  55  60  61  62  63  68  69
     70  71  76  77  78  79  84  85  86  87  92  93  94  95 100

您可能不應該將此代碼作為作業分配的答案。 它可能太安全而無法配置。

單循環代碼

print_sequence()函數的此實現提供了相同的外部接口，但是實現有些不同。

static void print_sequence(const char *tag, int start, int finish,
                    int major, int minor, int num_wid, int line_wid)
{
    assert(major > 0 && minor > 0 && major > minor);
    int count = printf("%s =", tag);
    int p_limit = start + minor;        // print limit
    int c_limit = start + major - 1;    // count limit
    for (int i = start; i <= finish; i++)
    {
        if (i < p_limit)
        {
            if (count > line_wid)
            {
                putchar('\n');
                count = printf("%*s  ", (int)strlen(tag), "");
            }
            count += printf(" %*d", num_wid, i);
        }
        else if (i == c_limit)
        {
            p_limit += major;
            c_limit += major;
        }
    }
    putchar('\n');
}

這將產生與以前相同的輸出。 它的效率略低於原始效率，但是您很難衡量在循環中增加i幾倍的成本。

還要注意，這兩種解決方案都可以在指定的num_wid + 1之外最多打印num_wid + 1字符。 您可以通過num_wid + 1調整line_wid來解決此問題。 該代碼還可以檢查major至少與minor一樣大，並且兩者都嚴格為正。 而且line_wid對於標簽， =和至少一個數字足夠大。 GIGO有一個元素-如果您提供偽參數，則輸出將相應地為偽。

Answer 3

我已經編寫了具有兩行輸出的代碼。第一行將包含x值，第二行將包含y值。 希望這對您有所幫助。

#include<stdio.h>

int main() {


    int lim, i,j;
    int limit = 100;

    printf("x = ");

    for(i = 0; i <= limit; i = i + 8){
       lim = i;
       for (j = i; j <= lim + 3; j++){ 
           printf("%d ",j);
    }
 }
   printf("\n");


   printf("y = ");

   for(i = 4; i <= limit; i = i + 8){
   lim = i;

    for (j = i; j <= lim + 4; j++){ 

      if (j > 100)
      break;

      printf("%d ",j);
    }
  } 

}

讓我解釋：

在這里，我寫了2個for循環，因為根據順序，這4個連續數字之間的差為8。 由於此序列具有子序列，因此必須使用2進行循環。要刪除的元素也遵循類似的模式，因此我也將它們打印出來。