Example

ก่อนอื่นเลยให้เราสร้าง Groovy on Grails ใหม่ใน NetBeans ชื่อว่า my_blog ละกันนะ

ใครทำไม่เป็นดูตามลิ้งนี้เลยนะ CLICK!!!

เมื่อทำเสร็จแล้วก็มาสร้าง blog กัน ก่อนอื่นเลยเรามาสร้าง domain ที่ชื่อว่า blog ก่อน ให้มันอยู่ใน blogger package ละกันนะ

create domain

give domain name

เราก็จะได้ domain ที่ชื่อว่า blog มาแล้ว

หลังจากนั้นให้เราไปแก้ไฟล์ ใน grails-app/domain/blogger/Blog.groovy

class Blog {
static constraints = {
      title(blank:false)
      body(widget:"textarea")
}
      String title
      String body
}

เมื่อเราได้ Domain ก็ต้องมาสร้างส่วนของ Controller กับ View แต่ด้วยความขี้เกียจเราจึงใช้ Function การ generate ใน groovy กัน มันจะ gen ให้หมดเลยโดยดูจาก domain

ให้เราคลิกขวาที่ชื่อ project เรา แล้วเลือก Run Grails Command

เราจะเจอหน้าต่างใหม่โผล่ขึ้นมา ทีนี้เราก็เติมคำในช่องว่างกัน

ในช่อง filter ปล่อยว่างไป

ส่วนของ parameter เราก็ใส่ ชื่อpackage.ชื่อdomain ในที่นี้ blogger.Blog

ใน Matching Task เป็นส่วนที่ให่เราเลือกว่าเราจะใช้ฟังก์ชันอะไร เราต้องการ generate-all ก็เลือกมันซะ

แล้วก็คลิกที่ Run ดู มันจะมีตัววิ่งวืดๆ เต็มเลยรอซักพักนะ ก็จะเป็นอันเสร็จ

รัน project เราดู คลิกขวาที่ชื่อ project แล้วเลือก Run

ซักพักมันก็จะขึ้น web browser มา

เลือก blogger.BlogController

มาสร้าง blog ใหม่ โดยเลือกที่ New Blog

ทีนี้เราก็เห็นแล้วผลลัพธ์ของ code ที่เราได้พิมพ์ไปตอนต้น

ลองใส่ข้อความแล้วกด create สิ

ได้ผลลัพธ์หน้าตาอย่างนี้ ที่นี้เพิ่มความเล้าใจมาอีกนิดนึง เราจะมาลองใช้ plug in ที่มีชื่อว่า grails-ui ซึ่งมีความสามารถหลายๆ อย่างไปดูเอาเองนะ แต่มีอย่างนึงคือ Rich Editor ที่เพิ่มอุปกรณืในการตกแต่งข้อความดังตัวอย่างบนสุด เริ่มกันเลย กลับมาที่ project เรา ให้เราคลิกขวาที่ชื่อ project แล้วเลือก Grails Plugins…

แล้วมันจะขึ้นหน้าต่างใหม่มา ให้เราเลือกแทบ New Plugins มันจะโหลดข้อมูลมาแปปนึง ต่อเน็ทด้วยนะตอนนี้

ทีนี้มันจะมี plugin ให้เราเลือกเต็มเลย

เราจะใช้ grails-ui ก็เลือกมันซะ แล้วกด install จะโหลดข้อมูลมารอซักพักนะ

หลังจากนั้น plugin ก็ถูกนำเข้ามาใส่ใน project เราและ ถ้าสำเร็จก็จะได้เหมือนรูปบนนะ

ทีนี้ไปที่ grails-app/views/blog/create.gps เปิดไฟล์นี้ออกมา ถ้าเป็น NetBeans มันจะ generate code รกรุงรังมั่วตั้วมากมาย ให้เราไปแก้ตรงส่วนนี้นะลองหาดู ตามรูป

ให้แก้ตาม code ต่อไปนี้นะ

ลองรัน project ดู จะเห็นได้ว่ามี text editor มาให้เราและ ลองเล่นดูนะ

เมื่อเรากด create มันจะเป็น ดังรูป

เวรกรรม tag html ต่างๆ มันมาได้เยี่ยงไร แล้วเราจะแก้ยังไง ง่ายมากครับ ให้เราไปที่ grails-app/views/blog/show.gps แล้วไปดูหาตำแหน่งนี้นะ

แล้วแก้ตามนี้นะครับ

<td>${blogInstance.body}</td>

แล้วลอง refresh หน้า webpage เราครับ ก็จะได้มาแล้ว

มันยังมีให้แก้อีก 2 3 จุด ลองเข้าไปดูในพวก edit.gsp กับ list.gsp นะ วิธีแก้คล้ายด้านบนอ่ะ

จบ

java.sql.SQLException: Cannot convert value ‘0000-00-00 00:00:00′ from column 7 to TIMESTAMP.
..

หากใครเคยเจอปัญหานี้ ตามมาทางนี้เลยครับ ผมมีคำตอบ

การแก้ปัญหานี้มีสองวิธีคือ
1. ไปเซ็ตค่า URL ในการติดต่อ database ว่า ?zeroDateTimeBehavior=convertToNull เช่น

jdbc:mysql://localhost/test?zeroDateTimeBehavior=convertToNull

2. ในขณะที่เราเขียนโปรแกรม (ภาษา Java)ในการติดต่อ database ให้เราเซ็ต Connection Properties ดังนี้

Class.forName(driver).newInstance();
connection = (Connection) DriverManager.getConnection(url + dbName, userName, password);
connection.setZeroDateTimeBehavior("convertToNull");

ทีนี้เมื่อเรารันโค้ด ที่ทำให้เกิด Exception ดังกล่าว

System.out.println(">>>> this is zero = "+rs.getTimestamp("finish_date"));

จะได้ผลลัพธ์เป็น

>>>> this is zero = null

หรือถ้าเป็น

connection.setZeroDateTimeBehavior("round");

จะได้ผลลัพธ์เป็น

>>>> this is zero = 0001-01-01 00:00:00.0

ซึ่งการเซ็ต zeroDateTimeBahavior สามารถดูรายละเอียดได้ ที่นี่

จะเกิดอะไรขึ้น ถ้า พอระบบทำขั้นตอนที่ 1 เสร็จสิ้นแล้ว แต่ยังไม่ทันที่จะทำขั้นที่ 2 ระบบเกิดมีปัญหาขึ้นมา
หากไม่ได้รับมือกับปัญหานี้ ผลที่เกิดขึ้น คือ
เงินบัญชีนาย aeronz เหลือ 1500 บาท เงินในบัญชีนาย Porza คือ 0 บาท

เราต้องทำยังไงหล่ะ ?
ถ้าใครสนใจก็ตามเข้ามาเลยครับ

จากบัญหาข้างต้น สิ่งที่ดีที่สุดที่เราจะทำก็คือหากเราทำ กระบวนการทั้งหมด (ทั้งข้อ 1 และ 2)ไม่สำเร็จ ระบบก็ควรที่จะไม่เปลี่ยนแปลงอะไรเลย
คือ เงินบัญชีนาย aeronz เหลือ 2000 บาท เงินในบัญชีนาย Porza คือ 0 บาท เหมือนเดิม

เพราะฉะนั้น เวลาเราเขียนโปรแกรม หรือทำระบบที่มีการดำเนินการใดๆ (Transaction) เราต้องคำนึงถึงเรื่องนี้ไว้ด้วยครับ
ในการย้อนกลับหากการดำเนินการไม่สำเร็จ เราจะเรียกว่าการ roll back ครับ ซึ่งใน ActiveRecord ของ ROR ก็มีการเขียนโค้ดเพื่อเตรียมป้องกันเหตุการเหล่านี้ดังนี้ครับ

aeronz = Account.find(1)
porza = Account.find(2)
 
Account.transaction do
  aeronz.withdrawal(500)
  porza.deposit(500)
end

หรือ

aeronz = Account.find(1)
porza = Account.find(2)
 
ActiveRecord::Base.transaction do
  aeronz.withdrawal(500)
  porza.deposit(500)
end

เพราะว่าโมเดลใน RoR มีการสืบทอดมาจาก คลาส ActiveRecord::Base ครับ

ครับ ตอนนี้เราก็ได้ concept ของ Transaction และวิธีการในการ RollBack ข้อมูล เมื่อเกิดปัญหาด้วย ActiveRecord ใน RoR กันแล้วนะครับ
ถ้าใครสนใจ อาจจะไปอ่านเพิ่มเิติมได้ ที่นี่ ครับ
ไว้เจอกันใหม่ครับ

for(int i=0;i<sizeofarray;i++){
array[i] = 0;
}

แถมต้องเซตทุกรอบที่วนกลับมาอีกต่างหาก ต้องวนไม่รู้กี่รอบ
วันนี้ผมจะเสนอวิธีใหม่ นั่นก็คือ การใช้คำสั่ง memset นั่นเอง

คำสั่ง memset อยู่ใน library ของ cstring หรือ string.h นั่นเอง
ซึ่งมีรูปแบบการใช้ดังนี้

memset(pointer to first element of array , value to set , size in bytes of array);

จากตัวอย่างข้างต้น เราจะเขียนง่ายๆ ได้ว่า
memset(array,0,sizeof(array));

เป็นไงครับ เหลือแค่บรรทัดเดียว แถมไม่ต้องเปลือง memory กับตัวแปร i ที่ใช้ในการวนอีกด้วย

จากคราวที่แล้ว
สมมติให้ input เป็นดังนี้
5 10
8 3000
3 1600
6 2500
1 600
4 1900

โดยเลข 5 ตัวแรกหมายถึงจำนวน card และ 10 หมายถึงจำนวนดาวสูงสุดที่จะหยิบได้
5 บรรทัดถัดมาจะประกอบด้วย จำนวนดาวและพลังโจมตี ตามลำดับ

วิธีการทำ จะใช้ตารางมาช่วยนะครับ ก่อนอื่นสร้างตารางที่เมื่อไม่มีการ์ดใบใดถูกเลือกเลย

เลขที่อยู่ในแต่ละช่องของตารางก็คือพลังโจมที่ดีที่สุดเมื่อเลือกแล้วนะครับ
เราจะมาเริ่มหยิบการ์ดกันนะครับ
เริ่มทีละ column โดยที่ column แรกจะเป็นการทดลองหยิบการ์ดใบแรก Blue Eyes White Dragon 8 ดาว พลังโจมตี 3000
จะเห็นได้ว่า ช่้อง 1 ดาว หยิบบลูอายส์ไม่ไ้ด้นะครับ เพราะดาวเกิน จะหยิบได้ก็เมื่อถึงช่องแปดดาวแล้ว
ลองทำ column แรกจะได้ตารางแบบนี้

จะเห็นได้ว่า เมื่อเลือกหยิบบลูอายส์ใบเดียวแล้ว
เราจะได้ 1 ดาว 2 ดาว 3 ดาว …. 7 ดาว ที่มีพลังโจมตีมากที่สุดเป็น 0 เพราะไม่สามารถใส่บลูอายส์ลงไปได้
แต่ที่ช่อง 8 9 10 จะเห็นได้ว่า เราได้เลือกบลูอายส์ ที่มีพลังโจมตี 3000

แล้วทำไมต้องมีเส้นสีน้ำเงิน??
เรามาลองดูกันตอนทำไปสักสองแถวดู จะได้ตารางแบบนี้

พอถึงตอนนี้จะเห็นได้ว่า ถ้าเรามีการ์ดแค่สองใบ แต่ต้องการหยิบให้ได้
ดาว        พลังโจมตีสูงสุด
0             0
1              0
2             0
3             1600
.
.
8             3000
9             3000
10          3000

แล้วเส้นสีน้ำเงินล่ะ??
สมมตินะครับ ถ้าเราต้องการหยิบ ให้ได้ 5 ดาว ที่ได้พลังโจมตีสูงที่สุด แต่การ์ดที่เราจะจับตอนนั้นมีแค่ 3 ดาว
เราก็เอาพลังโจมตีของการ์ดที่เราจะหยิบ + พลังโจมตีที่ดีที่สุดของ 2 ดาว เราก็จะได้ การ์ดรวมห้าดาวที่มีพลังโจมตีสูงสุดแล้วจริงใหมครับ

ในกรณีนี้คือ ช่อง 8 ดาว เราเลือกหยิบบลูอายส์ซึ่งมี 8 ดาว เพราะฉะนั้น เราจะต้องหา 0 ดาวที่มีพลังโจมตีสูงที่สุดมาเติม
(เป็นเหตุผลที่เราต้องตั้งค่าแถวแรกให้เป็นค่า 0 เนื่องจากหากเราเลือก 0 ดาวที่ดีที่สุด ค่าจะต้องเป็น 0)

เช่นเดียวกันกับช่อง 10 ดาว เราเลือกหยิบบลูอายส์ 8 ดาว เพราะฉะนั้น เราจะต้องหา 2 ดาวที่มีพลังโจมตีสูงที่สุดมาเติมแต่ 2 ดาวยังเป็น 0 อยู่เพราะเราเลือกหยิบบลูอายส์เป็นใบแรก
(เป็นเหตุผลที่เราต้องตั้งค่า column แรกให้เป็นค่า 0 ซึ่งเป็นค่าน้อยที่สุดที่เป็นไปได้)

ใน column 2 ก็เช่นเดียวกัน เพียงแต่ที่ช่อง 8 ดาวให้เรานำไปเปรียบเทียบกับค่าพลังโจมตีที่ดีที่สุดอันเก่าแล้วพบว่า ต่อให้เราเอา พลังโจมตีของ ซอมบี้ดราก้อน กับ 5 ดาวที่พลังโจมตีสูงที่สุด (1600+0) ก็ยังน้อยกว่าพลังโจมตี 8 ดาวเก่าที่ได้ที่สุด ดังนั้นเราจึงเลือกพลังโจมตีเก่านั่นเอง

เรามาลองทำจนจบดูนะครับ จะได้ตารางดังนี้

จะเห็นได้ว่า เราสามารถบอกได้หมดเลย ว่า 1 ดาวที่ดีที่สุดพลังโจมตีเท่าไหร่ 2 ดาวที่มีพลังโจมตีสูงที่สุด ….
จนถึงคำตอบของเรา 10 ดาวที่มีพลังโจมตีสูงที่สุด

บางคนอาจจะยังไม่เข้าใจ ให้ไล่ลองทำดูนะครับ ทีละขั้นตอน ผมจะสรุปขั้นตอนให้ดูง่ายๆ ละกัน
1. สร้างตาราง จำนวนของ(N) x จำนวนสูงสุดของข้อจำกัด(ดาว)
2. ที่ช่อง 0 ทั้งแนวนอนและแนวตั้ง ให้ตั้งค่าเป็นจำนวนที่น้อยที่สุดที่จะเป็นไปได้(ถ้าโจทย์ให้หาค่ามากที่สุดนะ)
3. ที่ช่องใดๆ ถ้าแถวดาว มากกว่า ดาวของการ์ดที่เราหยิบ แปลว่าเราจะสามารถหยิบการ์ดนี้ได้
4. นำพลังโจมตีของการ์ดที่เราหยิบ + ค่าที่(แถวบอกจำนวนดาว – ดาวของการ์ดที่เราหยิบ) ถ้าได้มากกว่า ค่าที่มากที่สุดของแถวเงื่อนไขนี้ ให้เปลี่ยนเป็นพลังโจมตีนั้นๆแทน
5. ถ้าไม่ ให้เลือกพลังโจมตีที่ดีที่สุดอันเดิม

แหม พอใช้ภาษาพูดแล้วงงๆ ใช่ใหมล่ะ งั้นลองเป็น code ดูนะครับ

เก็บข้อมูลตัวแปร float จาก GNU Compiler Collection (GCC) รันบน 32bit Ubuntu based on IEEE 754

0.05;                0-01111010-10011001 10011001 1001101
0.005;              0-01110111-01000111 10101110 0001010
-20.812;           1-10000011-01001100 11111101 1111010
20.1234567;     0-10000011-01000001 11111001 1010111
20.12345678;    0-10000011-01000001 11111001 1010111
1.0;                  0-01111111-00000000 00000000 0000000
2.0;                  0-10000000-00000000 00000000 0000000
10.0;                0-10000010-01000000 00000000 0000000
0.1;                  0-01111011-10011001 10011001 1001101
0.2;                  0-01111100-10011001 10011001 1001101
0.01;                0-01111000-01000111 10101110 0001010
0.02;                0-01111001-01000111 10101110 0001010
1.01;                0-01111111-00000010 10001111 0101110
1.02;                0-01111111-00000101 00011110 1011100
10.1;                0-10000010-01000011 00110011 0011010
10.2;                0-10000010-01000110 01100110 0110011

ตารางจาก http://en.wikipedia.org/wiki/Floating_point

Floating-Point Representation

ตัวแปร float มีขนาด 4 ไบต์ หรือ 32 บิตจะแบ่งพื้นที่เพื่อเก็บข้อมูลแบบ ทศนิยมดังนี้

S : Sing(1 บิต) เอาไว้เพื่่อบอกว่า ทศนิยมนั้นเป็นเลข ลบ หรือ บวก โดย บิต 0 คือ + , บิต 1 คือ -

E : Exponent(8 บิต) เป็นส่วนที่แสดง เลขยกกำลังเป็นได้ทั้งบวก และ ลบ

M : Mantissa(23 บิต) เป็นส่วนที่อยู่หลังจุดทศนิยม

วิธีการเปลี่ยน ทศนิยม(float) ให้เป็นเลขฐานสอง

1. นำเลขที่ต้องการจะเปลี่ยนมาแปลงเป็นเลขฐานสอง

เช่น 0.005₁₀ = 0.000000010100011110101110000101000111101011100001010001111011₂

(วิธีการแปลงนั้น ขอยกเป็นบทความถัดไปนะครับ)

2. ทำ Normalization form (คือการทำให้อยู่ในรูป 1.AAA x 2^B)

จาก  0.005₁₀ = 0.000000010100011110101110000101000111101011100001010001111011₂

ทำเป็น  Normalization form ได้

1.0100011110101110000101000111101011100001010001111011 x 2^-8

3. เลข Mantissa คือ เลขฐานสองที่อยู่หลังจุดทศนิยม

จาก  1.0100011110101110000101000111101011100001010001111011 x 2^-8

Mantissa คือ  0100011110101110000101000111101011100001010001111011

แบ่งเป็น 8 bits ให้สวยงาม ก็จะได้

01000111 10101110 00010100 0111101011100001010001111011

Mantissa มีขนาด 23 บิต เพราะฉะนั้น เราสนใจเพียง 24 บิตแรกเท่านั้น

ที่สนใจ 24 บิต ไม่ใช่ 23 บิต ก็เพราะว่า บิตตัวที่ 24 ถ้าเป็นบิต 1 ก็จะปัดขึ้นมา แต่ถ้าเป็นบิต 0 ก็ไม่ปัดนั่นเอง

(วิธีปัดนั้น ก็เหมือนกับการ บวกด้วย 1 แบบเลขฐานสองครับ)

เพราะฉะนั้น

Mantissa = 01000111 10101110 0001010

4. เลข Exponent คือเลขกำลัง

จาก 1.0100011110101110000101000111101011100001010001111011 x 2^-8

Exponent หาได้จาก bias – true exponent

bias ของ float = 127

true exponent คือ -8 (เลขกำลัง ของ 2 นั่นเอง)

เพราะฉะนั้น จะได้

Exponent = 127₁₀ + (-8)₁₀ = 119₁₀ ซึ่งเท่ากับ 1110111₂ และเนื่องจาก Exponent มีขนาด 8 บิต

แต่ Exponent ที่เราคำนวนได้นั้น มีเพียง 7 บิต แก้โดยการเติม บิต 0 ไปข้างหน้า จนครบ 8 บิต ดังนั้น

จะได้

Exponent = 01110111

5. รวม sign, exponent, mantissa เข้าด้วยกัน

sign เป็น 0 เพราะ 0.005 เป็น บวก

exponent เป็น  01110111

mantissa เป็น  01000111 10101110 0001010

รวมกันจะได้  0 01110111 01000111 10101110 0001010

อ้างอิงความรู้จาก

www.cs.northwestern.edu/~fabianb/classes/eecs-213-s07/lectures/04-FloatingPoint.pps

http://www.cs.northwestern.edu/~fabianb/classes/

ตัวเลขในคอมพิวเตอร์ ล้วนประกอบขึ้นด้วยเลขฐานสอง

เช่น  เลข 0₁₀ = 00000000 00000000₂

1₁₀ = 00000000 00000001₂

2₁₀ = 00000000 00000010₂

3₁₀ = 00000000 00000011₂

ไปจนถึง

65535₁₀ = 11111111 11111111₂

การผสมกันของบิต 0 กับ 1 รูปแบบข้างบนนี้   เป็นการเก็บตัวเลข ของชนิดข้อมูล unsigned int ใน Turbo C++

ชนิดข้อมูล unsigned int นี้ คือ ชนิดข้อมูลที่เป็นตัวเลข ศูนย์และจำนวนเต็มบวก คือตั้งแต่ 0 จนถึง 65535

แต่ถ้าเป็นชนิดข้อมูลแบบ int จะเป็นชนิดข้อมูลที่เป็นตัวเลข ศูนย์ จำนวนเต็มบวก และจำนวนเต็มลบ คือ ตั้งแต่ -32768 จนถึง 32767

ทั้งข้อมูลชนิด unsigned int และ แบบ int จะสามารถเก็บตัวเลขได้ 65536 กรณีเท่ากัน

นั่นก็เพราะว่า ชนิดข้อมูล unsigned int และ int ล้วนประกอบด้วย รูปแบบ 16 bits ซึ่งมีขนาด 2 bytes

และจำนวนที่สามารถเก็บข้อมูลไ้ด้ คือ 2¹⁶ = 65536 ตัวเลข(ที่ไม่ซ้ำกัน)

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

วิธีการก็มีดังนี้

1. แปลงเลขฐาน 10 ที่ต้องการเก็บ ไปเป็นเลขฐาน 2

2. กลับบิต จาก 0 เป็น 1     และ จาก 1 เป็น 0

3. นำไปบวกด้วย 1 แบบ ไบนารี

เช่น ต้องการเก็บค่า -32 ลงใน ตัวแปรชนิด int

เนื่องจาก 32₁₀ = 00000000 00100000₂

กลับบิต           ->11111111 11011111₂

บวกด้วย 1       ->11111111 11100000₂

มีค่าเท่ากับ 65504 ในรูปแบบตัวแปร unsigned int

แต่จะมีค่าเท่ากับ -32 ในรูปแบบตัวแปร int

หลักการคือ

1 1111111     11100000₂ = -32 (รูปแบบ int)

^ บิตตัวแรกสุด จะทำหน้าที่แยกตัวเลขนั้นๆ ว่า เป็นเครื่องหมาย + หรือ –    โดย ถ้าเป็น 0 คือ + , 1 คือ -

หลักการนี้ เรียกว่า two’s complement

แหล่งข้อมูล http://sot.swu.ac.th/CP341/lesson01/cs2t1.htm

class SMS
def initialize(config)
@config = config
end

def create(recipient, message_text)
api.send_message(recipient, message_text)
end

private
def api
@api ||= Clickatell::API.authenticate(
@config[:api_key],
@config[:username],
@config[:password]
)
end
end
4. configuration=>environments=>product.rb เพิ่มโค้ดดังนี้
CLICKATELL_CONFIG = YAML.load(File.open(File.join(RAILS_ROOT, ‘config’, ‘clickatell.yml’)))
5. configuration=> clickatell.yml เพิ่มโค้ดดังนี้
api_key: xxxxx
username: mai
password: xxxx
6. configuration=> routes.rb เพิ่มโค้ดดังนี้
ActionController::Routing::Routes.draw do |map|
map.resource :sms
end
7. หน้า view สร้างหน้าเวบที่ต้องการให้ผู้ใช้กรอกข้อมูลเพื่อส่ง sms ถึงผู้รับ
<% form_tag '/sms', :method => :post do -%>
Enter the recipients mobile number:
<%= text_field_tag "recipient" %>
Enter your message:
<%= text_area_tag "message_text" %>
<%= submit_tag "Send SMS" %>
<% end %>
8. ส่วนของ controller
class SmsController < ApplicationController
def create
sms = SMS.new(CLICKATELL_CONFIG)
sms.create(params[:recipient], params[:message_text])
flash[:notice] = "Message sent succesfully!"
redirect_to :back
rescue Clickatell::API::Error => e
flash[:error] = “Clickatell API error: #{e.message}”
redirect_to :back
end
end
9. เสร็จแล้วจ้าา…
แหล่งที่มา:

http://lukeredpath.co.uk/blog/sending-sms-messages-from-your-rails-application.html

อืม . .. .

ลองดูรึยังครับ ไม่ได้ใช่มะ?? งั้นมาดูเหตุผลกัน

นั้นเพราะว่าคำว่า con มันไปตรงกับคำสั่งหนึ่งใน DOS

con=คอนโซล ใช้ประกอบคำสั่ง copy เพื่อเขียน file บนหน้าจอ โดยไม่ต้องใช้ notepad ได้

รูปแบบการใช้

C:\>copy con test.txt

จากนั้นก็พิมข้อความอะไรก็ได้ลงไป

เมื่อเสร็จกด ctrl+z แล้วตามด้วย enter เราก็จะได้ไฟล์ชื่อ test.txt อยู่ที่ C: และจะมีข้อความที่เราเขียนลงไปอยู่ข้างใน

อะ นอกเรื่องไปแล้วเนอะ ที่จริงนอกจากคำว่า con ยังมีอีกหลายตัวที่เราจะใช้ตั้งชื่อไม่ได้นะครับดังนี้

อักษรที่ห้ามใช้ในการตั้งชื่อคือ  < > : ” / \ | ? *

คำที่ห้ามใช้ มีดังนี CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, และ LPT9

ซึ่งชื่อเหล่านี้อาจจะไปตรงกับ device name หรือ คำสั่ง อะไรซักอย่างของ DOS ก็เป็นได้

แต่เราก็ยังดันมีวิธีสร้าง folder เหล่านี้ได้อีกนะเนี่ย -*- (จะทำไปทำไมนะ??)

สมมติจะสร้าง folder ชื่อ con นะครับ

ขั้นแรกให้ run cmd ขึ้นมาก่อนและพิมพ์คำสั่งดังนี้

mkdir \\.\C:\con

เราก็จะได้ folder ชื่อ con มาไว้ในครอบครอง แต่!!

แต่มันดันลบไม่ได้นี่สิ จะลบก็ต้องใช้ command อีกครับผม คำสั่งในการลบก็คือ

rmdir \\.\C:\con

เรียบร้อย โฟลเดอร์ con ก็หายไปแล้ว ^^

happy มีความสุขครับ

สรุปแล้ว con ไม่ใช่ชื่อพ่อของ bill gates นะครับ ^^

จากคราวที่แล้ว ได้เขียนเกี่ยวกับ Dynamic Programming แบบง่ายๆ ที่นี่

วันนี้เราจะมาลองกันแบบ Advance ขึ้นไปอีกขั้น นั่นก็คือ การเขียน Dynamic Programming เพื่อแก้ปัญหาประเภท Knapsack Problem
Knapsack Problem คืออะไร?
สมมติ มีการ์ดยูกิอยู่หลายใบ แต่ละใบจะมี level (ดาว) และพลังโจมตีต่างๆกัน หากให้เลือกการ์ดออกมาให้ครบ 10 ดาว และให้มีพลังโจมตีสูงที่สุด จะเลือกอย่างไร?

ตัวอย่างง่ายๆ
สมมติมีการ์ดอยู่ห้าใบ ดังนี้
Blue Eyes White Dragon 8 ดาว พลังโจมตี 3000
Dragon Zombie 3 ดาว พลังโจมตี 1600
Demon 6 ดาว พลังโจมตี 2500
Kuriboh 1 ดาว พลังโจมตี 600
Bloodwars 4 ดาว พลังโจมตี 1900
ให้เลือกอย่างมากได้สิบดาว ให้ได้พลังโจมตีสูงที่สุด จะทำอย่างไร

ยังจำตอนที่แล้วได้มั้ยครับ ที่ว่า ให้มองปัญหาใหญ่ให้กลายเป็นปัญหาย่อยๆ เล็กๆ แล้วก็ย่อยปัญหาเล็กลงไปอีกทีจนเลือกหน่วยที่เล็กที่สุด
จากโจทย์้ข้อนี้ก็เช่นเดียวกันครับ
- หากเราต้องการจะหยิบการ์ดใบสุดท้ายที่มี 4 ดาวแล้ว แสดงว่า การ์ดที่เราหยิบ 6 ดาวก่อนหน้าจะต้องได้พลังโจมตีมากที่สุด
-      หากเราต้องการหยิบการ์ดรองสุดท้ายที่มี 1 ดาวแล้ว แสดงว่า การ์ดที่เราหยิบ 5 ดาวก่อนหน้าจะต้องได้พลังโจมตีมากที่สุด
-      แต่หากเราต้องการหยิบการ์ดรองสุดท้ายที่มี 6 ดาวแล้ว แสดงว่า การ์ดที่เราหยิบ 0 ดาวก่อนหน้าจะต้องได้พลังโจมตีมากที่สุด – จบ
-      แต่หากเราต้องการหยิบการ์ดรองสุดท้ายที่มี 3 ดาวแล้ว แสดงว่า การ์ดที่เราหยิบ 3 ดาวก่อนหน้าจะต้องได้พลังโจมตีมากที่สุด
….

เป็นเช่นนี้ไปเรื่อยๆ..
เป็นไงครับ ดูยากใช่ใหมครับ งั้นลองดูรูปนี้ดู

อาจจะดูง่ายขึ้นนิดหน่อย แต่ก็ยังงงใช่ใหมครับ ว่า มันต่างจากการ Recursion ตรงไหน
นั่นก็เพราะว่า Dynamic Programming จะให้ memory แทนการ run ที่สูญเปล่าไงครับ

อย่างเช่น หากมีการ์ด 4 ดาวในชุดอยู่สองใบ แล้วเราจะเลือกการ์ด 4 ดาวแต่ละใบ เราจำเป็นต้องแต่ recursive ไปทั้งสองทาง
ทั้งที่เป็นการหาการ์ดที่มีดาวรวม 6 ดาว และมีพลังโจมตีเยอะที่สุดเหมือนกันแท้ๆ

พูดถึงตรงนี้ พอมองภาพออกแล้วใช่ใหมครับ นี่ก็เป็นหลักการง่ายๆ (?) ของ Dynamic Programming นั่นเอง
ครั้งหน้าจะพูดถึงเรื่องของ การใช้ Dynamic Programming ในการเขียนโปรแกรมจริงๆ นะครับ

วันนี้ขอลาไปก่อน สวัสดีปีใหม่