我正在尝试在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
答案 0 :(得分：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;
}
答案 1 :(得分：0)
问题规范是自我不一致的。它指定：
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
至少有两个问题：
x行应以96 97 98 99结尾，y行应以92 93 94 95结尾（也可能100，如果应包括在内输出）。问题中的代码存在缺陷，因为它使用k = i; k = i % divisor;的方式，并且因为没有必要的嵌套循环结构。我认为严格来说你可以编写没有嵌套循环的代码，但使用嵌套循环更简单。
两条线的显示有点不方便，所以最好将它们包裹在合适的长度。下面的代码处理这些不同的问题。它利用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个字符。您可以通过line_wid调整num_wid + 1来解决此问题。代码还可以检查major是否至少与minor一样大，并且两者都是严格正数;另外line_wid对于标记，=和至少一个数字来说足够大。有一个GIGO的元素 - 如果你提供虚假参数，输出将相应虚假。
答案 2 :(得分：-1)
我已经编写了一个具有两行输出的代码 第一行由x值组成，第二行由y值组成。 希望这会帮助你。
divTag = soup.find("div", {"class":"dataCol col02 inlineEditWrite"})
for tag in divTag:
tdTags = tag.find_all("td")
print (tdTags[0].text)
让我解释一下：
这里我写了2个for循环，因为根据序列，4个连续数字之间的差异为8。 由于此序列具有子序列，因此必须使用2作为循环。要删除的元素也遵循类似的模式，因此，我也打印它们。