#include <stdio.h>

int main(void)
{
    int sum = 0;

    for (int i = 1; i <= 100; i += 1) {
        sum += i;               /* 불변식: sum == 1 + 2 + ... + (i - 1)... 갱신 후엔 ...+ i */
    }
    printf("sum of 1..100 = %d\n", sum);
    return 0;
}

/* 같은 일을 세 형제로 각각 적어 보고, 서로 다른 자리를 드러낸다. */
#include <stdio.h>

/* 1부터 5까지 더하기 — while */
static int sum_while(void)
{
    int sum = 0;
    int i = 1;                  /* 시작: 루프 밖에 있다 */
    while (i <= 5) {            /* 조건 */
        sum += i;
        i += 1;                 /* 갱신: 몸통 끝에 있다 — 잊기 쉬운 자리 */
    }
    return sum;
}

/* 같은 일 — for. 살림(시작·조건·갱신)이 한 줄에 모인다 */
static int sum_for(void)
{
    int sum = 0;
    for (int i = 1; i <= 5; i += 1)
        sum += i;
    return sum;
}

/* 같은 일 — do-while. 몸통을 먼저 한 번 실행한다 */
static int sum_do(void)
{
    int sum = 0;
    int i = 1;
    do {
        sum += i;
        i += 1;
    } while (i <= 5);
    return sum;
}

/* 셋의 차이가 드러나는 자리 ① — 처음부터 조건이 거짓일 때 */
static int count_while(int n)
{
    int turns = 0, i = 0;
    while (i < n) { turns++; i++; }
    return turns;
}

static int count_do(int n)
{
    int turns = 0, i = 0;
    do { turns++; i++; } while (i < n);
    return turns;
}

/* 셋의 차이가 드러나는 자리 ② — continue 가 어디로 가는가.
   for 의 갱신식은 continue 뒤에도 반드시 실행된다. while 로 옮겨 적을 때
   갱신을 몸통 끝에 두면, continue 가 그 갱신을 뛰어넘어 루프가 멈추지 않는다. */
static int odd_sum_for(void)
{
    int sum = 0;
    for (int i = 1; i <= 9; i++) {
        if (i % 2 == 0)
            continue;           /* i++ 는 그래도 실행된다 */
        sum += i;
    }
    return sum;
}

static int odd_sum_while_fixed(void)
{
    int sum = 0;
    int i = 1;
    while (i <= 9) {
        if (i % 2 == 0) {
            i++;                /* 갱신을 여기서도 해 주어야 한다 */
            continue;
        }
        sum += i;
        i++;
    }
    return sum;
}

/* do-while 이 정말로 값을 하는 자리 — 부호 없는 첨자로 거꾸로 걷기.
   size_t 는 0 아래로 내려가지 못하므로 for (size_t i = n-1; i >= 0; i--) 는
   무한 루프가 된다(41장). do-while 은 「먼저 하나 줄이고, 0 을 처리한 뒤 끝낸다」
   를 그대로 적을 수 있다. 단, 몸통이 먼저 도는 형태이므로 n 이 0 이 아니어야
   한다 — 그 검사가 이 패턴의 값과 짝을 이룬다. */
static void countdown(size_t n)
{
    if (n == 0) {                   /* do-while 의 「최소 한 번」을 막아 준다 */
        printf("  (nothing to visit)\n");
        return;
    }
    printf("  ");
    size_t i = n;
    do {
        i--;                        /* n-1 부터 0 까지 */
        printf("%s%zu", i == n - 1 ? "" : " ", i);
    } while (i > 0);
    printf("\n");
}

int main(void)
{
    printf("[the same job, three ways]\n");
    printf("  while    : 1..5 -> %d\n", sum_while());
    printf("  for      : 1..5 -> %d\n", sum_for());
    printf("  do-while : 1..5 -> %d\n", sum_do());

    printf("\n[what changes when the condition is false from the start]\n");
    printf("  while (i < 0) ran %d time(s)\n", count_while(0));
    printf("  do ... while (i < 0) ran %d time(s)\n", count_do(0));

    printf("\n[continue and the update step]\n");
    printf("  for   : sum of odd numbers 1..9 = %d\n", odd_sum_for());
    printf("  while : sum of odd numbers 1..9 = %d\n", odd_sum_while_fixed());
    printf("\n[walking backwards with an unsigned index]\n");
    countdown(6);
    countdown(1);
    countdown(0);
    printf("  do-while says it plainly: step down first, handle 0, then stop.\n");

    printf("  in the for loop i++ runs even after continue;\n");
    printf("  in the while loop the update sits in the body, so continue can skip it -\n");
    printf("  that is how a working loop turns into an endless one when it is rewritten.\n");
    return 0;
}

/* 불변식을 눈으로 보기 — 매 바퀴 성립하는 명제를 실제로 검사한다.
   assert 는 「이 자리에서 이 명제가 참이어야 한다」를 코드로 적는 도구다(17장). */
#include <assert.h>
#include <stdio.h>

/* ① 1부터 n 까지의 합 — 불변식을 표로 찍어 본다.
      몸통에 들어설 때마다 sum == 1 + 2 + ... + (i-1) 이 성립한다.
      그 오른쪽을 따로 세어 두었다가 맞대어 본다. */
static int sum_to(int n)
{
    int sum = 0;
    int checked = 0;                 /* 1 + ... + (i-1) 을 따로 셈한 값 */

    printf("   i | sum | 1+...+(i-1) | invariant\n");
    printf("  ---+-----+-------------+----------\n");
    for (int i = 1; i <= n; i++) {
        assert(sum == checked);      /* ← 매 바퀴 여기서 성립한다 */
        printf("  %2d | %3d | %11d | %s\n", i, sum, checked,
               sum == checked ? "holds" : "BROKEN");
        sum += i;                    /* 몸통이 등식을 한 칸 자라게 하고 */
        checked += i;                /* 갱신 i++ 가 다시 같은 꼴로 만든다 */
    }
    /* 종료 조건: i > n. 불변식에 i = n+1 을 넣으면 sum == 1 + ... + n */
    printf("  loop ended: sum = %d\n", sum);
    return sum;
}

/* ② 종료를 보장하는 것은 불변식이 아니라 「줄어드는 양」이다.
      아래 루프에서 그 양은 n - i 이고, 매 바퀴 정확히 1씩 준다. */
static void measure_shrinks(int n)
{
    int prev = n;                    /* 직전 바퀴의 남은 걸음 수 */
    for (int i = 0; i < n; i++) {
        int left = n - i;            /* 남은 걸음 = 줄어드는 양 */
        assert(left < prev || i == 0);
        assert(left >= 0);
        prev = left;
    }
    printf("  the quantity (n - i) fell from %d to 0, one step at a time\n", n);
}

/* ③ 이진 탐색 — 불변식이 실제로 값을 하는 자리.
      불변식: 찾는 값이 배열 안에 있다면, 그것은 반드시 [lo, hi) 안에 있다.
      구간이 매 바퀴 좁아지고(종료), 빈 구간이 되면 없는 것이다. */
static int binary_search(const int *a, int n, int key)
{
    int lo = 0, hi = n;              /* 반열림 구간 [lo, hi) */
    int steps = 0;

    while (lo < hi) {
        assert(0 <= lo && lo <= hi && hi <= n);   /* 구간이 늘 유효하다 */
        int mid = lo + (hi - lo) / 2;             /* lo+hi 로 적으면 넘칠 수 있다 */
        assert(lo <= mid && mid < hi);            /* 그래서 mid 는 구간 안이다 */
        steps++;
        if (a[mid] == key)
            return mid;
        if (a[mid] < key)
            lo = mid + 1;            /* 왼쪽 절반은 답이 아니다 */
        else
            hi = mid;                /* 오른쪽 절반은 답이 아니다 */
    }
    printf("  (%d not found in %d steps)\n", key, steps);
    return -1;
}

int main(void)
{
    printf("[the invariant of a summing loop]\n");
    int s = sum_to(5);
    printf("  1 + 2 + 3 + 4 + 5 = %d\n", s);

    printf("\n[what makes a loop end is a quantity that shrinks]\n");
    measure_shrinks(4);

    printf("\n[binary search - the invariant is the search range]\n");
    int a[] = { 2, 4, 8, 16, 32, 64, 128 };
    int n = (int)(sizeof a / sizeof a[0]);
    for (int key = 1; key <= 16; key *= 2)
        printf("  key %3d -> index %d\n", key, binary_search(a, n, key));
    printf("  key %3d -> index %d\n", 5, binary_search(a, n, 5));

    printf("\n[the empty range is not a special case - the invariant covers it]\n");
    printf("  searching an empty array for 42 -> index %d\n",
           binary_search(a, 0, 42));
    return 0;
}

/* for 의 첫 칸(clause-1)에서 무엇을 선언할 수 있는가 — 실측판.
   C23 로 빌드한다. 주석에 적은 「C99·C11 에서는」 은 -std=c11 -pedantic-errors
   로 확인한 결과다. */
#include <stdio.h>

/* ① 한 번의 선언이므로 기본 타입은 하나다. 파생 타입은 함께 적을 수 있다. */
static void one_base_type(void)
{
    int a[3] = { 10, 20, 30 };

    /* int 하나로 값·포인터·개수를 한꺼번에 만든다 */
    for (int *p = a, *end = a + 3, n = 0; p != end; p++, n++)
        printf("  a[%d] = %d\n", n, *p);

    /* for (int i = 0; double x = 0.0;) 는 문법 오류다 —
       "expected expression before 'double'" (gcc·clang 모두) */
}

/* ② 이름의 수명은 루프 하나다 — 세 칸과 몸통까지, 그리고 거기서 끝난다. */
static void scope_of_the_name(void)
{
    int i = 100;                        /* 바깥의 i */

    for (int i = 0; i < 2; i++)         /* 안쪽 i 가 바깥 i 를 가린다 */
        printf("  inside the loop i = %d\n", i);

    printf("  after the loop i = %d (the outer one was never touched)\n", i);
}

/* ②-b 수명 — 첫 칸의 변수는 루프 하나에 대해 *객체 하나*다.
      몸통 안에서 선언한 변수는 그렇지 않다: 매 바퀴 새로 태어나고 매 바퀴 죽는다. */
static void lifetime_of_the_two(void)
{
    int last_body = -1;

    for (int i = 0; i < 3; i++) {
        int body = 0;                   /* 매 바퀴 새 객체 — 그래서 늘 0 부터 */
        body++;
        last_body = body;
        printf("  turn %d: counter i = %d (one object, kept), body = %d (reborn)\n",
               i, i, body);
    }
    printf("  the body variable never grew past %d - it died at every closing brace\n",
           last_body);
}

/* ②-c 같은 객체라는 것은 주소로 확인된다 — 세 바퀴 모두 같은 주소다. */
static void one_object_one_address(void)
{
    const void *first = nullptr;

    for (int i = 0; i < 3; i++) {
        if (i == 0)
            first = (const void *)&i;
        printf("  turn %d: &i %s\n", i,
               (const void *)&i == first ? "is the same address as turn 0"
                                         : "CHANGED (would mean a new object)");
    }
    /* 루프를 벗어나면 그 객체의 수명이 끝난다. 위에서 받아 둔 주소를
       이제 와서 읽는 것은 정의되지 않은 동작이라 여기서는 쓰지 않는다.
       이름 자체도 사라진다 --- 여기서 i 를 적으면 컴파일 오류다. */
}

/* ③ C23 의 auto — 첫 칸에서 타입을 초기값으로부터 추론한다. */
static void c23_auto(void)
{
    for (auto i = 0; i < 3; i++)        /* i 는 int 로 추론된다 */
        printf("  auto i = %d\n", i);
}

/* ④ C23 은 저장 클래스 제약을 없앴다 — 그래서 static 도 적을 수 있다.
      적을 수 있다는 것과 적어야 한다는 것은 다르다. 이 함수가 그 이유다. */
static void static_counter(void)
{
    for (static int calls = 0; calls < 2; calls++)
        printf("  static clause-1: this line ran (calls = %d)\n", calls);
}

int main(void)
{
    printf("[one declaration means one base type]\n");
    one_base_type();

    printf("\n[the name lives in the loop and nowhere else]\n");
    scope_of_the_name();

    printf("\n[the counter lives for the whole loop, a body variable does not]\n");
    lifetime_of_the_two();

    printf("\n[one object means one address]\n");
    one_object_one_address();

    printf("\n[C23: auto infers the type from the initializer]\n");
    c23_auto();

    printf("\n[C23: a static object in clause-1 is initialized once, ever]\n");
    printf("  first call:\n");
    static_counter();
    printf("  second call:\n");
    static_counter();
    printf("  third call:\n");
    static_counter();
    printf("  the second and third calls print nothing - the counter kept its\n");
    printf("  value from the first call, so the loop never ran again.\n");
    return 0;
}

/* 조건 칸은 「검사」가 아니라 매 바퀴 실행되는 코드다 — 그 값을 재어 본다. */
#include <stdio.h>

static int limit_calls = 0;

/* 매 바퀴 불리면서 자기가 몇 번 불렸는지 센다 */
static int limit(void)
{
    limit_calls++;
    return 5;
}

static int probe_calls = 0;

static int probe(int i)
{
    probe_calls++;
    return i < 3;
}

int main(void)
{
    printf("[the condition runs once more than the body]\n");
    int turns = 0;
    for (int i = 0; i < limit(); i++)
        turns++;
    printf("  body ran %d times, limit() was called %d times\n", turns, limit_calls);
    printf("  the last call is the one that fails and ends the loop\n");

    printf("\n[short-circuit can skip the side effect entirely]\n");
    probe_calls = 0;
    int guard = 0;                       /* 왼쪽이 거짓이면 오른쪽은 평가되지 않는다 */
    for (int i = 0; guard && probe(i); i++)
        ;
    printf("  guard is false: probe() was called %d time(s)\n", probe_calls);
    probe_calls = 0;
    guard = 1;
    turns = 0;
    for (int i = 0; guard && probe(i); i++)
        turns++;
    printf("  guard is true : probe() was called %d time(s), body ran %d times\n",
           probe_calls, turns);

    printf("\n[assignment inside the condition - the parentheses are the point]\n");
    const char *text = "abc";
    const char *p = text;
    int c = 0, seen = 0, first = 0;
    while ((c = *p++) != '\0') {         /* 담고 나서 비교한다 */
        if (seen == 0)
            first = c;
        seen++;
    }
    printf("  with parentheses   : read %d characters, first value stored = %d ('%c')\n",
           seen, first, (char)first);

    p = text;
    seen = 0;
    first = 0;
    while ((c = (*p++ != '\0'))) {       /* 비교부터 하면 0 또는 1 만 담긴다 */
        if (seen == 0)
            first = c;
        seen++;
    }
    printf("  without parentheses: read %d characters, first value stored = %d\n",
           seen, first);
    printf("  the character is gone - only the truth value was kept\n");
    printf("  gcc says: suggest parentheses around assignment used as truth value\n");

    printf("\n[changing the counter inside the condition]\n");
    int n = 3;
    printf("  while (i < n)  visits:");
    for (int i = 0; i < n; i++)
        printf(" %d", i);
    printf("\n  while (i++ < n) visits:");
    int i = 0;
    while (i++ < n)
        printf(" %d", i);
    printf("\n  while (++i < n) visits:");
    i = 0;
    while (++i < n)
        printf(" %d", i);
    printf("\n  i++ added 1 before the body saw i: 1..3 instead of 0..2,\n");
    printf("  and ++i also compares the new value, so it turns one time fewer\n");
    return 0;
}

/* 겹쳐 도는 루프 — 이중과 삼중, 그리고 겹칠 때 새로 생기는 실수들. */
#include <stdio.h>

/* ① 이중 for — 바깥 한 바퀴마다 안쪽이 처음부터 다시 돈다 */
static void times_table(void)
{
    for (int row = 2; row <= 4; row++) {
        printf("  ");
        for (int col = 1; col <= 5; col++)
            printf("%s%2d x %d = %2d", col == 1 ? "" : "   ", row, col, row * col);
        printf("\n");                    /* 안쪽 루프가 끝난 자리 = 한 줄의 끝 */
    }
}

/* ② 안쪽 루프 변수를 바깥에서 만들면 「다시 처음부터」가 사라진다 */
static void forgot_to_reset(void)
{
    int visits = 0;
    int col = 1;                         /* 초기화가 바깥에 있다 */
    for (int row = 2; row <= 4; row++)
        for (; col <= 5; col++)          /* 두 번째 바퀴부터 col 은 이미 6 이다 */
            visits++;
    printf("  counter declared outside : %d cells visited\n", visits);

    visits = 0;
    for (int row = 2; row <= 4; row++)
        for (int c = 1; c <= 5; c++)     /* 안쪽에서 선언하면 매 바퀴 새로 시작한다 */
            visits++;
    printf("  counter declared inside  : %d cells visited\n", visits);
}

/* ③ 안쪽에서 바깥 카운터를 올리는 실수 (실제 사례의 패턴).
      멈추게 하려고 한도를 두었다 — 실제 코드에는 그런 안전장치가 없다. */
static void wrong_counter(void)
{
    int steps = 0;
    for (int j = 0; j < 3; j++) {
        for (int k = 0; k < 3; j++) {    /* k 가 아니라 j 를 올리고 있다 */
            steps++;
            if (steps >= 100)            /* 이 줄이 없으면 끝나지 않는다 */
                break;
        }
        if (steps >= 100)
            break;
    }
    printf("  wrong counter (k stands still): %d steps and still not done\n", steps);

    steps = 0;
    for (int j = 0; j < 3; j++)
        for (int k = 0; k < 3; k++)
            steps++;
    printf("  right counter                : %d steps, 3 x 3 as intended\n", steps);
}

/* ④ 삼중 for — 세 값을 한꺼번에 훑는 전형. 피타고라스 세 쌍을 찾는다. */
static void triples(int n)
{
    long long tries = 0;
    int found = 0;

    for (int a = 1; a <= n; a++)
        for (int b = a; b <= n; b++)             /* b 를 a 부터 시작해 중복을 없앤다 */
            for (int c = b; c <= n; c++) {
                tries++;
                if (a * a + b * b == c * c) {
                    printf("  %2d^2 + %2d^2 = %2d^2\n", a, b, c);
                    found++;
                }
            }
    printf("  n = %d: %d triple(s) found in %lld checks\n", n, found, tries);
}

int main(void)
{
    printf("[a double loop - the inner one restarts every outer turn]\n");
    times_table();

    printf("\n[where the inner counter is declared decides whether it restarts]\n");
    forgot_to_reset();

    printf("\n[raising the wrong counter in the inner loop]\n");
    wrong_counter();

    printf("\n[a triple loop - Pythagorean triples up to n]\n");
    triples(20);

    printf("\n[how fast the work grows]\n");
    for (int n = 10; n <= 40; n *= 2) {
        long long steps = 0;
        for (int a = 1; a <= n; a++)
            for (int b = 1; b <= n; b++)
                for (int c = 1; c <= n; c++)
                    steps++;
        printf("  n = %2d -> %lld steps (n^3)\n", n, steps);
    }
    return 0;
}