จุดประสงค์ของโพสต์นี้คือการรวบรวมเคล็ดลับการเล่นกอล์ฟทั้งหมดที่สามารถนำไปใช้อย่างง่ายดาย<all languages>มากกว่าที่เฉพาะเจาะจง

โพสต์คำตอบเท่านั้นว่าตรรกะสามารถนำไปใช้กับส่วนใหญ่ของภาษา

กรุณาหนึ่งเคล็ดลับต่อคำตอบ

ผสานลูป

โดยปกติคุณสามารถรวมลูปสองอันที่ตามมาหรือสองลูปซ้อนกันเป็นหนึ่งเดียว

ก่อน:

for (i=0; i<a; i++) foo();
for (i=0; i<b; i++) bar();

หลังจาก:

for (i=0; i<a+b; i++) i<a?foo():bar();

เพียงพูดถึงชัดเจน:

ตั้งคำถามกับอัลกอริทึมที่คุณเลือกและลองสิ่งใหม่ทั้งหมด

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

นี่เป็นสิ่งที่เห็นได้ชัดเจนในHitting 495 (Kaprekar)ซึ่งเบี่ยงเบนจากอัลกอริทึมจริงและมองหารูปแบบที่คุณสามารถนำไปใช้เพื่อให้ได้ผลลัพธ์เดียวกันนั้นสั้นลงในหลายภาษา (ไม่ใช่ J)

ข้อเสียคือคุณอาจแก้ปัญหาเดียวกันครึ่งโหลครั้ง แต่มันใช้งานได้จริงในทุกภาษายกเว้น HQ9 + (การหาวิธีอื่นในการส่งออกHello Worldจะไร้ประโยชน์เล็กน้อย)

ใช้การพัฒนาที่ขับเคลื่อนด้วยการทดสอบ

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

พยายามลดคำแถลงเชิงตรรกะ

ตัวอย่างเช่นหากAและBเป็นบูลีนและภาษาของคุณจะถือว่าบูลีนเหมือนตัวเลขในระดับหนึ่งA and (not B)และA>Bเทียบเท่า ตัวอย่างเช่นใน Python

if A and not B:
    foo()

เหมือนกับ:

if A>B:
    foo()

เริ่มต้นตัวแปรโดยใช้ค่าที่คุณมีอยู่แล้ว

แทนการx=1พยายามที่จะมองหาสิ่งที่มีอยู่แล้วเท่ากับ 1
ตัวอย่างเช่นค่าตอบแทนการทำงานที่: ->printf("..");x=0; x=!printf("..");ง่ายที่สุดคือ 0 เพราะคุณสามารถปฏิเสธได้ตลอดเวลาหรือเมื่อคุณต้องการมีค่าความจริงที่ถูกต้อง (และไม่สนใจว่ามันจะเป็น 1 หรือ 19)

ใช้เอก~สำหรับx+1และx-1

เคล็ดลับนี้จะนำไปใช้ภาษาที่มีผู้ประกอบการระดับบิตปฏิเสธเอกและผู้ประกอบการปฏิเสธปกติเอก~-

หากโปรแกรมของคุณมีนิพจน์-x-1คุณสามารถแทนที่ด้วย~xเพื่อบันทึกไบต์ สิ่งนี้ไม่ได้เกิดขึ้นบ่อยเกินไป แต่ดูว่าจะเกิดอะไรขึ้นถ้าเราคัดค้าน ( -) การแสดงออกทั้งสอง: x+1เท่ากับ-~x! ในทำนองเดียวกันเท่ากับx-1 ~-x(ลองคิดดูว่าคะแนนตัวหนอน: ทางขวาคือ+ซ้ายคือ-อะไร)

สิ่งนี้มีประโยชน์เพราะในทุกภาษาที่ฉันคิดว่ามีตัวดำเนินการเหล่านี้พวกเขามีความสำคัญมากกว่าตัวดำเนินการส่วนใหญ่ สิ่งนี้ช่วยให้คุณสามารถบันทึกในวงเล็บ ดูวิธีที่เราบันทึกสี่ไบต์ที่นี่:

(x+1)*(y-1)     ==>    -~x*~-y

บีบช่องว่าง

รู้กฎสำหรับพื้นที่ว่างในภาษาของคุณ เครื่องหมายวรรคตอนบางตัวหรือตัวอักษรอื่นอาจไม่ต้องการช่องว่างโดยรอบ พิจารณาฟังก์ชันเชลล์เป้าหมายนี้:

f () { echo a; echo b; }

ใน Bourne shell ();เป็น metacharacters และไม่ต้องการช่องว่างโดยรอบ อย่างไรก็ตาม{}เป็นคำและต้องการช่องว่างเว้นเสียแต่ว่ามันจะอยู่ถัดจาก metacharacters เราสามารถกอล์ฟออกไป 4 พื้นที่ติดกับ();แต่ต้องให้ช่องว่างระหว่างและ{echo

f(){ echo a;echo b;}

ในCommon เสียงกระเพื่อมและPicoLisp , ()มี metacharacters พิจารณารหัสนี้เพื่อหาค่าเฉลี่ยของตัวเลขสองตัว:

(/ (+ a b) 2)

เราสามารถเล่นกอล์ฟได้ 2 ที่

(/(+ a b)2)

บางภาษามีกฎที่แปลกและละเอียดอ่อนสำหรับช่องว่าง พิจารณาโปรแกรม Ruby นี้ซึ่งพิมพ์ผลรวมและผลคูณของจำนวนเต็ม

#!ruby -an
i=$F.map &:to_i
puts"#{i.reduce &:+} #{i.reduce &:*}"

แต่ละคน&ต้องการพื้นที่ก่อนหน้านั้น ใน Ruby i=$F.map &:to_iหมายถึงi=$F.map(&:to_i)ตำแหน่งที่&ส่งพารามิเตอร์บล็อก แต่i=$F.map&:to_iหมายถึงการi=$F.map.&(:to_i)ที่&เป็นผู้ประกอบการไบนารี

ความประหลาดนี้เกิดขึ้นในภาษาเช่น Perl หรือ Ruby ที่ใช้เครื่องหมายวรรคตอนที่ไม่ชัดเจน หากมีข้อสงสัยให้ใช้ REPL หรือเขียนโปรแกรมสั้น ๆ เพื่อทดสอบกฏช่องว่าง

กำหนดฟังก์ชั่นชื่อใหม่ถ้าใช้หลายครั้ง

x = SomeLongFunctionName
x(somedata)
x(somemoredata)
etc

ชื่อตัวแปรตัวอักษรเดียว

คุณมี 52 ของพวกเขา; ใช้พวกเขาทั้งหมด! อย่ากลัวที่จะลองวิธีการที่แตกต่างและเปรียบเทียบความยาว รู้ภาษาและฟังก์ชั่นทางลัด / ไลบรารีเฉพาะที่มีให้

ใช้โอเปอเรเตอร์ที่มีเงื่อนไข

ผู้ประกอบการตามเงื่อนไข

bool ? condition_true : condition_false

เป็นประโยชน์มากขึ้นตัวละครฉลาดกว่าถ้าคำสั่ง

if(a>b){r=a;}else{r=b;}

สามารถเขียนเป็น

r=a>b?a:b;

เขียนคำอธิบายรหัสของคุณ

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

เคล็ดลับนี้จะคล้ายกับคำถามทางเลือกของอัลกอริทึมและลองสิ่งใหม่ทั้งหมด ; อย่างไรก็ตามฉันพบว่าขั้นตอนในการจดบันทึกว่าแต่ละส่วนควรทำงานอย่างไรเป็นสิ่งสำคัญในการตระหนักถึงทางเลือกต่างๆ

ในฐานะโบนัสคำตอบรวมถึงคำอธิบายน่าสนใจยิ่งขึ้นสำหรับผู้ใช้รายอื่นและมีแนวโน้มที่จะถูกถอนออก

ตรวจสอบจำนวนตัวละครของคุณอีกครั้ง

ฟังดูเหมือนไม่ใช่เกมง่ายๆ แต่ระวังให้ดีคุณอาจ "บันทึก" ตัวละครสองสามตัวโดยไม่ทำอะไรเลย!

หากคุณใช้ Windows คุณอาจกำลังป้อนข้อมูล\r\nแทน\rหรือ\nเมื่อคุณกดย้อนกลับ - เพิ่มไบต์พิเศษต่อบรรทัด! เปลี่ยนอักขระควบคุมเพื่อตรวจสอบอีกครั้งว่าคุณไม่ได้ทำสิ่งนี้

ใน Notepad ++ คุณสามารถแปลงทุก\r\nปลายสายที่จะเพียงแค่ได้โดยไปที่\rEdit > EOL Conversion > UNIX/OSX Format

ตรวจสอบให้แน่ใจว่าคุณไม่ได้รวมช่องว่างต่อท้ายในการนับตัวละครของคุณ! ฟีดบรรทัดในบรรทัดล่างในรหัสของคุณก็ไม่สำคัญดังนั้นจึงไม่จำเป็นต้องนับเช่นกัน

อ่านคำถามอย่างระมัดระวัง

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

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

ใช้การดำเนินการระดับบิตเพื่อตรวจสอบตัวเลขระหว่าง 0 ถึง 2 ⁿ -1

อาจเป็นเรื่องเล็กน้อย แต่อาจมีประโยชน์ในบางครั้ง มันขึ้นอยู่กับความจริงที่ว่าตัวเลขทั้งหมดที่ m = 2 ⁿ -1 ใช้นั้นมี n บิตที่ถูกต้องที่สุดตั้งค่าเป็น 1

ดังนั้น 7 ₁₀ == 00000111 ₂ , 15 ₁₀ == 00001111 ₂ , 31 ₁₀ == 00011111 ₂และอื่น ๆ

x&~mเคล็ดลับคือ นี้จะกลับจริงเมื่อใดก็ตามที่xเป็นไม่ได้ระหว่าง 0 และm(รวม) และเท็จอย่างอื่น จะช่วยประหยัด 6 ไบต์จากการแสดงออกเทียบเท่าสั้นที่สุดต่อไป: x>=0&&x<=mแต่เห็นได้ชัดว่าทำงานได้เฉพาะเมื่อmตอบสนอง 2 ⁿ -1

นำพารามิเตอร์ฟังก์ชันมาใช้ใหม่แทนตัวแปรใหม่

มากกว่า / น้อยกว่าเพื่อบันทึกตัวเลข:

//use:
if(n>9){A}else{B}
//instead of:
if(n<10){B}else{A}

เพียงจำไว้ว่าให้สลับโค้ดจากifไปยังelseและพวกเขาจะทำสิ่งเดียวกัน (หรือสลับข้างของความไม่เท่าเทียมกัน)!

หมายเหตุ:สิ่งนี้สามารถใช้กับพลังใด ๆ ของ 10 และเชิงลบของพวกเขา:...-100, -10, 10, 100...

(ลิงค์แหล่งที่มา)

ใช้> และ <แทน> = และ <=

เมื่อตรวจสอบกับค่าจำนวนเต็มตายตัวใช้>และ<แทน>=และ<=เป็นไปได้ ตัวอย่างเช่นการใช้

if(x>24&&x<51)

สั้นกว่าการใช้ 2 ไบต์

if(x>=25&&x<=50)

หลีกเลี่ยงการแบ่งวงก่อนวัยอันควร

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

int main() {
bool m = false;
int n = 1000;
for (int i = 0; i < n; i++) {
if (i >= 100) {
m = true;
break; // remove this line
}
} 
return 0;
}

ใช้-แทน!=

สำหรับการเปรียบเทียบเชิงตัวเลข:

หาก a เท่ากับ b a-bผลลัพธ์0จะเป็นเท็จ สิ่งอื่นใดนอกจากความ0จริง ดังนั้น
หากใช้ในบริบทบูลีนa-b<=>a!=b

หากคุณใช้กับif/elseผู้ประกอบการที่ประกอบไปด้วยสิ่งนี้สามารถช่วยคุณหนึ่งไบต์เพื่อความเท่าเทียม:
a==b?c:d<=>a-b?d:c

แยกสตริงสำหรับอาร์เรย์ที่มีความยาว

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

เช่นใน GolfScript

["Foo""Bar""Baz""Quux"]  # 23 chars

กลายเป็น

"Foo
Bar
Baz
Quux"n/  # 20 chars

สำหรับบางภาษาเกณฑ์จะต่ำกว่าหนึ่งสตริง เช่นใน Java

new String[]{"Foo"}  // 19 chars

กลายเป็น

"Foo".split("~")  // 16 chars

ทำความเข้าใจกับสิ่งที่คนอื่นทำ

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

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

รู้ถึงความสำคัญของผู้ให้บริการ

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

ตัวอย่าง:

• ในทุกภาษาที่ฉันรู้ตัวดำเนินการระดับบิตมีความสำคัญมากกว่าตัวดำเนินการบูลีน: (a&b)&&cไม่จำเป็นต้องใช้วงเล็บ: a&b&&cเช่นเดียวกับ(a*b)+cไม่
• a+(b<<c)a+b*2**cสามารถเขียนเป็น
  นั่นไม่ได้บันทึกอะไรสำหรับตัวอย่างนี้ แต่มันจะถ้าcเป็นตัวอักษรจำนวนเต็มขนาดเล็ก (<14)
• การดำเนินการระดับบิตมีลำดับความสำคัญต่ำกว่าการดำเนินการทางคณิตศาสตร์ส่วนใหญ่ดังนั้นหากภาษาของคุณปลดบูลีนเป็น int คุณสามารถบันทึกไบต์a<b&&c<dด้วยa<b&c<d(ยกเว้นกรณีที่คุณต้องการการประเมินการลัดวงจร)

สั้นกว่าสำหรับลูป

หากคุณมีXคำสั่ง{อยู่ใน}for-loop คุณสามารถย้ายX-1คำสั่ง(ภายใน)for-loop หลังจากเครื่องหมายอัฒภาคที่สองfor(blah;blah;HERE)เพื่อบันทึก 3 ไบต์ (แยกข้อความโดยใช้เครื่องหมายจุลภาค, )

แทน

for(int i=0;i<9;){s+=s.length();println(i++);}

คุณสามารถย้ายข้อความใดข้อความหนึ่งไปยัง(เครื่องหมายวงเล็บปีกกาของ for-loop )ขณะที่ปล่อยข้อความอื่นออก

for(int i=0;i<9;println(i++))s+=s.length();

และบันทึก 3 ไบต์ (บันทึกอีก 1 ไบต์ต้องขอบคุณ @ETHProductions)

พูดง่ายๆ

แทน

for(blah;blah;){blah 1;blah 2;...;blah X}

ย้ายข้อความไปรอบ ๆ เพื่อที่คุณจะได้จบเรื่องนี้

for(blah;blah;blah 2,...,blah X)blah 1;

และบันทึก 3 ไบต์

ใช้เอก~สำหรับa-b-1และa+b+1

นอกจากคำแนะนำของ@Lynnเกี่ยวกับx+1→ -~x; และx-1→~-xคุณยังสามารถกอล์ฟและa-b-1a+b+1

a-b-1    // 5 bytes
a+~b     // 4 bytes

a+b+1    // 5 bytes
a-~b     // 4 bytes

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

บีบอัดหรือ / และลายเส้น

เคล็ดลับง่าย ๆ ที่ฉันคิดขึ้นมาเมื่อพยายามบีบเงื่อนไขอันยาวเหยียดที่ถูกล่ามโซ่โดย ands (หรือ ors ในกรณีนี้เพียงแทนที่ 'all' ด้วย 'any')

เช่น:

if a>0 and a<10 and a+b==4 and a+3<1:

กลายเป็น

if all([a>0,a<10,a+b==4,a+3<1]):

พึ่งพาคอมไพเลอร์เพื่อให้มีประสิทธิภาพตามที่ต้องการ

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

พิจารณาฟังก์ชัน Haskell ต่อไปนี้เพื่อคำนวณ 2 ^ n (โดยไม่สนใจข้อเท็จจริงที่ว่า Haskell มีตัวดำเนินการการยกกำลังในตัวอยู่แล้วหรือสาม) (23 ตัวอักษร):

p 0=1;p x=p(x-1)+p(x-1)

ปัญหาคือ - มันช้าอย่างน่ากลัวมันทำงานในเวลาที่ชี้แจง สิ่งนี้อาจทำให้รหัสของคุณไม่สามารถทดสอบได้หรือทำให้ข้อ จำกัด ด้านประสิทธิภาพใด ๆ ที่เกิดจากคำถามนั้นล้มเหลว คุณอาจถูกล่อลวงให้ใช้ตัวแปรชั่วคราวหรือเรียกใช้ฟังก์ชันตามตัวอักษรทันทีเพื่อหลีกเลี่ยงการเรียกใช้ฟังก์ชันซ้ำ (25 อักขระ):

p 0=1;p x=(\y->y+y)$p$x-1

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

อาจจะค่อนข้างชัดเจน แต่ ...

ใช้ประโยชน์จากค่าคืนของโอเปอเรเตอร์

โปรดทราบว่าผู้ดำเนินการที่ได้รับมอบหมายคืนค่า!

ตัวอย่างเช่นหากคุณต้องการเพิ่ม y เป็น x แล้วตรวจสอบว่า x มากกว่าสิ่งที่คุณทำหรือไม่

if(25<x+=y)

แทน

x+=y;if(x>25)

หรือบางทีคุณต้องการค้นหาความยาวของสตริงหลังจากตัดแต่ง:

strlen(s=trim(s))

ค่อนข้างมากกว่า

s=trim(s);strlen(s)

ใช้ประโยชน์จากรุ่นภาษา / คอมไพเลอร์ / สภาพแวดล้อมนิสัยใจคอ / คุณสมบัติใหม่

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

รวมหลาย / ซ้อนกันถ้าตรวจสอบการใช้และ / หรือเมื่อเป็นไปได้

เช่น:

if (a && (b || c)) {

}

แทน:

if (a) {
    if (b) {
        //Do Stuff
    } elseif (c) {
        //Do same stuff
    }
}

ค้นหาวิธีที่ดีกว่าในการเริ่มต้นตัวแปรของคุณ

บางคำตอบอื่น ๆ ใกล้จะพูดถึงสิ่งนี้อยู่แล้ว แต่ในหลาย ๆ ภาษา (พิมพ์อย่างเคร่งครัด?) มันสั้นกว่าที่จะเริ่มต้นxเป็นสตริงว่างเช่น:

x:=""

หรือxว่างเปล่า rune (char) เช่น:

x:=''

กว่า

var x string

และ

var x rune

การใช้ค่าที่มีอยู่ก่อนหน้านั้นเป็นที่ต้องการอย่างเห็นได้ชัด แต่ไม่ใช่เรื่องง่าย