คำสั่งวนซ้ำ while loop ในภาษา C

30 April 2021

ในบทนี้ คุณจะได้เรียนรู้การใช้งานคำสั่ง while loop ในภาษา C สำหรับควบคุมเพื่อให้โปรแกรมทำงานซ้ำๆ จากเงื่อนไขที่กำหนด เราจะพูดถึงการใช้งานคำสั่ง while loop ในพื้นฐาน และตัวอย่างการประยุกต์ใช้ในการเขียนโปรแกรมรูปแบบต่างๆ นี่เป็นเนื้อหาในบทนี้

  • การใช้งานคำสั่ง while loop
  • การใช้ลูปเพื่อนับตัวเลขถอยหลัง
  • การตรวจสอบจำนวนเฉพาะ
  • การใช้คำสั่ง while loop กับอาเรย์
  • การกำหนด loop ที่ซ้อนกัน
  • การแยกตัวประกอบของตัวเลข

การใช้งานคำสั่ง while loop

คำสั่ง while loop เป็นคำสั่งวนซ้ำที่เป็นพื้นฐานและเรียบง่ายที่สุดในภาษา C มันใช้สำหรับควบคุมเพื่อให้โปรแกรมทำงานบางอย่างซ้ำๆ จากเงื่อนไขที่กำหนด ซึ่งการทำงานในรูปแบบนี้เป็นเรื่องปกติในการเขียนโปรแกรม นี่เป็นรูปแบบการใช้งานคำสั่ง while loop ในภาษา C

while (condition) {
    // statements
}

ในการใช้งานคำสั่ง while loop นั้นจะประกอบไปด้วยสองส่วนคือ การกำหนดเงื่อนไข condition สำหรับลูปเพื่อทำงานและส่วนของคำสั่งที่ต้องการให้ทำงานในขณะที่เงื่อนไขเป็นจริง ซึ่งเราจะกำหนดภายในบล็อค {} ของคำสั่ง

เงื่อนไขสามารถเป็นนิพจน์ใดๆ ที่เป็น Boolean หรือสามารถประเมินค่าเป็น Boolean และในขณะที่โปรแกรมทำงานในลูป เมื่อถึงบางช่วงจังหวะคุณต้องทำให้เงื่อนไขเป็นเท็จเพื่อจบการทำงานของลูป ไม่เช่นนั้นโปรแกรมจะทำงานในลูปตลอดไปหรือเรียกว่า Infinity loop

สำหรับตัวอย่างแรกในบทนี้ เรามาเริ่มต้นด้วยการเขียนโปรแกรมนับเลขจาก 1-10 โดยการใช้งานคำสั่ง while loop ในภาษา C ซึ่งมันเป็นตัวอย่างที่เรียบง่ายที่สุดสำหรับแสดงการใช้งานลูป เป็นตัวอย่างของโปรแกรม

counting_numbers.c
#include <stdio.h>

int main()
{
    int n = 1;
    while (n <= 10) {
        printf("%d\n", n);
        n++;
    }
    printf("Loop ended\n", n);
    return 0;
}

นี่เป็นผลลัพธ์การทำงานของโปรแกรม

1
2
3
4
5
6
7
8
9
10
Loop ended

นี่เป็นตัวอย่างพื้นฐานสำหรับการใช้งานคำสั่ง while loop ลูป เราได้ใช้มันนับตัวเลขจาก 1-10 และแสดงค่าออกทางหน้าจอ ต่อไปมาดูคำอธิบายในแต่ละส่วนว่าโปรแกรมทำงานอย่างไร

int n = 1;

เราเริ่มต้นจากการประกาศตัวแปร n ที่มีค่าเป็น 1 สำหรับใช้ในการนับเลข นี่เป็นการกำหนดค่าเริ่มต้นสำหรับคำสั่ง while loop เพื่อทำงาน ซึ่งมักจะทำก่อนที่ลูปจะเริ่มทำงานหรือก่อนจะถึงบล็อคของคำสั่ง while loop

while (n <= 10) {
    printf("%d\n", n);
    n++;
}

จากนั้นเป็นการสร้างลูปโดยการกำหนดเงื่อนไขเป็น n <= 10 นี่หมายความว่าเราต้องการให้โปรแกรมทำงานในลูปในขณะตัวแปร n มีค่าน้อยกว่าหรือเท่ากับ 10 และภายในบล็อคของคำสั่ง while loop เราได้แสดงค่าของตัวแปรออกทางหน้าจอ

n++;

ในตอนท้ายของลูป เราเพิ่มค่าในตัวแปร n ขึ้นไปหนึ่งค่า นี่เป็นคำสั่งที่จะทำให้ค่าในตัวแปรเพิ่มขึ้นเรื่อยๆ สำหรับการทำงานแต่ละรอบของลูป จนกระทั่งค่าในตัวแปรมากว่า 10 ซึ่งนี่จะทำให้เงื่อนไขเป็นเท็จและลูปจบการทำงาน

คุณสามารถลองเปลี่ยนคำสั่งเพิ่มค่าในตัวแปร n ให้เพิ่มค่าทีละสองได้ ยกตัวอย่างเช่น

n += 2;

จากนั้นรันโปรแกรมอีกครั้ง และนี่เป็นผลลัพธ์การทำงานของโปรแกรม

1
3
5
7
9
Loop ended

ในรอบนี้ จะเห็นว่าโปรแกรมทำงานในลูปเพียง 5 รอบเท่านั้น เนื่องจากตัวเลขเพิ่มขึ้นทีละสอง และทำให้เงื่อนไขเป็นเท็จเร็วขึ้น ดังนั้น กล่าวคือภายในบล็อคของคำสั่ง while loop คุณมีหน้าที่ควบคุมการทำงานของลูปเพื่อจบการทำงานในแบบที่ต้องการ

การใช้ลูปเพื่อนับตัวเลขถอยหลัง

ต่อไปเป็นตัวอย่างการใช้คำสั่ง while loop สำหรับสร้างตัวนับถอยหลังเพื่อปล่อยจรวดไปยังอวกาศอันไกลโพ้น อาจเป็นดาวอังคารหรือที่ไหนสักแห่งซึ่งเราก็ไม่แน่ใจ แต่นี่เป็นโค้ดสำหรับภาระกิจการปล่อยจรวดของเรา

count_down.c
#include <stdio.h>

int main()
{
    int n = 10;
    printf("Count down started\n", n);
    while (n >= 0) {
        printf("%d\n", n);
        n--;
    }
    printf("Now! Firing the Rocket\n", n);
    return 0;
}

นี่เป็นผลลัพธ์การทำงานของโปรแกรม

Count down started
10
9
8
7
6
5
4
3
2
1
0
Now! Firing the Rocket

นี่เป็นโปรแกรมนับถอยหลังโดยมันจะเริ่มจาก 10 สำหรับการปล่อยจรวด คุณสามารถจินตนาการได้ว่าคุณจะใช้มันทำอะไรก็ได้ ไม่ใช่เพียงแค่การปล่อยจรวด

int n = 10;

คล้ายกับตัวอย่างก่อนหน้า เรากำหนดค่าเริ่มต้นในตัวแปร n เป็น 10 เนื่องจากเราต้องการนับตัวเลขถอยหลังจาก 10 จากนั้นกำหนดเงื่อนไขในคำสั่ง while loop เป็น n >= 0 ซึ่งหมายความว่าโปรแกรมจะทำงานในลูปในขณะที่ค่าในตัวแปรนั้นมากกว่าหรือเท่ากับ 0

n--;

และสิ่งที่เราต้องทำกับ loop นี้เพื่อให้มันจบการทำงานก็คือลดค่าในตัวแปร n ลงทีละ 1 ในแต่ละรอบของการทำงานในลูป นั่นจะทำให้เมื่อค่าในตัวแปรน้อยกว่า 0 โปรแกรมจบการทำงาน และจรวดถูกปล่อยในตอนท้ายของโปรแกรม

ตัวอย่างนี้ไม่ได้มีอะไรพิเศษไปจากตัวอย่างก่อนหน้า เราเพียงแค่เปลี่ยนวิธีการนับตัวเลขจากเดินหน้าเป็นถอยหลังเท่านั้น แต่นี่จะช่วยให้คุณเห็นความหลากหลายของการนำลูปมาใช้งานในการเขียนโปรแกรม นั่นคือคุณสามารถใช้ลูปทำอะไรก็ได้ที่มีการทำงานซ้ำๆ ในกรณีนี้คือการนับเลขนั่นเอง

การตรวจสอบจำนวนเฉพาะ

ในตัวอย่างก่อนหน้า เราได้แสดงการนับเลขโดยการใช้ลูป นี่เป็นตัวอย่างพื้นฐานในการเรียนรู้การใช้งานลูปที่สามารถเข้าใจได้ง่าย ต่อไปมาดูตัวอย่างของการใช้งานลูปที่เริ่มซับซ้อนขึ้น

คุณคงจะทราบว่าจำนวนเฉพาะคือตัวเลขจำนวนเต็มที่มากกว่า 1 ที่มีเพียงตัวเลขสองตัวเท่านั้นที่หารลงตัวนั่นคือ 1 และตัวมันเอง และใช่แล้ว ในตัวอย่างนี้ เราจะมาเขียนโปรแกรมเพื่อตรวจสอบว่าตัวเลขเป็นจำนวนเฉพาะหรือไม่ นี่เป็นตัวอย่างของโปรแกรม

prime_number.c
#include <stdio.h>

int main()
{
    printf("Prime number checker\n");
    printf("Enter a number: ");

    int n;
    scanf("%d", &n);

    int divisible = 0;
    int i = 1;
    while (i <= n) {
        if (n % i == 0) {
            divisible++;
        }
        i++;
    }

    if (divisible == 2) {
       printf("%d is prime number\n", n);
    } else {
       printf("%d is not prime number\n", n);
    }
    return 0;
}

นี่เป็นผลลัพธ์การทำงานของโปรแกรมจากการรันโปรแกรมสองครั้ง และเรากรอกตัวเลขเป็น 5 และ 18 ตามลำดับ

Prime number checker
Enter a number: 5
5 is prime number
Prime number checker
Enter a number: 18
18 is not prime number

นี่เป็นตัวอย่างของโปรแกรมสำหรับตรวจสอบว่าตัวเลขเป็นจำนวนเฉพาะหรือไม่ โดยรับค่าที่ต้องการตรวจสอบผ่านทางคีย์บอร์ด ต่อไปเป็นการอธิบายว่าแต่ละส่วนของโปรแกรมมีการทำงานอย่างไร

int n;
scanf("%d", &n);

ในตอนที่โปรแกรมเริ่มต้น เราได้ประกาศตัวแปร n และรับค่ามาจากคีย์บอร์ด นี่เป็นตัวเลขที่จะนำมาตรวจสอบว่ามันเป็นจำนวนเฉพาะหรือไม่

int divisible = 0;
int i = 1;

และนี่เป็นการกำหนดเงื่อนไขเริ่มต้นสำหรับลูปเพื่อทำงาน โดยเราจะใช้ตัวแปร i เป็นตัวนับจาก 1-n เพื่อวนหาตัวเลขทั้งหมดที่หาร n ลงตัว และถ้าหากมีการหารลงตัวเกิดขึ้น เรานับมันด้วยตัวแปร divisible

while (i <= n) {
    if (n % i == 0) {
        divisible++;
    }
    i++;
}

ดังนั้นเราสร้าง while loop โดยกำหนดเงื่อนไขเป็น i <= n เราจะค้นหาตัวเลขที่อยู่ระหว่าง 1 - n ว่ามีตัวเลขไหนที่หาร n ลงตัวบ้าง ทุกครั้งที่มีการหารลงตัว เราใช้ตัวแปร divisible สำหรับนับ จากนั้นเพิ่มค่าค่าในตัวแปร i ขึ้นไป 1 เพื่อตรวจสอบตัวเลขใหม่ในลูปถัดไป

if (divisible == 2) {
    printf("%d is prime number\n", n);
} else {
    printf("%d is not prime number\n", n);
}

และเมื่อลูปจบการทำงาน เราจะทราบว่ามีกี่จำนวนที่หาร n ลงตัว และเนื่องจากเราตรวจสอบตัวเลขทั้งหมดจาก 1-n ถ้าหากมันเป็นจำนวนเฉพาะ นั่นหมายความว่าค่าที่นับได้จากตัวแปร divisible จะมีค่าเท่ากับ 2 และเราใช้มันเป็นเงื่อนไขในการตรวจสอบ

มีอีกหลายวิธีที่สามารถใช้ในการตรวจสอบว่าตัวเลขเป็นจำนวนเฉพาะ สำหรับตัวอย่างนี้ เราเลือกวิธีการเขียนที่ตรงไปตรงมาโดยหลีกเลี่ยงคำสั่งอื่น เช่นคำสั่ง break เนื่องจากเราต้องการมุ่งเน้นที่การใช้งานคำสั่ง while loop เป็นหลัก

การใช้คำสั่ง while loop กับอาเรย์

อาเรย์เป็นประเภทข้อมูลในภาษา C ที่เก็บข้อมูลในรูปแบบของลำดับ และแต่ละค่าในอาเรย์สามารถเข้าถึงได้จาก Index ที่เป็นลำดับต่อเนื่องกัน ดังนั้นการใช้งานลูปกับอาเรย์ ทำให้เราสามารถวนอ่านค่าทั้งหมดในอาเรย์ได้อย่างง่ายดาย

ในตัวอย่างนี้เป็นการใช้งานคำสั่ง while loop กับอาเรย์ เรามาเขียนโปรแกรมสำหรับหาผลรวมและค่าเฉลี่ยของตัวเลขในอาเรย์ นี่เป็นตัวอย่าง

sum_n_average.c
#include <stdio.h>

int main()
{
    int numbers[] = {10, 3, 5, 12, 6, 8, 9};
    int size = sizeof(numbers) / sizeof(int);

    int i = 0;
    int sum = 0;
    while (i < size) {
        sum += numbers[i];
        i++;
    }

    printf("Sum: %d\n", sum);
    printf("Average: %f\n", sum / (float)size);
    return 0;
}

นี่เป็นผลลัพธ์การทำงานของโปรแกรม

Sum: 53
Average: 7.571429

ในตัวอย่าง เป็นโปรแกรมสำหรับหาผลรวมและค่าเฉลี่ยของตัวเลขในอาเรย์ คุณสามารถจินตนาการได้ว่าอาเรย์สามารถมีสมาชิกเท่าไหร่ก็ได้ และเราสามารถวนมันได้ด้วยคำสั่ง loop

int numbers[] = {10, 3, 5, 12, 6, 8, 9};
int size = sizeof(numbers) / sizeof(int);

นี่เป็นประกาศอาเรย์เริ่มต้นสำหรับหาผลรวมและค่าเฉลี่ย และเพื่อนับจำนวนสมาชิกในอาเรย์ ฟังก์ชัน sizeof ส่งค่ากลับเป็นไบท์ของข้อมูล เมื่อเราหารขนาดของอาเรย์และขนาดของประเภทข้อมูลของอาเรย์ int เราจะได้จำนวนของสมาชิกทั้งหมดในอาเรย์และเก็บในตัวแปร size

นั่นหมายความว่าหากคุณเพิ่มตัวเลขเข้าไปในอาเรย์ ขนาดของมันจะถูกคำนวณหาอัตโนมัติ ซึ่งเป็นวิธีทียืดหยุ่นสำหรับตรวจสอบขนาดของอาเรย์ในตอนที่โปรแกรมทำงาน

int i = 0;
int sum = 0;

จากนั้นเราประกาศตัวแปร i ที่จะใช้เป็น Index เพื่อวนอ่านค่าในอาเรย์ และตัวแปร sum สำหรับเก็บผลรวมของตัวเลขในอาเรย์

while (i < size) {
    sum += numbers[i];
    i++;
}

และเริ่มต้น while loop ด้วยการกำหนดเงื่อนไขเป็น i < size นั่นเป็นเพราะ Index ของอาเรย์จะเริ่มจาก 0 ไปจนถึง size - 1 นัั่นเอง จากนั้นภายในลูปนำแต่ละค่าในอาเรย์ numbers[i] มาบวกเก็บไว้ในตัวแปร sum และเพิ่มค่าในตัวแปร i ขึ้นไปหนึ่งสำหรับค่าต่อไปของอาเรย์

printf("Sum: %d\n", sum);
printf("Average: %f\n", sum / (float)size);

เมื่อลูปจบการทำงาน เราจะได้รับผลรวมของตัวเลขในอาเรย์เก็บไว้ในตัวแปร sum เราสามารถหาค่าเฉลี่ยได้จากนำผลรวมหารด้วยจำนวนสมาชิกทั้งหมดในอาเรย์ และแสดงผลสรุปออกทางหน้าจอ

การกำหนด loop ที่ซ้อนกัน

เหมือนกับคำสั่งควบคุมประเภทอื่นๆ ลูปสามารถที่จะซ้อนกันได้ การใช้งานของลูปในลักษณะนี้มักใช้กับอาเรย์สองมิติ หรือการทำงานในรูปแบบของตาราง M x N เช่นเมื่อต้องการทำงาน M อย่าง และในแต่ละอย่างจะมีงานที่ต้องการทำอีก N อย่าง

เราจะเริ่มจากตัวอย่างง่ายๆ เราคิดว่าคุณคงจะเคยเล่นหรือเห็นตารางของหมากรุกมาก่อน มาสร้างตารางของหมากรุกโดยการใช้คำสั่ง while loop แบบซ้อนกันในภาษา C นี่เป็นตัวอย่าง

chess_table.c
#include <stdio.h>

int main()
{
    int M = 8, N = 8;
    int i = 0;
    while (i < M) {
        int j = 0;
        while (j < N) {
            if ((i + j) % 2 == 0) {
                printf("X");
            } else {
                printf(" ");
            }
            j++;
        }
        printf("\n");
        i++;
    }
    return 0;
}

นี่เป็นผลลัพธ์การทำงานของโปรแกรม

X X X X
 X X X X
X X X X
 X X X X
X X X X
 X X X X
X X X X
 X X X X

ในตัวอย่างนี้เราได้สร้างตารางของหมากรุกด้วยคำสั่ง while loop แบบซ้อนกัน ที่มีขนาด 8 แถวและ 8 หลัก

int M = 8, N = 8;
int i = 0;

นี่เป็นการกำหนดค่าเริ่มต้นสำหรับ while loop เพื่อทำงาน ในการเขียนโปรแกรมแบบลูปซ้อนกัน ให้คิดว่าแต่ละลูปนั้นมีการทำงานของมันเอง เนื่องจากงานของเราคือต้องการสร้างตารางหมากรุก ดังนั้นในลูปแรกใช้สำหรับการสร้างแต่ละแถว

while (i < M) {
    // inter loop
    printf("\n");
    i++;
}

หากโฟกัสเพียงแค่ loop ด้านนอก จะเห็นว่าหน้าที่ของมันคือการสร้างแถวเป็นจำนวน M แถว ตอนนี้เพียงคิดว่า loop ด้านในจะเป็นอะไรก็ได้ที่เราต้องการทำ ลองลบลูปด้านในโปรแกรมออกให้เหลือเท่ากับตัวอย่างด้านบน จะเห็นว่ามีเพียงบรรทัดว่างเปล่า 8 ที่ถูกแสดงออกทางหน้าจอ

เมื่อเราจัดตั้ง loop ด้านนอกให้สามารถทำงานได้ตามที่ต้องการแล้ว ต่อไปเป็นการกำหนดการทำงานให้กับ loop ด้านในเพื่อวาดตัวอักษรลงในตาราง ทุกอย่างที่คุณเขียนในลูปนี้จะถูกนำไปใช้สำหรับทุกแถวจากลูปด้านนอก

int j = 0;
while (j < N) {
    if ((i + j) % 2 == 0) {
        printf("X");
    } else {
        printf(" ");
    }
    j++;
}

เราประกาศตัวแปร j สำหรับนับการทำงานของลูปด้านในเพื่อวนทำงาน N รอบสำหรับแสดงแต่ละหลักในแถว และสร้างเงื่อนไขเพื่อให้แสดงแบบสลับตารางตาข่าย โดยการนำแถวและหลักมาบวกกันและหารด้วย 2 ถ้าหากการหารลงตัวเราแสดงตัวอักษร X ไม่เช่นนั้นแสดงช่องว่างแทน

และในตอนท้ายเมื่อ loop ทั้งสองทำงานเสร็จสิ้น เราจะได้ตารางของหมากรุกขนาด 8 x 8 ที่แสดงผลออกทางหน้าจอ คุณสามารถลองเปลี่ยนขนาดของตารางในตัวแปร M และ N และรันโปรแกรมเพื่อดูผลลัพธ์อีกครั้งได้

การทำงานกับ loop นั้นเป็นเรื่องที่สนุก จากตัวอย่างก่อนหน้าสำหรับการวาดตารางหมากรุก เราสามารถเปลี่ยนเงื่อนไขเพื่อให้วาดภาพอื่นได้ นี่เป็นตัวอย่างของการวาดกรอบสี่เหลี่ยมล้อมรอบตาราง

if (i == 0 || i == N - 1 || j == 0 || j == M - 1) {
    printf("*");
} else {
    printf(" ");
}

คุณเพียงแค่เปลี่ยนโค้ดใน loop ด้านในและรันโปรแกรมอีกครั้ง นี่เป็นผลลัพธ์การทำงานของโปรแกรม

********
*      *
*      *
*      *
*      *
*      *
*      *
********

จากนั้นลองเปลี่ยนเงื่อนไขเป็นนี่เพื่อวาดเส้นตามแนวแทยงจากมุมทั้งสองและลองรันโปรแกรมอีกครั้งเพื่อดูผลลัพธ์

if (i == 0 || i == N - 1 || j == 0 || j == M - 1 || i == j || i == M - j - 1) {
    printf("*");
} else {
    printf(" ");
}

และนี่เป็นผลลัพธ์ของโปรแกรม

********
**    **
* *  * *
*  **  *
*  **  *
* *  * *
**    **
********

นี่ราวกับว่าเราอยู่ในการเรียนของวิชาศิลปะ ใช่แล้ว การเขียนโปรแกรมสามารถใช้สำหรับสร้างงานศิลปะได้ และคุณควรจะลองทำมัน

การแยกตัวประกอบของตัวเลข

ในตอนที่คุณเรียนวิชาคณิตศาสตร์ คุณยังจำวิธีการแยกตัวประกอบของตัวเลขได้หรือไม่ การแยกตัวประกอบคือการแบ่งตัวเลขออกเป็นชุดของจำนวนเฉพาะซึ่งเมื่อคูณกันจะได้ตัวเลขตัวเดิม ซึ่งนี่มีประโยชน์มากในการเขียนโปรแกรมขั้นสูง นี่เป็นตัวอย่างของการแยกตัวประกอบของตัวเลข

6 = 2 x 3
28 = 2 x 2 x 7
345 = 3 x 5 x 23
15450 = 2 x 3 x 5 x 5 x 103

และในตัวอย่างนี้ เราจะเขียนโปรแกรมเพื่อแยกตัวประกอบของตัวเลขใดๆ ที่รับค่าเข้ามาผ่านทางคีย์บอร์ด นี่เป็นตัวอย่างของโปรแกรมสำหรับแยกตัวประกอบของตัวเลขในภาษา C

number_factorization.c
#include <stdio.h>
#include <stdlib.h>

int main()
{
    printf("Prime Factorization Calculator\n");
    printf("Enter a number: ");
    int n;
    scanf("%d", &n);

    int factors[n];
    int index = 0;

    // find prime factors
    int i = n;
    while (i > 1) {
        int j = 2;
        while (j <= i) {
            if (i % j == 0) {
                factors[index++] = j;
                i = i / j;
                break;
            }
            j++;
        }
    }

    // display result
    printf("%d = ", n);
    i = 0;
    while (i < index) {
        printf("%d", factors[i]);
        if (i < index - 1) {
            printf(" x ");
        }
        i++;
    }
    return 0;
}

นี่เป็นผลลัพธ์การทำงานของโปรแกรม เราสามารถใช้มันสำหรับแยกตัวประกอบของตัวเลขจำนวนเต็มใดๆ คุณสามารถลองมันกับตัวเลขของคุณ

Prime Factorization Calculator
Enter a number: 18
18 = 2 x 3 x 3
Prime Factorization Calculator
Enter a number: 100
100 = 2 x 2 x 5 x 5

ต่อไปเราจะอธิบายการทำของมันในรูปแบบที่ง่ายที่สุด โดยโฟกัสที่การใช้งาน loop เป็นหลัก โปรแกรมเริ่มต้นทำงานโดยถามให้ผู้ใช้กรอกตัวเลขเพื่อแยกตัวประกอบและเก็บไว้ในตัวแปร n

int factors[n];
int index = 0;

เราประกาศอารย์สำหรับเก็บค่าตัวประกอบจำนวนเฉพาะทั้งหมดที่สามารถแยกได้ และประกาศตัวแปร index สำหรับนับจำนวนตัวประกอบที่พบและใช้สำหรับกำหนดค่าดังกล่าวให้กับอาเรย์

int i = n;

เรากำหนดค่าเริ่มต้นสำหรับ while loop เพื่อทำงานโดยกำหนดค่าให้กับตัวแปร i โดยให้มีค่าเริ่มต้นเท่ากับ n นั่นเป็นเพราะว่าค่านี้จะเปลี่ยนไปตลอดเวลาในขณะที่โปรแกรมทำงาน และเราต้องการรับษาค่าในตัวแปร n เอาไว้

while (i > 1) {
    // inner loop
}

จากนั้นเริ่มต้นการทำงานของ while loop นี่จะทำงานโดยการหาตัวเลขมาหาร i ในขณะที่ค่าในตัวแปรนั้นมากกว่า i และเมื่อค่าในตัวแปรน้อยกว่าหรือเท่ากับ 1 ซึ่งจะทำให้เงื่อนไขเป็นเท็จ หมายความว่าการแยกตัวประกอบเสร็จสิ้นนั่นเอง

int j = 2;
while (j <= i) {
    if (i % j == 0) {
        factors[index++] = j;
        i = i / j;
        break;
    }
    j++;
}

ส่วน loop ด้านในนั้นทำหน้าที่สำหรับหาตัวเลขที่หาร i ลงตัวโดยวนจาก 2 ถึง i เราใช้ตัวแปร j สำหรับการวนที่ลูปนี้ หากพบกับตัวเลขที่สามารถหารลงตัว จะถือว่าตัวเลขดังกล่าวเป็นตัวประกอบของ n และเราเก็บมันลงอาเรย์ factors

i = i / j;
break;

จากนั้นลดค่าในตัวแปร i ลงให้เท่ากับผลจากการหารตัวมันเองด้วย j และจบการทำงานของลูปภายในด้วยคำสั่ง break ที่จะส่งการทำงานกลับมายังลูปด้านนอก และลูปด้านนอกจะทำการตรวจสอบเงื่อนไขของมัน (i > 1) อีกครั้ง นี่แสดงว่าค่าในตัวแปร i ลดลงแล้ว

ถ้าหากเงื่อนไขยังคงเป็นจริง โปรแกรมจะทำงานที่ลูปด้านในเช่นเดิม แต่กับค่าของ i ที่ลดลงแล้ว และวนทำเช่นนี้ไปเรื่อยๆ จนกว่าค่าในตัวแปร i จะมีค่าน้อยกว่าหรือเท่ากับ 1 เพื่อจบการทำงานของลูป และในตอนท้ายเราจะได้ตัวประกอบทั้งหมดที่แยกได้เก็บในตัวแปรอาเรย์ factors

printf("%d = ", n);
i = 0;
while (i < index) {
    printf("%d", factors[i]);
    if (i < index - 1) {
        printf(" x ");
    }
    i++;
}

สุดท้ายเป็นการแสดงผลลัพธ์ออกทางหน้าจอ โดยการใช้คำสั่ง while loop เพื่อวนอ่านค่าในอาเรย์เช่นเดิม คุณได้เห็นเราได้ทำเช่นนี้ในตัวอย่างของการหาผลรวมของตัวเลขในอาเรย์ และนี่ก็คือทั้งหมดของโปรแกรมแยกตัวประกอบนี้

ในบทนี้ คุณได้เรียนรู้การใช้งานคำสั่ง while loop สำหรับควบคุมโปรแกรมเพื่อให้ทำงานซ้ำๆ ภายใต้เงื่อนไขที่กำหนด เราได้แสดงตัวอย่างการใช้งานในรูปแบบต่างๆ เพื่อให้คุณสามารถนำไปประยุกต์ใช้ในงานของคุณได้

กลุ่มหัดเขียนโปรแกรมภาษา Python

กลุ่มหัดเขียนโปรแกรมเบื้องต้น เข้าร่วมกลุ่มเพื่อสอบถามปัญหาเกี่ยวกับการเขียนโปรแกรมในภาษาต่างๆ

เข้าร่วมกลุ่ม
บทความนี้เป็นประโยชน์หรือไม่? Yes · No