K&R 练习 1-21 - 心理不理解

Question

“不可能的”K&R 练习。

“编写一个程序 entab 来替换 最少的空格字符串 要实现的制表符和空白的数量 相同的间距。使用相同的选项卡 停止，比如说每 n 列。应该 是一个变量或符号 参数？”

我遇到的问题是，我不确定如何正确执行此操作。我知道这不是很有解释性，但这几乎就是这里的问题。我见过的大多数示例都计算了一个数字空白，并用选项卡替换了这些系列，但这不是它的要求，我想我明白它的要求，但目前感觉无法做到这一点

:)

编辑：我写的代码。远可以在这里找到。

Answer 1

如果您的问题是“这要我做什么？”我想我可以通过解释原来的问题（以不同的方式提出相同的问题）来提供帮助。

编写一个程序，将带空格的文本作为输入文本，并尽可能使用制表符生成视觉上等效的文本作为输出。

例如，每 8 个字符就有一个制表位，并将空格显示为“.”制表符为“-”；

input;
".foo:...bar;......#comment"
output;
".foo:-bar;-..#comment"

input;
".......-foo:.....bar;......#comment"
output;
"-foo:-.bar;-...#comment"

编写程序，以便制表符参数 n 可以变化，即允许 n 的值为 8 以外的值。准备好证明您的决定是否合理，使 na 为常量或变量。

编辑我查看了您的代码，我认为它比需要的更复杂。我的建议是一次只做一个角色。无需缓冲整行。在读取每个字符时保持列计数（“\n”将其重置为零，“\t”将其增加 1 或更多，其他字符将其增加）。当您看到空格（或制表符）时，不要立即发出任何内容，开始插入过程，发出零个或多个制表符，然后发出空格（在“\n”或非空白字符处，以先到者为准）。

最后一点提示是，状态机可以使这种算法更容易编写、验证、测试和读取。

编辑2为了让OP接受我的答案，我现在已经根据我上面提供的提示和我在讨论中的评论，自己实际编写了一个解决方案。

// K&R Exercise 1-21, entab program, for Stackoverflow.com
#include <stdio.h>
#define N 4     // Tabstop value. Todo, make this a variable, allow
                //  user to modify it using command line

int main()
{
    int col=0, base_col=0, entab=0;

    // Loop replacing spaces with tabs to the maximum extent
    int c=getchar();
    while( c != EOF )
    {

        // Normal state
        if( !entab )
        {

            // If whitespace goto entab state
            if( c==' ' || c=='\t' )
            {
                entab = 1;
                base_col = col;
            }

            // Else emit character
            else
                putchar(c);
        }

        // Entab state
        else
        {

            // Trim trailing whitespace
            if( c == '\n' )
            {
                entab = 0;
                putchar( '\n' );
            }

            // If not whitespace, exit entab state
            else if( c!=' ' && c!='\t' )
            {
                entab = 0;

                // Emit tabs to get close to current column position
                //  eg base_col=1, N=4, col=10
                //  base_col + 3 = 4 (1st time thru loop)
                //  base_col + 4 = 8 (2nd time thru loop)
                while( (base_col + (N-base_col%N)) <= col )
                {
                    base_col += (N-base_col%N);
                    putchar( '\t' );
                }

                // Emit spaces to close onto current column position
                // eg base_col=1, N=4, col=10
                //  base_col -> 8, and two tabs emitted above
                //  base_col + 1 = 9 (1st time thru this loop)
                //  base_col + 1 = 10 (2nd time thru this loop)
                while( (base_col + 1) <= col )
                {
                    base_col++;
                    putchar( ' ' );
                }

                // Emit buffered character after tabs and spaces
                putchar( c );
            }
        }

        // Update current column position for either state
        if( c == '\t' )
            col += (N - col%N); // eg col=1, N=4, col+=3
        else if( c == '\n' )
            col=0;
        else
            col++;

        // End loop
        c = getchar();
    }
    return 0;
}

Answer 2

我有点晚了，但这是我自己解决的方法。这是与上面分享的方法不同的方法，因此如果您有任何评论/反馈，请分享。

查看我在 Github 上的公开要点以获取源代码。代码中有注释，并且该方法在文件顶部进行了解释，但我将其复制并粘贴到此处，以便从一开始就清晰逻辑。

方法：

• 我们将跟踪遇到的空格数量（非制表符/非空格字符之间）

• 我们将跟踪每个输入行的字符（不是制表符/空格/换行符）

• 我们将通过以下方式评估空格产生的“间隙”：

  • 评估这些字符之间是否有空格数。

  • 当空格数 >= TABSIZE 时，间隙将“足够大”

  • 然后，对于“缓冲区”中所有剩余的空间，我们将单独打印它们

最后，我们打印出读入的字符（不是制表符/空白）

如有必要，还可更新空格数和字符数。

从各种意义上来说，我仍然是一个新手程序员，所以我不确定它与此处发布的其他解决方案相比如何，但逻辑似乎更容易遵循（至少对我来说）。

希望这对以后的人有帮助！

Answer 3

我同意你的评价。用制表符替换每 n 个空格是不够的；例如，如果 n == 4，则“hi Blank Blank Blank Blank”不应替换为“hi Tab”，而应替换为“hi Tab Blank Blank”。

听起来您需要做的是在阅读每一行时跟踪当前位置，并使用此信息来确定您需要多少个选项卡。这有帮助吗？如果您需要更多详细信息，请告诉我！

至于“变量与符号参数”部分，两者都肯定是可行的，但我可以想到使用变量的一个显着优点：您可以针对不同的 n 值运行程序而无需重新编译。

Answer 4

让我提供另一个至少处理提供顶级答案的案例。但它只处理一根字符串。

假设列表是至少包含2个空格的东西。

1. 让我们跟踪尾随空格的数量。 \
2. 如果最后一个符号和当前符号都是空格，则可能是一个列表。 \
3. 当尾随空格数等于 tabulation stop 时：将主计数器设置为 counter - tabulation stop - 1 （当我们使用数组时），然后将位置分配给 \t
4. 移位计数器后变量，其他符号照常写入

/*
Write a program that takes as input text with spaces
and produces as output visually equivalent text using tabs to the maximum extent possible.

f.e. tab=4

input:
".foo:...bar;......#comment"
output:
".foo:-bar;-..#comment"

input:
".......-foo:.....bar;......#comment"
output:
"-foo:-.bar;-...#comment"
*/

#include <stdio.h>

#define MAXLINE 24
#define TABSTOP 4

int entab(char s[]);

int main() {
    char s[MAXLINE];

    entab(s);
    printf("%s\n", s);

    return 0;
}

int entab(char s[]) {
    int i;
    int j;
    char c;

    for (i = 0, j = 1; i < MAXLINE - 1 && ((c = getchar()) != '\n'); ++i) {
        // entab state
        if (i > 0 && s[i - 1] == ' ' && c == ' ') {
            ++j;
            if (j == TABSTOP) {
                i -= TABSTOP - 1;
                j = 1;
                s[i] = '\t';
            } else
                s[i] = c;
        }
        // Normal state
        else
            s[i] = c;
    }
    if (c == '\n') {
        s[i] = c;
        ++i;
    }
    s[i] = '\0';

    return 0;
}

Answer 5

我的理解是，你不必真正知道问题是什么或如何解决它才能回答这个问题。这个问题似乎是在问您是否理解何时使用变量而不是“符号参数”。我实际上不确定“符号参数”是什么意思；这似乎是过时的术语。

话虽如此，解决问题的第一部分（用制表符替换空格）相当简单。思考除法和余数。

Answer 6

我粗略地查看了你的代码，没有发现任何明显错误的地方。

因此，我的建议是要么在调试器中单步执行一些输入示例，一边检查变量值，要么添加一大堆调试打印语句。无论哪种情况，您的目标都是找到程序状态开始偏离您的预期或意图的点。

Answer 7

我目前正在研究 KnR，并浏览了此页面：

练习答案

您的练习位于：

• 解决方案

  • 第 1 章 - 教程简介

    • 前第 21 页第 34 页

      users.powernet.co.uk/eton/kandr2/krx121.html

希望您发现这很有用。

真挚地，
Morpfh

1：http://users.powernet.co.uk/eton/kandr2/index.html “C 编程语言” ，第二版，Kernighan 和 Ritchie - 练习答案

Answer 8

在上面评价最高的答案中，该程序过于复杂。
为了简化答案的这一部分，我附加了一个更简单的代码，希望以 K&R 的风格编写（主要是通过使用 ++ 内联递增）。

包括

定义 TAB 4

int main(){

char newsentence[255],c;
int spacecount = 0, oldsentencepointer = 0, newsentencepointer = 0;

printf("Give me a sentence please:\n");

while ((c = getchar()) != '\n') {
    if ((oldsentencepointer != 0) && (oldsentencepointer % TAB == 0) && (spacecount > 0))
       {
        newsentencepointer -= spacecount;         //if at tabstop, and spaces and not
                                                    first, go back to 1st space, set tab.
        newsentence[newsentencepointer++] = '\t';
        spacecount = 0;
        }

    if (c == ' ') {
        newsentence[newsentencepointer++] = ' ';
        spacecount++;                       //keep track of spaces before tab stop
    }

    else if (c == '\t') {
        newsentence[newsentencepointer++] = '\t' ;
        oldsentencepointer = TAB;   //set old pointer to TAB (does not matter if actual,
                                      only cadence important)
        continue;                   //continue from here so as not to increment 
                                      old sentence counter.
        }

    else {
        newsentence[newsentencepointer++] = c ;   //write whatever was old into new.
        spacecount = 0;                           //reset space counter.
        }

    oldsentencepointer++;

}

newsentence[newsentencepointer] = '\0';    //cap it off.

puts(newsentence);

return 0;

}

Answer 9

有一个更简洁的解决方案，尽管它没有采用可用的最佳代码实践（滥用短路评估、通过 continue 的尴尬控制流、有点奇怪的“空间”循环）。

#include <stdio.h>

#define TS 8

int main(int arg, char *argv[]) {
    int counter = 0, space_counter = 0, c;
    while ((c = getchar()) != EOF) {
        ++counter;
        if (c == ' ' && ++space_counter && (counter % TS) == 0) {
            space_counter = 0;
            c = '\t';
        } else if (c == '\t') {
            counter = space_counter = 0;
        } else if (c != ' ') {
            while (space_counter--)
                putchar(' ');
            space_counter = 0;
            if (c == '\n')
                counter = 0;
        } else {
            continue; /* don't call putchar(c) */
        }
        putchar(c);
    }
    return 0;
}

除空格外，读取的每个字符都会逐字打印。而是计算空白。如果程序遇到非空白字符，它会打印之前计数的空白字符，然后重置该计数器。如果遇到空白，它会通过第二个计数器（从行开头/最后一个制表符开始打印的字符）检查光标是否位于制表符上。如果是，则打印一个制表符，否则仅计算空白。

输入中的制表符用于重置空格计数器并输出制表符，从而消除该过程中任何多余的空白。