อ่ะนี่ ตัวอักษรสำคัญเลขคือ \r (carriage return)

#include<stdio.h>
void delay()
{
   for(int i=0;i<1000000;i++) for(int j=0;j<10;j++);
}
int main()
{
   for(int p=0;p<=100;p++)
   {
       delay();
       printf("\rPercent: %d ", p);
       fflush(stdout);
   }
   printf("\n");
   return 0;
}

งืมๆ… มาพ่นโค้ด แล้วก็ไป ฮ่าๆ

ผมเลยลองเขียนปลั๊กอินไว้ “กรองข้อความ” โดยใช้เงื่อนไขง่ายๆ ว่า

“ใน 1 ชม. ที่ผ่านมา ถ้าเธอยังไม่เคยส่งข้อความหาฉันเลย แล้วจู่ๆ ส่ง URL มาให้ ฉันจะขอโยนข้อความนั้นทิ้งซะ (มันต้องเป็น spam แน่เลย!)”

Anti MSN Spam

ลองเขียนไว้ 2 version ครับ เขียนด้วย Python กับ C

1. anti-msn-spam.py

ลองเขียนตัวต้นแบบด้วย Python ครับ ใช้ dbus คุยกับ pidgin เพื่อเช็คว่ามีข้อความส่งมารึเปล่า (หาอ่านเพิ่มเติมได้จาก wiki นี้)

คิดว่าใช้ได้บน linux เท่านั้น เพราะมันใช้ dbus น่ะครับ
วิธีใช้: เปิด pidgin แล้วเรียกคำสั่งต่อไปนี้

python anti-msn-spam.py

พอโปรแกรมจับ SPAM ได้มันก็จะบ่นออกมาทาง command line ว่า “ข้อความ…..โดน block ทิ้ง เพราะสงสัยว่าเป็น SPAM” (โค้ด version python น่าจะทำความเข้าใจได้ง่ายสุดครับ ลองแกะเล่นดูได้นะ )

2. anti_msn_spam_c.zip

version C นี้ไปเอาโค้ด message_filter.c ของคุณ Huy Phan มาโมดิฟาย… ของเดิมเค้าเขียนโปรแกรม “block ข้อความที่มีแต่ smiley”

วิธีใช้ ดาวน์โหลดไฟล์ zip ไปจะมี anti_msn_spam.c กับ anti_msn_spam.so
- สำหรับคนใช้ x86 กับ pidgin 2.5.5 (บน linux):
1. สามารถเอาไฟล์ anti_msn_spam.so ไปใส่ไว้ที่ /home/USERNAME/.purple/plugins/anti_msn_spam.so ได้เลย
2. เปิด pidgin ขึ้นมาใหม่ เลือกเมนู Tools->Plugins
3. ติ๊กถูกหน้า “Anti MSN Spam 1.0″ เป็นอันเสร็จ

- สำหรับคนอื่นๆ (เช่น คนใช้ pidgin บน windows)
น่าจะต้อง compile เองครับ ทำตามคู่มือนี้เลย เหมือนจะต้องใช้ MinGW มา compile ครับ ถ้าใครพยายามแล้วติดปัญหา ก็แปะคอมเม้นท์มาได้นะครับ

โม้ไว้นิ๊สนึง… ตั้งแต่ลองใช้มา 3-4 สัปดาห์ ก็ยังไม่เจอ SPAM กวนใจอีกเลย ไม่รู้ว่าเค้าเลิกส่ง SPAM กันแล้ว หรือว่า Plugin เราดีจริง หะๆ

Q: eXceed Camp หรือค่ายทะลุฟ้าคืออะไร?
A: ค่าย 7 วันสำหรับนิสิตที่กำลังจะขึ้นปี 2 จากวิศวคอมฯ บางเขน+กำแพงแสน+วิศวซอฟต์แวร์ ประมาณ 120 คนมานั่งเรียน….จัดกลุ่มประมาณ 7-8 คนแล้วให้ลองเขียนโปรแกรมด้วยกันภายในเวลา 2 คืน 1 วัน

จะเห็นว่าเดือนที่แล้ว ผมไม่ได้เขียนบล็อกเลย เพราะนั่งคุย นั่งเตรียมค่ายกับเพื่อนๆ ปี 3 แล้วก็เขียน eXceed wiki ที่เป็นคลังความรู้ให้น้องๆ ในค่าย น่าดีใจที่ตอนนี้ wiki ของค่ายมีเนื้อหามากกว่า 500 หน้าแล้วครับ (เขียนกันมาเป็นปีที่ 2 แล้ว… ขอบคุณพี่ๆ CPE20&SKE04 ที่เริ่มต้นเขียนเนื้อหาใน wiki ไว้เยอะมาก)

กิจกรรมในค่าย

กิจกรรมก็ไม่มีอะไรมากครับ กิน เรียน นอน ตีดอท(เฉพาะบางคน อิๆ) เนื้อหาที่พยายามยัดเยียดให้น้องๆ ในค่ายปีนี้คือ Windows Form, SVN และ OOP สาเหตุที่ต้องสอน Windows Form เพราะตอนปี 1 น้องเรียน C# มาครับ ถ้าจะทำ App. ก็หนีไม่พ้นต้องใช้ Windows Form … แล้วแถม SVN ให้น้องๆ เพราะคาดว่าน่าจะช่วยให้น้องแลกโค้ดกันได้สะดวกขึ้น (ปีที่แล้วใช้ thumb drive เสียบเข้าเสียบออกติดไวรัสกันกระจาย) และสุดท้ายคือ OOP ที่หวังว่าน้องจะได้แบ่งโปรแกรมออกเป็นคลาสหลายๆ คลาส แล้วกระจายกันเขียนคนละคลาส (idea OOP ตกทอดมาจากรุ่นพี่ครับ)

นอกจากเนื้อหาที่บังคับยัดเยียดแล้ว… เรายังมีเนื้อหาที่น้องๆ เลือกเรียนตามความสนใจอีก 7 เรื่อง… พอเรียนกันเสร็จแล้วก็ได้เวลาปล่อยน้องๆ ทำโปรเจคครับ

==ชะแว๊บ… เวลาผ่านไป 2 คืน 1 วัน… ไปดูผลงานน้องๆ กันเลยดีกว่า==

ผลงานน้องๆ

ภาพซ้ายมือนี้ เป็นตอนที่ผมไปลองเล่นเกมส์ที่น้องเขียนขึ้น ชื่อว่า TYPING SHOOTER ครับ สร้างด้วย XNA Studio (พี่โบะเจ๋งมาก สอนน้องแค่ 2 ชม.ครึ่ง น้องก็เขียนเกมส์ได้แล้ว) เป็นเกมส์ฝึกพิมพ์ดีด ต้องพิมพ์คำศัพท์ให้ทันก่อนที่ซอมบี้จะเดินมาถึงตัวเรา… ปรากฏว่าเล่นไปเล่นมา น้องแก้โปรแกรมให้ผมเจอกับ level พิเศษ…ซอมบี้เดินเร็วอย่างโหดครับ พิมพ์ไม่ทัน Game Over ตามภาพ (น้องมันก็ยิ้มสะใจอยู่ด้านหลังนะนั่น)

จริงๆ ยังมีโปรเจคเจ๋งๆ อีกตั้ง 16 โปรเจคครับ ลองคลิกเข้าไปดู+ดาวน์โหลดมาลองเล่นกันได้ (คาดว่าน้องๆ จะเขียน wiki +อัพโปรแกรมกันเสร็จภายในวันที่ 7 มิ.ย. นี้ครับ)

x = 01001111000000001010101011110000

ให้กลายเป็น

y = 00001111010101010000000011110010

(คือ เขียน bit ใน x จากหลังมาหน้านั่นแหละครับ)

ตอนแรกพยายามนึกวิธีเอง ได้วิธีถึกๆ แบบต้องวนลูป 32 ครั้งค่อยๆ ดึง bit ตัวท้ายออกมาใส่อีกตัวแปรนึงไปเรื่อยๆ (32 ครั้ง = 32 bit) พอไปค้นในเน็ตเจอ Bit Twiddling Hacks ซึ่งแข็งแกร่งมาก (ทำเสร็จในไม่กี่ operation) ขอเอาโค้ดมาแปะตามนี้

unsigned int v; // 32 bit word to reverse bit order
// swap odd and even bits
v = ((v >> 1) & 0x55555555) | ((v & 0x55555555) << 1);
// swap consecutive pairs
v = ((v >> 2) & 0x33333333) | ((v & 0x33333333) << 2);
// swap nibbles ... 
v = ((v >> 4) & 0x0F0F0F0F) | ((v & 0x0F0F0F0F) << 4);
// swap bytes
v = ((v >> 8) & 0x00FF00FF) | ((v & 0x00FF00FF) << 8);
// swap 2-byte long pairs
v = ( v >> 16             ) | ( v               << 16);

ตอนแรกดูโค้ดแล้วก็งงๆ มันทำงานได้ยังไงหว่า ขอยกตัวอย่างการทำงานกับเลข 8 bit โดยใช้สัญลักษณ์ ABCDEFGH แทน 0, 1 และขอรันโค้ดจากบรรทัดล่างขึ้นบนซึ่งให้ผลลัพธ์เหมือนกัน (มันจะเข้าใจง่ายกว่าจริงๆ นะ)

x = ABCDEFGH
x = EFGHABCD	// สลับ nibble (4 bits) ที่ติดกัน
x = GHEFCDAB	// สลับ คู่บิต (2 bits) ที่ติดกัน
x = HGFEDCBA	// สลับ 'บิตที่อยู่ตำแหน่งคี่' กับ 'บิตที่อยู่ตำแหน่งคู่'

ถ้ายังไม่เข้าใจบ่นได้เลยครับ

เกมส์ Mysweeper เป็นเกมส์ที่ปั่นอย่างบ้าระห่ำ ใน 1 ชม. (ไม่ยอมอ่านหนังสือสอบ) เพื่อที่จะเอาไปบอกน้องๆ ปีหนึ่งว่า นี่คือเกมส์เล็กๆ ที่สร้างด้วย Visual C# ได้นะครับ (ผมกำลังจะสอนน้องๆ เรื่อง Windows Form Application ครับ)

แต่เขียนเสร็จเก็บไว้มันก็เท่านั้น เอาโค้ดมาแจกละกันครับ เผื่อใครจะลองเอาไปศึกษาดู อ่านรู้เรื่องไม่รู้เรื่องก็ทิ้ง comment ไว้ได้นะครับ สาเหตุที่เอาโค้ดมาแจกเพราะตอนสมัยหัดเขียน Visual Basic ครั้งแรกๆ ก็มาดาวน์โหลดโค้ดชาวบ้านไปนั่งดู (เยอะมากๆ) โค้ดอันนึงที่ประทับใจมากคือโค้ดของ Tamagotchi Simulator ของคุณ Tooh (พีรภัทร์ สว่างเพียร) แล้วเอามานั่งแกะๆ แล้วได้รับความรู้มากมาย

ผมเลยหวังว่าโปรแกรมเล็กๆ ที่ผมเขียนนี้อาจจะเป็นแหล่งเรียนรู้ให้กับคนอื่นได้ไม่มากก็น้อยฮับ

ดาวน์โหลดโค้ดเกมส์ mysweeper (ขนาด 46KB สร้างด้วย Visual Studio 2008)

#include <stdio.h>
int main(){
      float a = 10.1F;
      printf("%d", a);
      return 0;
}

Result:
1073741824

เราก็เกิดอาการสงสัย และเดาว่า มันคงอ่านค่า binary ทั้งดุ้นของ float เป็นแบบ int และพิมพ์ออกมา เราก็เลยลองฟังก์ชัน printbin เพื่อพิมพ์ binary representation ของตัวแปรใดๆ (ดูว่าใน ram มันเก็บเป็นเลขฐานสองยังไง) ได้โค้ดอย่างนี้…

#include <stdio.h>
void printbin(char *c, int bytes)
{  // author: nattster.siamdev.net
  int i, j;
  char a;
  for(j=bytes-1; j>=0; j--)
  {
    a = c[j];
    for(i=sizeof(char)*8-1; i>=0; i--)
    {
      printf("%d", (((a & 1<<i) > 0) ? 1 : 0));
    }
  }
  printf("\n");
}
int main(){
  float a = 10.1F;
  printf("%d\n", a);
  printbin((char*)&a, sizeof(float));
  return 0;
}

Result:
1073741824
01000001001000011001100110011010

เลขฐานสองยาวๆ อันล่างเป็น binary representation ของ 10.1F ตามมาตรฐาน IEEE754-1985 พอลองแปลงเลขฐานสองก้อนนี้กลับไปเป็นฐานสิบมันได้ = 1092721050 ซึ่งคลาดเคลื่อนจากผลที่ได้จาก printf(“%d”, a); นิดหน่อย สรุปว่าเราก็ยังไม่รู้อยู่ดีว่า printf มันเอาอะไรออกมาพิมพ์

แต่! ได้ฟังก์ชัน printbin เอาไว้ใช้เป็นของเล่นในอนาคต เผื่ออยากดูว่าตัวแปรอื่นๆ มันเก็บข้อมูลใน memory ยังไง
ปล. คิดว่าฟังก์ชันทำงานถูกต้องแล้วนะ เพราะลองใส่เลข 0.15625 แล้วมันได้เลขฐานสองถูกต้องตามรูปนี้อ่ะ

IEEE754 representation of 0.15625 (Ref: wikipedia.org)

malloc(ขนาดหน่วยความจำเป็นไบต์);

calloc(หน่วยความจำกี่ช่อง, ช่องละกี่ไบต์)

เกิดอาการสงสัยอย่างแรง ว่าไหนๆ มันก็ทำงานได้เหมือนๆ กันแล้ว ทำไมต้องมีตั้งสองฟังก์ชัน พอไปเปิด man ดูก็เจอข้อแตกต่างว่า malloc จะจองพื้นที่ให้ แล้วก็จบแค่นั้น แต่ calloc จะจองพื้นที่ให้และกำหนดค่าเริ่มต้นเป็น 0 ด้วย

ลองดูโค้ดและผลลัพธ์ของโปรแกรม น่าจะช่วยให้เข้าใจง่ายขึ้นครับ

#include<stdio.h>
#include<stdlib.h>
int main() {
	int *a = (int*) malloc(sizeof(int)*10);
	int *b = (int*) calloc(10, sizeof(int));
	int i;
	for(i=0;i<10;i++)
	{
		printf("a = %d, b = %d\n", a[i], b[i]);
	}
	return 0;
}

ผลลัพธ์:
a = 3221200, b = 0
a = 3215048, b = 0
a = 1095651909, b = 0
a = 1346192717, b = 0
a = 1095910725, b = 0
a = 1196314448, b = 0
a = 1866661971, b = 0
a = 1701860205, b = 0
a = 977485155, b = 0
a = 1852397404, b = 0

ดังนั้นควรเลือกฟังก์ชันให้เหมาะสมกับการใช้งาน เพราะมี overhead ไม่เท่ากันนะครับ

$ man qsort

เพื่อดูรายละเอียดของฟังก์ชัน qsort ได้ผลลัพธ์ตามนี้ (ทีนี้จะได้รู้และว่าต้อง include file ไหนและฟังก์ชันรับอาร์กิวเมนท์อะไรบ้าง)

QSORT(3)                   Linux Programmer`s Manual                  QSORT(3)
 
NAME
       qsort - sorts an array
 
SYNOPSIS
       #include <stdlib.h>
 
       void qsort(void *base, size_t nmemb, size_t size,
                  int(*compar)(const void *, const void *));
 
DESCRIPTION
       The  qsort()  function sorts an array with nmemb elements of size size.
       The base argument points to the start of the array.

แต่! ก่อนที่จะทำแบบนี้ได้ต้องติดตั้งแพคเกจ manpages-dev ก่อนครับ สำหรับผู้ใช้ ubuntu/debian (ใช้ Synaptic ติดตั้ง หรือ sudo apt-get install manpages-dev ก็ได้ครับ) สำหรับคนใช้ดิสโทรอื่นต้องลองค้น google ดูครับ

ถ้าลอง man printf ดูจะเจอ manual ของคำสั่ง printf ของ linux แทนที่จะเป็น reference ของฟังก์ชัน printf ของภาษา C แทน

วิธีเปิด manual ของ printf (ฟังก์ชันภาษา C) ให้เรียกคำสั่ง

$ man 3 printf

แทน ซึ่งหมายความว่า เปิดดูคำสั่ง printf ใน section ที่ 3 ของ manual ครับ (manual มีทั้งหมด 7-8 section… เขาแบ่ง section ตามหัวข้อครับ ดูรายละเอียดเพิ่มเติมที่นี่)

A = [1, 2, 3, 6, 7, 9, 12]
for x in A:
    if x % 3 == 0:
        A.remove(x)

List<int> A = new List<int>(new int[]{1, 2, 3, 6, 7, 9, 12});
foreach(int x in A)
{
    if(x % 3 == 0)
        A.Remove(x);
}

ในบล็อกนี้ขออนุญาตยกตัวอย่างแค่ 2 ภาษา คือ Python และ C# นะครับ สำหรับฝั่ง C# จะเจอกับ “Unhandled Exception: System.InvalidOperationException: Collection was modified;” (เขาบอกว่า เกิดการกระทำที่ไม่ถูกต้อง เนื่องจาก list ถูกแก้ไขระหว่างวนลูป) ส่วนคนใช้ Python จะไม่เจอปัญหาอะไรเวลารันครับ แต่พอลองพิมพ์ A ออกมาดูจะพบว่า

A = [1, 2, 6, 7, 12]

แงว… ทำไม 6 กับ 12 ยังโผล่ออกมา? ในเมื่อมันน่าจะ mod 3 ลงตัว… ในบล็อกนี้เราจะมาดูวิธีแก้ปัญหาที่มักจะเจอบ่อยๆ ปัญหานี้กันครับ

ปัญหาที่เจอใน Python คือ เลขจำนวนเต็มที่หารสามลงตัว ไม่โดนลบออกไปทุกตัว สาเหตุคือ ในการวนลูปบน list python จะมีตัวชี้ index ของ list สร้างขึ้นมา และในการวนลูปแต่ละรอบ index จะต้องโดนขยับไป 1 เสมอ ดังนั้นเมื่อตัวเลขโดนลบไป ตัวเลขอื่นๆ ที่อยู่ต่อท้ายจะเลื่อนมาแทนที่ตัวที่หายไป แล้วตัวที่เลื่อนมาแทนที่เนี่ยแหละครับ จะโดนข้ามไป (ไม่โดนตรวจสอบ)…. ถ้างง ลองดูตัวอย่างต่อไปนี้ครับ

A = 1 2 3 6 7 9 12

A = 1 2 3 6 7 9 12

A = 1 2 3 6 7 9 12

A = 1 2 6 7 9 12

จะเห็นว่ามีกรณีแบบนี้เกิดขึ้นได้ใน python และคนเขียนโปรแกรมก็ไม่รู้ว่าเกิดปัญหาขึ้นเลย (นอกจากมาดูผลลัพธ์) ดังนั้นใน C# เขาจึงห้ามวนลูปแบบ foreach แล้วแก้ไขข้อมูลใน list (เกิด InvalidOperationException นั่นเอง) ในเมื่อ foreach ใช้ไม่ได้ ขอลักไก่ใช้ for ธรรมดาแทนได้มั้ย? คำตอบคือ ไม่ได้ครับ ถ้าลองเขียนแล้วจะเจอปัญหาเหมือนกับที่เจอใน Python ครับ

แล้วเราจะแก้ปัญหานี้ยังไงดีหละ?

แบ่งได้เป็น 3 วิธีที่เจอบ่อยๆ ครับ

1. สร้าง List อีกอันมาเก็บเฉพาะผลลัพธ์ที่ต้องการ

วิธีนี้ง่ายๆ ตรงๆ เลยครับ ในเมื่อมี list A แล้วเราต้องการเฉพาะเลขที่หารสามไม่ลงตัว แล้วใช้ list ใหม่เป็นคำตอบ เราก็เขียนโปรแกรมประมาณนี้ได้เลยครับ

B = []
for x in A:
    if x % 3 <> 0:
        B.append(x)

List B = new List<int>();
foreach(int x in A)
{
    if (x % 3 != 0)
	B.Add(x);
}

อ่าวๆๆแบบนี้ โปรแกรมก็ต้อง copy ตัวเลขทุกตัว ไปใส่ list B แทน ซึ่งมันต้องทำงานช้าแน่ๆ เลย สมมติว่าเราต้องการลบเลขแค่ตัวเดียวใน list A แต่ดันต้อง copy ตัวที่ต้องการเก็บไว้ไปใส่ใน list B ซึ่งเสียเวลาทำงานตั้งนาน (แต่! จะเร็วกว่าวิธีอื่นๆ ถ้ามีตัวเลขที่ต้องโดนลบเยอะๆ ครับ)

งั้นไปดูวิธีที่สองดีกว่า

2. วนลูปในตัวก๊อบปี้ของ List

วิธีนี้คือ สร้างตัวก๊อบปี้ของ List (เอาตัวเลขทุกตัว) มาเลยครับ เอามาใช้วนลูป แล้วเวลาลบข้อมูลก็ลบใน list ของจริง ผลลัพธ์ก็จะเก็บอยู่ใน list A ตามปกติ

for x in A[:]:
    if x % 3 == 0:
        A.remove(x)

foreach(int x in new List<int>(A))
{
    if (x % 3 == 0)
	A.Remove(x);
}

หลายๆ คนคงจะเห็นว่า มันก็คล้ายๆ กับวิธีที่ 1 แหละน๊า… แค่สร้างตัวก๊อบปี้ไว้วนลูป ต้องเสียเวลาสร้างตัวก๊อบปี้เหมือนกันไม่ใช่เรอะ?… ฮึ่ม! งั้นลองไปดูวิธีที่ 3 กันครับ

3. วนลูปถอยหลัง

ในเมื่อวนลูปจากหน้าไปหลัง (0 ไปจนถึงขนาดของ list) จะมีปัญหาเพราะว่า ตัวเลขใน list จะเลื่อนมาแทนที่ตัวที่ถูกลบ ดังนั้นเราแก้ปัญหาโดยวนลูปถอยหลัง แทนครับ นั่นก็คือ วนลูปจากขนาดของ list มาจนถึง 0 นั่นเอง

for i in reversed(range(len(A)))
    if x % 3 == 0:
        del A[i]

for(int i = A.Count - 1; i >= 0; i--)
{
    if (A[i] % 3 == 0)
	A.RemoveAt(i);
}

จากตัวอย่างโค้ดจะเห็นว่าเราใช้ del A[i] และ A.RemoveAt(i) เพื่อลบตัวเลข ที่ตำแหน่งใดๆ แทนที่จะใช้ Remove ที่ใช้ลบค่าใดๆ จะเห็นว่าวิธีที่สามนั้นน่าจะทำงานได้เร็วกว่าวิธีที่ 1 และ 2 เพราะไม่ต้องสร้างตัวก๊อบปี้ของ list นั่นเอง

สรุป

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

ส่วนตั๊วส่วนตัวจากคนเขียน

ปล. สาเหตุที่มานั่งเขียน blog นี้เพราะผมเขียนโปรแกรมไปแล้วก็เจอ bug… คือ “ของ” ใน list มันโดนลบออกไปไม่หมด (แต่ python ไม่ยอมเตือนเหมือน C# หง่ะ!!) ก็เลยนั่งหา bug จนมาเจอ… เอาเป็นว่า เพื่อนๆ คนอื่นที่อ่านมาเจอบล็อกนี้แล้ว คงไม่พลาดแบบผมละกันครับ

ปล2. เพิ่งรู้ว่าใช้ reversed() แล้วโค้ดสวยกว่าเดิมเยอะเลย ปกติเวลาต้องการวนลูปจากมากไปน้อย (9 ถึง 0) ก็เขียนโค้ดน่าเกลียดๆ แบบนี้

for i in range(9, -1, -1):
    print i

พอเขียนบล็อกนี้แล้วเพิ่งรู้ว่าเขียนเป็น

for i in reversed(range(0, 9)):
    print i

สวยกว่าเยอะเลย

ปล3. ใครอยากให้เขียนบล็อก แล้วยกตัวอย่างภาษาอื่นๆ นอกจาก Python และ C# ช่วยทิ้งคอมเม็นท์ไว้ด้วยครับ

ใช้ scanf(“%s”, …); ก็อ่านได้เฉพาะบรรทัดที่ไม่มีเว้นวรรคเท่านั้น
จะใช้ gets() ก็พอช่วยได้ แต่ติดปัญหาที่ว่า พอใช้งานร่วมกับ scanf อื่นๆ แล้วเจอปัญหามากมาย

นายนิน PJ ก็ชี้ทางสว่างว่า scanf ก็สามารถอ่านข้อความได้ทั้งบรรทัดเหมือนกัน โดยใช้ modifier นิดหน่อยกับ scanf ตามตัวอย่างนี้

scanf("%[^\n]", myString);

โอ้โห..สุดยอด ทำไมมันง่ายจัง… ก่อนหน้านี้เคยเสียเวลาเขียน function อ่านค่าทีละตัวอักษร ใส่ string เอง ขอบคุณท่าน นิน PJ ครับ… อ้อ ใครอยากรู้เรื่องเกี่ยวกับ scanf เพิ่มเติมก็เรียกคำสั่งนี้เลยครับ

$ man scanf

Reference ฉบับอ่านง่าย: บล็อกพี่อิ๊กเรื่อง scanf 102