เคล็ดลับการตีกอล์ฟใน GolfScript


35

อะไรโพสต์นี้ยังไม่มีอยู่?

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

เริ่มต้นด้วยนี่คือหน้าอ้างอิง GolfScript อย่างเป็นทางการ คุณควรทำความคุ้นเคยกับสิ่งเหล่านี้ก่อน:

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


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

  • วิธีการทับศัพท์ จำกัด ใน GolfScript อย่างไร {FROM?TO=}%ใช้งานได้ถ้าคุณมั่นใจได้ว่าอินพุตทั้งหมดนั้นถูกค้นพบในFROM(หรือไม่รังเกียจพวกมันทั้งหมดถูกแมปไปยังองค์ประกอบสุดท้ายของTO) แต่วิธีการทั้งหมดที่ฉันเห็นสำหรับการทิ้งค่าที่ไม่ได้แมปไว้ไม่เปลี่ยนแปลง

  • วิธีแปลงสตริงเป็นอาร์เรย์ของรหัส ASCII และย้อนกลับได้ดีที่สุด การดำเนินการใดที่ทำให้เกิดผลข้างเคียง อะไรคือวิธีที่ดีที่สุดในการถ่ายโอนอักขระในสตริงไปยังสแต็ก (เช่นเดียว~กับอาร์เรย์)


คำถามอื่น: มีวิธีที่ดีในการแปลง... xเป็น... [x]? [.;]ที่ดีที่สุดของฉันสามารถดูเป็น
Peter Taylor

@Peter: ถ้าxเป็นตัวเลขให้ใช้[]+งานได้และเป็นถ่านที่สั้นกว่า และแน่นอนถ้าxเป็นเพียงสิ่งเดียวบนสแต็คก็]จะทำ
Ilmari Karonen

ฉันต้องการถามวิธีที่ดีที่สุดที่จะทำ: min, max, and value absolute โซลูชันทั้งหมดของฉันดูเหมือนจะใช้ตัวละครมากกว่าที่ควร
Claudiu

วิธีที่ดีที่สุดในการปรับเปลี่ยนอาร์เรย์ที่ดัชนีที่กำหนดคืออะไร?
user1502040

@ user1502040: ตอบด้านล่าง (ถ้าใครรู้วิธีที่ดีกว่าโปรดแบ่งปัน!)
Ilmari Karonen

คำตอบ:


29

Rational / Float / Complex

ฉันอ่านมาหลายครั้งแล้วที่ GolfScript มีจำนวนเต็มเท่านั้นที่ฉันเริ่มเชื่อ ก็ไม่เป็นความจริง

2-1? # Raise 2 to the power of -1. Result: 0.5
4-1? # Raise 4 to the power of -1. Result: 0.25
+    # Add. Result: 0.75

ผลลัพธ์คือ

3/4

ด้วยล่าม GolfScript มาตรฐานและ

0.75

บนเว็บ GolfScript

hacks ที่คล้ายกันอนุญาตให้ร่ายไปยัง Rational, Float หรือ Complex ได้:

{-2.?./*}:rational
{2.-1??./*}:float
{-2.-1??./*}:complex

9
OMGWTFHAX o_O !!!
Ilmari Karonen

3
วัด! ค่อนข้างแน่ใจว่านี่เป็นข้อผิดพลาดในล่าม แต่ว้าว
Doorknob

3
สาย 82 Gint.new(@val**b.val)ของล่ามล่าสุด: ดูเหมือนว่าGintคอนสตรัคจะหายไปโยน int ...
พรีโม่

10

การลบตัวเลข

สิ่งหนึ่งที่ GolfScript ขาดคือผู้ดำเนินการปฏิเสธในตัว วิธีที่ชัดเจนในการแปลงตัวเลขในสแต็กเป็นค่าลบเช่น-1*หรือ0\-ต้องใช้สามตัวอักษร อย่างไรก็ตามมีวิธีการทำในสอง:

~)

สิ่งนี้ได้ผลเพราะ GolfScript ใช้เลขคณิตของสองส่วนดังนั้น ~ xเท่ากับ - x −1

แน่นอนตัวแปร(~ยังใช้งานได้; เลือกระหว่างพวกเขาโดยทั่วไปเป็นเรื่องของรสนิยม


9

การสับเปลี่ยนอาเรย์

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

{;9rand}$

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

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

รหัสต่อไปนี้ซึ่งใช้ 9 9 = 387,420,489 ค่าที่เป็นไปได้ดีสำหรับมากถึง 1,000 รายการหรือมากกว่านั้น (และยอมรับได้มากถึง 20,000)

{;9.?rand}$

สำหรับรายการที่ยาวมากให้เพิ่มอีก 9 รายการสำหรับ 99 99 ≈ 3.7 × 10 197ค่า:

{;99.?rand}$

การทดสอบ:

นี่คือการกระจายตัวขององค์ประกอบแรกในรายการ 10 องค์ประกอบที่สับโดยใช้ตัวแปรที่แตกต่างกันที่แสดงด้านบนตัวอย่างมากกว่า 10,000 การทดลอง:

  • ผลลัพธ์ของการ10,{;9rand}$0=แสดงอคติที่ชัดเจนมากโดยมี0มากกว่าสามครั้งน่าจะจบลงในตำแหน่งแรกเมื่อ1:

    0 16537 #######################################################
    1 5444  ##################
    2 7510  #########################
    3 8840  #############################
    4 9124  ##############################
    5 12875 ##########################################
    6 9534  ###############################
    7 8203  ###########################
    8 7300  ########################
    9 14633 ################################################
    
  • ด้วย10,{;99rand}$0=ความอคติส่วนใหญ่จะหายไป แต่ยังมีจำนวนที่สังเกตได้:

    0 10441 ##################################
    1 9670  ################################
    2 9773  ################################
    3 9873  ################################
    4 10134 #################################
    5 10352 ##################################
    6 10076 #################################
    7 9757  ################################
    8 9653  ################################
    9 10271 ##################################
    
  • ด้วย10,{;9.?rand}$0=การส่งออกเป็นพื้นแตกต่างจากตัวอย่างที่สุ่มอย่างแท้จริง:

    0 9907  #################################
    1 9962  #################################
    2 10141 #################################
    3 10192 #################################
    4 9965  #################################
    5 9971  #################################
    6 9957  #################################
    7 9984  #################################
    8 9927  #################################
    9 9994  #################################
    

ps สำหรับการสับอาร์เรย์หรือสตริงตัวเลขที่ไม่ดีจริงๆบางครั้งอาจใช้รหัสต่อไปนี้ได้:

{rand}$

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


3
ฉันจำได้ว่าครั้งหนึ่งฉันเคยคิดคณิตศาสตร์เกี่ยวกับวันเกิดความขัดแย้งหลังจากที่พี่ชายของฉันบอกฉันเกี่ยวกับเรื่องนี้เขาพูดถูก :(
ajax333221

8

วิธีจัดการกับคำถามย่อยเฉพาะ:

วิธีแปลงสตริงเป็นอาร์เรย์ของรหัส ASCII และย้อนกลับได้ดีที่สุด การดำเนินการใดที่ทำให้เกิดผลข้างเคียง อะไรคือวิธีที่ดีที่สุดในการถ่ายโอนอักขระในสตริงไปยังสแต็ก (เช่น ~ สำหรับอาร์เรย์)

สำหรับผู้ที่ไม่เข้าใจปัญหาระบบประเภทของ GolfScript ให้ความสำคัญกับประเภทในจำนวนเต็มลำดับอาร์เรย์สตริงสตริงบล็อก ซึ่งหมายความว่าการดำเนินการอาร์เรย์ทั่วไปที่ใช้กับสตริงมักจะให้สตริงกับคุณ เช่น

'ABC123'{)}%

จะทิ้งไว้'BCD234'บนกองซ้อน

ด้วยเหตุนี้วิธีที่ดีที่สุดในการแปลงสตริงให้เป็นอาร์เรย์ของรหัส ASCII นั้นแทบจะแน่นอนที่จะถ่ายโอนอักขระบนสแต็กแล้วจึงรวบรวมเป็นอาร์เรย์

วิธีที่ดีที่สุดในการถ่ายโอนอักขระในสตริงลงบนสแต็กคืออะไร {}/

วิธีที่ดีที่สุดในการแปลงสตริงเป็นอาร์เรย์ของรหัส ASCII คืออะไร [{}/](ด้วยข้อแม้ปกติที่ถ้าไม่มีอะไรในกองซ้อนคุณสามารถข้ามไปได้[)

วิธีที่ดีที่สุดในการแปลงอาร์เรย์ของรหัส ASCII เป็นสตริงคืออะไร? ''+(โปรดทราบว่าสิ่งนี้จะทำให้อาร์เรย์เรียบเช่นกันเช่น[65 [66 67] [[[49] 50] 51]]''+ให้'ABC123')


วิธีที่ดีที่สุดในการเปลี่ยนรหัส ASCII เดียวให้เป็นสตริงคืออะไร []+''+? (ดูเหมือนจะค่อนข้างยาว)
Justin

@ ควินนันซ์มันค่อนข้างนาน แต่ฉันไม่รู้วิธีที่ดีกว่า สิ่งที่ต้องทำอาจดูว่ารหัส ASCII มาจากที่ใดและดูว่าคุณสามารถทำให้มันมาถึงอาร์เรย์ได้หรือไม่
Peter Taylor

6

หากโปรแกรมของคุณแตกอย่างลึกลับให้ตรวจสอบตัวแปรของคุณ

ฉันเพิ่งใช้เวลาสักครู่ในการดีบักโปรแกรมที่ถูกต้องซึ่งเห็นได้ชัดว่าใช้!เป็นตัวแปร (เพราะฉันไม่ได้ใช้มันอีก) แต่น่าเสียดายที่ผมไม่ได้ใช้งานifและปรากฎว่าการดำเนินงานของifสาย!การตัดสินใจที่สาขาที่จะปฏิบัติตาม


6

การตัดรายการด้านบนของสแต็กเป็นอาร์เรย์

มีวิธีที่ดีในการแปลง... xเป็น... [x]?

เพื่อความสมบูรณ์แบบตัวเลือกที่ดีที่สุดดูเหมือนจะเป็น 4 ตัวอักษร อย่างไรก็ตามในกรณีพิเศษบางอย่างก็เป็นไปได้ที่จะลดสิ่งนี้

1 ถ่าน

]ทำงานในกรณีพิเศษที่xเป็นสิ่งเดียวในสแต็ก

3 ตัวอักษร

[]+ทำงานในกรณีพิเศษที่xเป็นจำนวนเต็ม

.,/ทำงานในกรณีพิเศษที่xเป็นอาร์เรย์หรือสตริงที่เป็นความจริง เช่น"AB".,/ให้["AB"]; จะช่วยให้3,.,/ [[0 1 2]]อย่างไรก็ตาม"".,/และทั้งสองให้[].,/[]

4 ตัวอักษร

[.;] ทำงานอย่างไม่มีเงื่อนไข


6

วิธีที่ดีที่สุดในการปรับเปลี่ยนอาร์เรย์ที่ดัชนีที่กำหนดคืออะไร? - user1502040

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

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

  • .i<[x]+\i>+(11 ตัวอักษร) - ใส่ค่าxลงในอาร์เรย์ที่ดัชนี (ตาม 0)i

ในการแทนที่ค่าที่ดัชนีiด้วยxเราแค่ต้องย่อช่วงครึ่งหลังของอาร์เรย์ด้วยองค์ประกอบเดียว:

  • .i<[x]+\i)>+(12 ตัวอักษร) - แทนที่องค์ประกอบที่ดัชนี (ตาม 0) iด้วยค่าx

อีกทางหนึ่งการตัดทอนครึ่งแรกแทนจะทำสิ่งเดียวกันได้อย่างมีประสิทธิภาพ แต่ด้วยการจัดทำดัชนีแบบ 1 ซึ่งบางครั้งอาจจะดีกว่า:

  • .i(<[x]+\i>+(12 ตัวอักษร) - แทนที่องค์ประกอบที่ดัชนี (ตาม 1) iด้วยค่าx

ในตัวอย่างด้านบนทั้งหมดถ้าxเป็นตัวเลขวงเล็บสี่เหลี่ยมรอบ ๆ อาจถูกละเว้นเพื่อบันทึกอักขระสองตัวเนื่องจากจะถูกรวมเข้ากับอาร์เรย์โดยอัตโนมัติ+:

  • .i<x+\i>+(9 ตัวอักษร) - ใส่ตัวเลขxลงในอาร์เรย์ที่ดัชนี (ตาม 0)i
  • .i<x+\i)>+(10 ตัวอักษร) - แทนที่องค์ประกอบที่ดัชนี (ตาม 0) iด้วยจำนวนx
  • .i(<x+\i>+(10 ตัวอักษร) - แทนที่องค์ประกอบที่ดัชนี (1-based) iด้วยจำนวนx

วงเล็บอาจถูกละเว้นถ้าอย่างใดอย่างหนึ่งxหรืออินพุต "อาร์เรย์" (หรือทั้งสอง) เป็นสตริงจริงซึ่งในกรณีนี้ผลลัพธ์จะถูก coerced เป็นสตริง (ใช้กฎการแปลงอาร์เรย์→สตริงสตริงปกติ)


ps ในกรณีพิเศษถ้าเรารู้ว่าอาร์เรย์มีองค์ประกอบระหว่างiและ 2 × iเราสามารถแทรกองค์ประกอบใหม่xที่ดัชนี( ตาม 0) iด้วยi/[x]*(6 ตัวอักษร) สิ่งนี้จริง ๆ แล้วแบ่งอาร์เรย์เป็นส่วนของiองค์ประกอบและแทรกxระหว่างแต่ละอัน โปรดทราบว่าในกรณีนี้วงเล็บมีความจำเป็นแม้ว่าxจะเป็นตัวเลขก็ตาม


pps แนวทางอื่นคือการใช้ตัวแปรที่ตั้งชื่อแบบไดนามิก ตัวอย่างเช่น,

 'foo' 42 ':x'\+~

จะกำหนดค่า'foo'ให้กับตัวแปรx42ในขณะที่

 42 'x'\+~

จะดึงมันมา

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


3
ปิดกระทู้ทั้งหมด: ขอแสดงความยินดีกับ 10k! :-D
Doorknob

1
หากคุณรู้ว่าอาเรย์นั้นไม่มีค่าซ้ำกันคุณสามารถแทนที่ค่าที่ดัชนีiสำหรับ 9 ไบต์:.[i=]/[x]*
Martin Ender

5

การจัดการผลผลิตสุดท้าย

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

]puts

สิ่งที่เอกสารไม่ตรงพูดถึงก็คือว่าล่ามแท้จริงเรียกตัวในputsการผลิตผลผลิตนี้และที่ว่านี้ในตัวเป็นตัวอักษรหมายถึง:

{print n print}:puts;

ดังนั้นคุณสามารถระงับหรือจัดการกับผลลัพธ์สุดท้ายโดย Redefining puts, print และ / หรือn(หรือ ถ้าคุณรู้สึกกำลังบิดจริงๆ) นี่คือตัวอย่างบางส่วน:

ระงับการขึ้นบรรทัดใหม่:

'':n;

(แน่นอนคุณสามารถปล่อยให้;ถ้าคุณไม่สนใจสตริงว่างพิเศษในกอง.)

ไม่แสดงผลลัพธ์สุดท้าย:

:puts

สิ่งนี้จะเขียนทับputsสิ่งที่เกิดขึ้นบนสแต็ก หากเกิดขึ้นเป็นสิ่งที่คุณไม่ต้องการดำเนินการคุณสามารถใช้เช่น0:puts;แทน โปรดทราบว่าสิ่งนี้ยังระงับp(ซึ่งกำหนดไว้เป็น{`puts}:p;) แต่คุณยังสามารถใช้printสำหรับการส่งออกถ้าคุณต้องการ


และnothingคุณหมายถึง\nอะไร
CalculatorFeline

หากคุณไม่สนใจบรรทัดใหม่ที่ตามมาคุณสามารถใช้];เพื่อระงับเอาต์พุตสุดท้าย
กำจัด

5

ฉันต้องการถามวิธีที่ดีที่สุดที่จะทำ: min, max, and value absolute โซลูชันทั้งหมดของฉันดูเหมือนจะใช้ตัวละครมากกว่าที่ควร - Claudiu

ต่ำสุด / สูงสุด

ในการหาค่าที่น้อยที่สุด / มากที่สุดในอาเรย์ให้เรียงลำดับและนำองค์ประกอบแรก / ตัวสุดท้าย:

  • $0= (3 ตัวอักษร) - องค์ประกอบขั้นต่ำใน arry
  • $-1= (4 ตัวอักษร) - องค์ประกอบสูงสุดในอาร์เรย์

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

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

  • [\]$0= (6 ตัวอักษร) - อย่างน้อยสองค่าในกองซ้อน
  • [@]$0= (6 ตัวอักษร) - อย่างน้อยสามค่าในกอง
  • [\]$1= (6 ตัวอักษร) - ค่าสูงสุดสองค่าในสแต็ก
  • [@]$2= (6 ตัวอักษร) - สูงสุดสามค่าในกองซ้อน

เคล็ดลับเดียวกันนี้ยังสามารถใช้เพื่อค้นหาค่ามัธยฐานของสามค่าซึ่งอาจมีประโยชน์ในบางครั้ง:

  • [@]$1= (6 ตัวอักษร) - ค่ามัธยฐานของสามค่าในกอง

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

  • .2$>$ (5 ตัวอักษร) - ค้นหาค่าอย่างน้อยสองค่าบนสแต็กในขณะที่ปล่อยให้ค่าดั้งเดิมไม่ถูกแตะต้อง
  • .2$<$ (5 ตัวอักษร) - ค้นหาค่าสูงสุดสองค่าบนสแต็กในขณะที่ปล่อยให้ค่าดั้งเดิมไม่ถูกแตะต้อง

วิธีการทำงานคือการ.2$โคลนองค์ประกอบสองอันดับแรกบนสแต็กในลำดับที่กลับรายการ (เช่นa ba b b a) </ >เปรียบเทียบสำเนาและส่งกลับ 0 หรือ 1 และสเกลาร์$จากนั้นก็คัดลอกหนึ่งในสองค่าอินพุตขึ้นอยู่กับผลของการเปรียบเทียบ


หากคุณมีจำนวนเต็มสองจำนวนที่ไม่ต้องการลบบนสแต็กคุณสามารถใช้,\,&,(5 ตัวอักษร) เพื่อค้นหาค่าต่ำสุดและ,\,|,(5 ตัวอักษร) เพื่อค้นหาค่าสูงสุด เคล็ดลับนี้ใช้การตั้งค่าจุดตัดและสหภาพตามลำดับในช่วง คุณสามารถบันทึกอักขระอื่นได้ถ้าเป็นไปได้ที่จะนำ,ไปใช้กับแต่ละอาร์กิวเมนต์แยกกันโดยไม่ต้องแลกเปลี่ยนมัน เนื่องจากวิธีนี้คำนวณช่วงสำหรับแต่ละอาร์กิวเมนต์จึงไม่มีประสิทธิภาพมากสำหรับจำนวนที่มากขึ้น แต่อาจมีประโยชน์มากสำหรับอินพุตที่เล็กลง

วิธีที่สั้นยิ่งกว่านี้ในการค้นหาขั้นต่ำของจำนวนเต็มไม่เป็นลบสองตัวบนสแต็กคือ,<,(3 ตัวอักษร) อนิจจาเคล็ดลับนี้ใช้ไม่ได้กับการหาค่าสูงสุด


ค่าสัมบูรณ์

ตัวดำเนินการค่าสัมบูรณ์ของ GolfScript ในตัวคือabs(3 ตัวอักษร) แม้ว่านี่จะเป็นสองตัวอักษรมากกว่าที่ฉันต้องการ แต่ก็ยากที่จะเอาชนะโดยทั่วไป

ในบางกรณี (เช่นสำหรับการเรียงลำดับโดยค่าสัมบูรณ์) คุณอาจพบว่าสแควร์ของตัวเลขเป็นค่าทดแทนที่เพียงพอสำหรับค่าสัมบูรณ์ นี้สามารถคำนวณได้ในสองตัวอักษรอย่างใดอย่างหนึ่งหรือ2? .*ดังนั้นเราจะได้รับ:

  • {.*}$0= (7 ตัวอักษร) - องค์ประกอบขั้นต่ำโดยค่าสัมบูรณ์ในอาร์เรย์
  • {.*}$-1= (8 ตัวอักษร) - องค์ประกอบสูงสุดโดยค่าสัมบูรณ์ในอาร์เรย์

ในทำนองเดียวกันแทนที่จะทดสอบเช่นถ้าค่าสัมบูรณ์ของตัวเลขน้อยกว่า 3 ด้วยabs 3<(6 ตัวอักษรรวมถึงช่องว่าง) คุณสามารถทดสอบว่ารูปสี่เหลี่ยมจัตุรัสน้อยกว่า 9 ด้วย.*9<(4 ตัวอักษรไม่จำเป็นต้องใช้พื้นที่)


หากคุณมีจำนวนเต็มสองจำนวนที่ไม่ต้องการลบบนสแต็กคุณสามารถใช้,\,&,(5 ตัวอักษร) เพื่อค้นหาค่าต่ำสุดและ,\,|,(5 ตัวอักษร) เพื่อค้นหาค่าสูงสุด เคล็ดลับนี้ใช้การตั้งค่าจุดตัดและสหภาพตามลำดับในช่วง คุณสามารถบันทึกอักขระอื่นได้ถ้าเป็นไปได้ที่จะนำ,ไปใช้กับแต่ละอาร์กิวเมนต์แยกกันโดยไม่ต้องแลกเปลี่ยนมัน เนื่องจากวิธีนี้คำนวณช่วงสำหรับแต่ละอาร์กิวเมนต์จึงไม่มีประสิทธิภาพมากสำหรับจำนวนที่มากขึ้น แต่อาจมีประโยชน์มากสำหรับอินพุตที่เล็กลง
KirarinSnow

@KirarinSnow: ขอบคุณ! ฉันได้เพิ่มไปยังคำตอบ
Ilmari Karonen

4

การลบรายการที่ซ้ำออกจากอาร์เรย์

ตัวดำเนินการที่ตั้งค่าไว้|(สหภาพ), &(ทางแยก) และ^(ความแตกต่างแบบสมมาตร) จะยุบองค์ประกอบหลายแถวให้เป็นหนึ่งเดียว ดังนั้นวิธีที่ง่ายที่สุดในการลบองค์ประกอบที่ซ้ำกันออกจากอาร์เรย์คือการรวมกันหรือแยกด้วยกัน:

.|

หรือ:

.&

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


4

การทับศัพท์ จำกัด

ในการจัดการกับคำถามย่อยเฉพาะ: กำหนดสตริงเป็นวิธีที่ดีที่สุดในการดำเนินการtrอย่างไร เช่นtr/ABC/abc/

หากตัวละครทั้งหมดในสตริงจะได้รับผลกระทบนี่เป็นเรื่องง่าย: {'ABC'?'abc'=}%(ค่าใช้จ่าย: 9 ตัวอักษร)

อย่างไรก็ตามการแบ่งว่าถ้าบางส่วนของตัวอักษรที่ไม่ได้ทับศัพท์และช่วยให้'ABC'?-1

หากการทับศัพท์ไม่ใช่วงจรก็สามารถทำได้ครั้งละหนึ่งการแทนที่ด้วยการแยกสตริงและรวม: 'AaBbCc'1/2/{~@@/\*}/(ค่าใช้จ่าย: 15 ตัวอักษร) สิ่งนี้อาจจะแก้ไขได้ แต่มีวิธีการอื่นที่ดีกว่าและใช้งานได้กับนักแปลแบบวนรอบ

ปัจจุบันโซลูชันทั่วไปที่สั้นที่สุดมีค่าใช้จ่าย 14 ตัวอักษร:

  • วิธีการหนึ่งที่เกี่ยวข้องกับการหลบหนีตัวละคร: ที่ซึกเป็นโมฆะตัวอักษร (แน่นอนวิธีการนี้ไม่ได้สมบูรณ์แบบโดยทั่วไป: ไม่สามารถแมปอักขระอื่นเป็นไบต์ว่างได้){.'ABC'?'abc0'=\or}%0

  • หรือ{.'ABC'?'abc'@),+=}%มีค่าใช้จ่ายเท่ากัน แต่ใช้อักขระ ASCII ที่พิมพ์ได้เท่านั้น วิธี@),+นี้เป็นวิธีที่ซับซ้อน (แต่เห็นได้ชัดว่าสั้นที่สุด) เพื่อให้แน่ใจว่าสตริงการแทนที่จะลงท้ายด้วยอักขระอินพุตเสมอ


โดยใช้วิธีการที่ผ่านมาสำหรับสายป้อน'ABCDEF'ฉันได้รับผลแต่ผลที่เหมาะสมจะเป็น'abc000' 'abcDEF'ฉันพลาดอะไรไปรึเปล่า?
Cristian Lupascu

1
@ w0lf นั่นคือ 0 ในตัวหนาเพราะมันเป็นตัวละครหนีกล่าวถึงก่อนหน้านี้ - เช่นไบต์ 0
Peter Taylor

4

เปลี่ยนสตริงเป็นอาร์เรย์ของอักขระ

คุณสามารถทำได้โดยพิมพ์: 1/หลังจากนั้น

ตัวอย่าง: ผลักดันไปยังกองอาร์เรย์"String"1/['S''t''r''i''n''g']

สิ่งนี้มีประโยชน์เมื่อคุณต้องการย้ายตัวอักษรไปรอบ ๆ สตริง


1
คุณช่วยยกตัวอย่างว่ามันจะมีประโยชน์อย่างไร? สตริงทำหน้าที่เหมือนอาร์เรย์อยู่แล้วดังนั้นจึงไม่เป็นประโยชน์
Justin

@Quincunx มันจะมีประโยชน์เมื่อคุณต้องการที่จะโผล่ออกมาตัวละครและไม่ใช่ค่าของพวกเขา
3700847

และเมื่อไหร่ที่คุณต้องการทำเช่นนั้น?
Justin

5
@Quincunx: การหมุนสตริงตัวอย่างเช่น "abc"1/(+-> "bca"แต่->"abc"(+ bc97
เดนนิส

4

การกำหนดให้เป็นตัวอักษรตัวเลข

บ่อยครั้งแทนที่จะเขียน1:xแล้วใช้ / อัปเดตตัวแปรxคุณสามารถใช้และอัปเดต1โดยตรงได้:

1:^;{^.p.+:^;}5*
{1.p.+:1;}5*       (4 bytes shorter)

แน่นอนว่าสิ่งนี้ใช้ได้กับค่าเริ่มต้นอื่น ๆ ด้วย แต่จะแตกถ้าค่านั้นเกิดขึ้นที่ใดในรหัสของคุณ

เครื่องหมายวรรคตอนเป็นชื่อตัวแปร

หากคุณมีตัวแปรการใช้งานก็ยังมักจะฉลาดที่จะใช้เครื่องหมายวรรคตอนที่ไม่อยู่ในรหัสของคุณ - จำนวนมากของโปรแกรมที่สามารถทำได้โดยไม่&, |, หรือ^ ?ตัวอย่างเช่นวิธีนี้คุณสามารถเขียน&nแทนx nการกดตัวแปรแล้วกดขึ้นบรรทัดใหม่


3
การกำหนดบางอย่างอาจมีผลข้างเคียงที่ไม่คาดคิด โดยเฉพาะอย่างยิ่งการกำหนดที่จะ!มักจะเป็นความคิดที่ดีที่จะทำลายifและdo(เช่นเดียวกับwhile, until, and, orและxor) ในทำนองเดียวกันorจะถูกกำหนดโดยล่ามเป็นชื่อแทนสำหรับ1$\ifดังนั้น Redefining 1, $หรือ\ยังจะทำลายมัน นิยามใหม่ของการแบ่ง` p
Ilmari Karonen

3

การกรองอาเรย์

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

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

  • a b -: ลบองค์ประกอบใด ๆ ที่พบในอาร์เรย์bจากอาร์เรย์a
  • a. b --: ลบองค์ประกอบใด ๆ ที่ไม่พบในอาร์เรย์bจากอาร์เรย์a

โดยเฉพาะสิ่งนี้สามารถใช้เพื่อนับจำนวนครั้งที่องค์ประกอบเกิดขึ้นในอาร์เรย์:

  • a.[c]--,: นับจำนวนครั้งที่องค์ประกอบcเกิดขึ้นในอาร์เรย์a

โดยทั่วไปวิธีการนี้ไม่เหมาะเนื่องจากอย่างใดอย่างหนึ่ง:

  • a[c]/,(: นับจำนวนครั้งที่องค์ประกอบcเกิดขึ้นในอาร์เรย์a
  • a{c=},,: นับจำนวนครั้งที่องค์ประกอบcเกิดขึ้นในอาร์เรย์a

สั้นกว่าหนึ่งตัวอักษร (และถ้าหากตกลงเพื่อให้การนับถูกปิดหนึ่งตัวa[c]/,จะช่วยประหยัดอักขระอีกหนึ่งตัว) อย่างไรก็ตามในกรณีพิเศษที่cมีตัวเลขและaเป็นอาร์เรย์ปกติ (ไม่ใช่สตริง) วงเล็บเหลี่ยมรอบcอาจถูกตัดออกเนื่องจากตัว-ดำเนินการบีบอัดอาร์กิวเมนต์เป็นชนิดเดียวกัน:

  • a.c--,: นับจำนวนครั้งที่จำนวนcเกิดขึ้นในอาร์เรย์ (ไม่ใช่สตริง!)a

(ถ้าaเป็นสตริงและcเป็นตัวเลขระหว่าง 0 ถึง 9 a.c--จะนับจำนวนครั้งที่มีตัวเลข cเกิดขึ้นa)


เคล็ดลับที่คล้ายกันสามารถใช้เพื่อค้นหาองค์ประกอบที่พบบ่อยที่สุดในอาร์เรย์ :

:a{a\[.]-,}$0=

ถ้าอินพุตเป็นอาร์เรย์ของตัวเลข[.]ลำดับทั้งหมดอาจถูกละเว้น อนิจจานี้ไม่ได้[.]ทำงานให้กับสายได้โดยไม่ต้อง


สำหรับการนับที่เกิดขึ้น (กรณีทั่วไป) a[c]/,(และa{c=},,สั้นลงหนึ่งไบต์
Dennis

@Dennis: ขอบคุณ! ฉันเคยแก้ไขสิ่งต่อไปนี้
Ilmari Karonen

3

อ่านจาก STDIN

GolfScript สามารถอ่านได้จาก stdin:

"#{STDIN.read}"

สิ่งนี้จะอ่านต่อจาก STDIN จนกว่า EOF จะถึง อีกวิธีหนึ่งคือ:

"#{STDIN.gets}"

หรือ

"#{STDIN.readline}"

สิ่งอื่น ๆ ที่มี:

getbyte
getc
gets([sep])
gets(limit)
gets(sep, limit)
inspect # perhaps useful for an underhanded contest
isatty
read([length])
readbyte
readchar
readline([sep])
readline(limit)
readline(sep, limit)
readlines([sep])
readlines(limit)
readlines(sep, limit)
readpartial(maxlen [, outbuf])

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


2
คุณอาจต้องการเพิ่มคำพูดที่{"#{STDIN.readline}"p}2*ไม่ได้อ่าน 2 บรรทัด แต่แทนที่จะประเมินสตริงเพียงครั้งเดียว
Howard

2
หากคุณกำหนดค่าเริ่มต้นiเป็นจำนวนเต็มใด ๆ'"#{'i):i';STDIN.gets}"'++~จะให้ผลลัพธ์ที่แตกต่างทุกครั้งที่ประเมิน Backticks อาจคุ้มค่าที่จะกล่าวถึง ถ้าเราคิด Linux เราสามารถใช้เช่นแทน`head -1` STDIN.gets
Dennis

@Dennis: "#{var'g','gpush Gstring.new(STDIN.gets)'.cc}";ยังช่วยให้คุณกำหนดตัวดำเนินการ GolfScript ใหม่ gที่อ่านบรรทัดจาก stdin และกดลงบนสแต็ก
Ilmari Karonen

2

การถอดรหัสอินพุตเลขฐานสิบหก

GolfScript ไม่มีตัวอักษรฐานสิบหกจำนวนเต็มดังนั้นอนิจจาคุณสามารถไม่เพียง ~แต่แยกการป้อนข้อมูลเลขฐานสิบหกด้วย แต่ถ้ารหัสของคุณต้องป้อนค่าเลขฐานสิบหกคุณจะต้องแยกวิเคราะห์รหัสด้วยตนเอง

8-char loop นี้นำไปใช้กับสตริงจะแปลงเลขฐานสิบหกตัวเล็กให้เป็นตัวเลขเทียบเท่า:

{39%9-}%

หากคุณต้องยอมรับเลขฐานสิบหกตัวพิมพ์ใหญ่ด้วยวิธีที่ง่ายที่สุด (และสั้นที่สุด) คือการลดตัวอักษรเหล่านั้นด้วยตัวอักษรแรกโดย32|มีทั้งหมด 11 ตัวอักษร:

{32|39%9-}%

โปรดทราบว่าผลลัพธ์ทางเทคนิคจะยังคงเป็นสตริง (ประกอบด้วยอักขระ ASCII 0 - 15) แต่ฟังก์ชันอาร์เรย์ GolfScript ส่วนใหญ่จะยอมรับสตริงด้วย หากคุณต้องการอาเรย์อย่างแน่นอนคุณสามารถใช้งานได้ตลอดเวลา[{39%9-}/](ซึ่ง[ตัวเลือกแรกเป็นทางเลือกถ้าสแต็กว่างเปล่า)

ในการแปลงผลลัพธ์ของโค้ดด้านบนเป็นจำนวนเต็มคุณสามารถใช้16base(6 ตัวอักษร) หากคุณต้องการอาร์เรย์จำนวนหนึ่งแทนวิธีแก้ปัญหาที่สั้นที่สุดที่ฉันพบคือเพียงแค่ถอดรหัสเลขฐานสิบหกแต่ละคู่ด้วย2/{16base}%(11 ตัวอักษร) ทั้งหมดมารวมกันโค้ดที่สั้นที่สุดที่ฉันพบเพื่อเปลี่ยนสตริง hex ให้เป็นอาร์เรย์ไบต์คือ 8 + 11 = 19 ตัวอักษร:

{39%9-}%2/{16base}%

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


2

การกำหนดตัวดำเนินการในตัวใหม่

ล่าม GolfScript มาตรฐานมีคุณสมบัติที่ไม่ค่อยได้ใช้ที่อนุญาตให้มีการแก้ไขโค้ดรูบี้ในตัวอักษรสตริงที่ยกมาสองครั้ง

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

อย่างไรก็ตามสิ่งหนึ่งที่คุณสมบัตินี้ดีสำหรับการกำหนดตัวดำเนินการ GolfScript ใหม่ที่ใช้ในรหัสทับทิม ตัวอย่างเช่นต่อไปนี้เป็นวิธีการกำหนดตัวดำเนินการเพิ่มเติมไบนารีใหม่ที่ทำงานเหมือนกับตัวดำเนินการมาตรฐานใน+ตัว:

"#{var'add','gpush a+b'.cc2}";

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

1 2 add          # evaluates to 3
"foo" "bar" add  # evaluates to "foobar"

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

"#{var'shuf','gpush a.factory(a.val.shuffle)'.cc1}";

10,shuf          # evaluates to 0,1,2,...,9 in random order

หรือพิมพ์เนื้อหาของสแต็กทั้งหมด:

"#{var'debug','puts Garray.new($stack).ginspect'.cc}";

4,) ["foo" debug  # prints ["" [0 1 2] 3 "foo"], leaving the stack untouched

หรืออินพุตแบบโต้ตอบ:

"#{var'gets','gpush Gstring.new(STDIN.gets)'.cc}";

]; { "> " print gets ~ ]p 1 } do   # simple GolfScript REPL

หรือแม้กระทั่งการเข้าถึงเว็บ:

"#{
  require 'net/http'
  require 'uri'
  var'get','gpush Gstring.new(Net::HTTP.get_response(URI.parse(a.to_s)).body)'.cc1
}";

"http://example.com" get

แน่นอนว่านักกอล์ฟส่วนใหญ่ (และมีความเสี่ยง!) จะได้รับการปฏิบัติเช่นนี้:

"#{var'get','gpush Gstring.new(`curl -s #{a}`)'.cc1}";

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


มันทำงานยังไง?

การอ้างอิงที่มีสิทธิ์ในวิธีการกำหนดผู้ประกอบการ GolfScript ใหม่ในลักษณะนี้เป็นของหลักสูตรที่ซอร์สโค้ดล่าม ที่กล่าวว่านี่เป็นเคล็ดลับสั้น ๆ :

  • ในการกำหนดโอเปอเรเตอร์ใหม่nameที่รันโค้ด Ruby codeให้ใช้:

    var'name','code'.cc
  • ภายในรหัสที่ใช้gpopในการอ่านค่าออกมาจาก stack และgpushจะผลักดันหนึ่งกลับมาอยู่ใน. $stackคุณยังสามารถเข้าถึงสแต็คโดยตรงผ่านอาร์เรย์ ตัวอย่างเช่นในการผลักดันให้ทั้งสองaและbบนสแต็คก็ golfier ที่จะทำมากกว่า$stack<<a<<bgpush a;gpush b

    • ตำแหน่งของ[เครื่องหมายเริ่มต้นอาร์เรย์จะถูกเก็บไว้ใน$lbอาร์เรย์ gpopฟังก์ชั่นการดูแลของการปรับเครื่องหมายเหล่านี้ลงหากสแต็ค shrinks ด้านล่างตำแหน่งของพวกเขา แต่การจัดการกับ$stackอาร์เรย์โดยตรงไม่ได้
  • .ccวิธีสตริงที่รวบรวมรหัสทับทิมในสตริงเป็นผู้ประกอบการ GolfScript Gblock.new()เป็นเพียงความสะดวกสบายรอบเสื้อคลุม นอกจากนี้ยังมีสายพันธุ์.cc1, .cc2และ.cc3ที่ทำให้ผู้ประกอบการโดยอัตโนมัติ pop 1, 2 หรือ 3 ข้อโต้แย้งปิดสแต็คและกำหนดให้กับตัวแปรa, และb cนอกจากนี้ยังมี.orderวิธีการที่ใช้งานได้.cc2ยกเว้นว่าจะเรียงลำดับข้อโต้แย้งตามลำดับความสำคัญของประเภทโดยอัตโนมัติ

  • ค่าทั้งหมดในกอง GolfScript มี (และควรจะเป็น!) วัตถุชนิดGint, Garray, หรือGstring Gblockจำนวนเต็มพื้นฐานหรืออาเรย์พื้นฐานที่จำเป็นสามารถเข้าถึงได้ผ่าน.valวิธีการ

    • อย่างไรก็ตามโปรดทราบว่าGstring.valส่งคืนอาร์เรย์Gints! ในการเปลี่ยนเป็นGstringสตริงรูทีนดั้งเดิมให้เรียก.to_sใช้แทน (หรือใช้ในบริบทที่ทำโดยอัตโนมัติเช่นการแก้ไขสตริง) การเรียก.to_gsใช้ค่า GS ใด ๆ จะเปลี่ยนเป็น a Gstringเพื่อให้ค่า GS ใด ๆ สามารถทำให้เป็นสตริง.to_gs.to_sได้
  • gpushฟังก์ชั่นไม่ได้อัตโนมัติห่อหมายเลขทับทิมพื้นเมืองสตริงหรืออาร์เรย์ลงในประเภท GS Gstring.new()สอดคล้องกันดังนั้นคุณมักจะต้องทำมันด้วยตัวคุณเองโดยชัดเจนเช่นการเรียก หากคุณกดรหัสอื่นใดที่ไม่ใช่ประเภท GS ลงในสแต็กรหัสใด ๆ ที่พยายามจะจัดการในภายหลังนั้นอาจมีปัญหาได้

  • ประเภทค่า GS ยังมี.factoryวิธีที่เรียกใช้ตัวสร้างของประเภทซึ่งจะมีประโยชน์เช่นสำหรับการ rewrapping อาร์เรย์ / สตริงหลังจากจัดการเนื้อหาของพวกเขา ประเภททั้งหมดยังมี.coerceวิธีที่ดำเนินการบังคับประเภท : a.coerce(b)ส่งคืนคู่ที่มีaและbบังคับให้เป็นประเภทเดียวกัน

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.