ตอนนี้ฉันติดเกม Code Golf อย่างถี่ถ้วนอาจถึงเวลาที่ฉันพยายามเลือกภาษากอล์ฟสักสองสามภาษา

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

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

ย้ายจาก JavaScript เป็น Japt

ดังที่คุณทราบ Japt เป็น JavaScript ที่ย่อและขยายเพิ่ม ฉันสร้าง Japt เพราะฉันเบื่อกับชื่ออสังหาริมทรัพย์ที่ยาว ๆString.fromCharCode(x)และMath.floor(x)และความน่าเบื่อของการทำสิ่งต่าง ๆ เช่นการสร้างช่วง นี่คือขั้นต่ำเปลือยที่คุณต้องรู้เมื่อไปจาก JavaScript เป็น Japt:

• Japt เป็นtranspiledภาษา รหัส JaptP ถูกแปลงเป็นจาวาสคริปต์จากนั้นเรียกใช้เป็น JS (ฉันเดาว่าคุณสามารถพูดได้ว่าคอมไพล์แต่ transpiled ฟังดูทันสมัยยิ่งขึ้นคำเตือน: ฉันไม่รู้อะไรเลยเกี่ยวกับการเป็นฮิปสเตอร์)
• รายการทั้งหมดเป็นโปรแกรมเต็มตามค่าเริ่มต้น การป้อนข้อมูลจะแยกกันโดยปริยายและหกปัจจัยแรกที่จะใส่ลงในตัวแปรU, V, W, X, YและZ; Nอาร์เรย์เต็มรูปแบบจะถูกเก็บไว้ใน ผลลัพธ์ของนิพจน์สุดท้ายจะถูกพิมพ์โดยอัตโนมัติ
• ตัวอักษรตัวพิมพ์ใหญ่ทั้งหมดเป็นตัวแปรและยังคงเหมือนเดิมเมื่อ transpiled ส่วนใหญ่มีค่าที่ตั้งไว้ล่วงหน้าซึ่งคุณสามารถค้นหาได้ในส่วน "ตัวแปร" ของเอกสาร Japt (ที่ล่าม )
• อักษรตัวพิมพ์เล็กทั้งหมดที่มีฟังก์ชั่นต้นแบบหรือวิธีการ Japt เพิ่มวิธีการa- z(และà- ÿ) กับตัวเลขสตริงและอาร์เรย์ เมื่อคุณใช้ตัวอักษรตัวใดตัวหนึ่ง Japt จะเติมใน.และ(; Ucใน Japt เทียบเท่ากับU.c(ใน JavaScript ซึ่งอาจหมายถึง ceil, charCodeAt หรือ concat Uขึ้นอยู่กับชนิดของ นี่คือที่มาของพลังส่วนใหญ่ของ Japt มาจาก; คุณสามารถค้นหารายการทั้งหมดของวิธีการเหล่านี้ได้ในส่วน "_____ ฟังก์ชั่น" ของเอกสาร Japt (ที่ล่าม )
• พื้นที่แสดงให้เห็นถึง)และแสดงให้เห็นถึง) ))นี่เป็นเพราะเมื่อฉันออกแบบ Japt ครั้งแรกฉันต้องการที่จะบันทึกจำนวนไบต์ให้ได้มากที่สุดและนั่นคือวิธีที่ฉันคิดว่าจะทำสิ่งนี้เป็นครั้งแรก (แม้ว่าUs w nจะดูดีกว่าUs)w)n)IMHO)
• ฟังก์ชั่นถูกแสดงว่าเป็นABC{...}โดยที่ABCสามารถเป็นสตริงของตัวแปรใด ๆ ฟังก์ชั่นการทำงานส่วนใหญ่ที่พวกเขาทำใน JS ความแตกต่างที่สำคัญคือการแสดงออกครั้งสุดท้ายจะถูกส่งกลับโดยอัตโนมัติ (แทนที่จะต้องใช้returnหรือวงเล็บ ES6 แฟนซี)
• 'แสดงถึงอักขระตัวเดียว (เช่น'aเดียวกับ"a") และ#รับโค้ดตัวถัดไปและกลายเป็นหมายเลขนั้น ( #eเป็นตัวเดียวกัน101)
• สิ่งใดระหว่างเครื่องหมายดอลลาร์$ยังคงเหมือนเดิมในระหว่างขั้นตอนการถ่ายโอน คุณสามารถใช้สิ่งนี้เพื่อสร้างforลูปได้เนื่องจาก Japt ไม่มีสิ่งเหล่านั้น แต่ฉันขอแนะนำให้ใช้วิธีอื่น (เช่นmในสตริงและอาร์เรย์หรือoบนตัวเลข)
• ตัวอักษรอื่น ๆ ส่วนใหญ่ที่ใช้กันทั่วไปใน JS - "", 0-9, (, +, =ฯลฯ - พักเดียวกันเมื่อ transpiled (ส่วนใหญ่อยู่แล้ว)

และนั่นคือทั้งหมดที่คุณต้องรู้เพื่อเขียนรหัส Japt Basic การบรรลุพลังกอล์ฟสูงสุดใน Japt ต้องใช้ความรู้มากขึ้น แต่สามารถพบได้ในคำตอบอื่น ๆ

นี่คือตัวอย่างพื้นฐาน สมมติว่าคุณต้องการใช้สตริงของอักขระ ASCII และแทนที่ด้วยอักขระรหัสฐานสิบหก นี่คือวิธีที่คุณอาจทำใน JavaScript:

U.split("").map(x=>x.charCodeAt(0).toString(16)).join("")

ตอนนี้จะแปลงเป็น Japt .split("")ใน JS เทียบเท่ากับq""ใน Japt qหรือแม้สั้นเพียง .join("")เป็นเพียงแค่qความแตกต่างที่เป็นวัตถุเป็นอาร์เรย์แทนสตริง .map(เป็นm, .charCodeAt(เป็นcและเป็น.toString( sดังนั้นรหัส Japt ของเราอาจมีลักษณะดังนี้:

Uq mX{Xc0 s16} q 

ใน Japt แม้ว่าmการทำงานได้เป็นอย่างดีในสายมันไม่เกี่ยวกับอาร์เรย์เพื่อให้เราสามารถถอดทั้งqs:

UmX{Xc0 s16}

ทดสอบออนไลน์! ดังที่คุณเห็นในกล่อง "รหัส JS" สิ่งนี้จะส่งตรงไปที่:

U.m(function(X){return X.c(0).s(16)})

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

UmX{Xc0 s16}
               // Implicit: U = input string
UmX{       }   // Take U, and replace each character X with the result of this function:
    Xc0        //   Take the char-code at index 0 in X (the first and only one).
        s16    //   Convert this to a hexadecimal string.
               // Implicit: output result of last expression

การบีบอัดอาร์เรย์สตริง

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

บทนำ

หากคุณมีอาเรย์ของสตริงในโค้ดของคุณวิธีที่ชัดเจนที่สุดในการบีบอัดมันก็คือการรันแต่ละสตริผ่านOcแต่ละที สำหรับจุดประสงค์ของเคล็ดลับนี้เราจะทำงานร่วมกับอาร์เรย์["lollipop","marshmallow","nougat","oreo"]ซึ่งมีน้ำหนักอยู่ที่ 42 ไบต์ในตอนแรก การใช้แต่ละสตริงผ่านOcทำให้เรา:

[`lo¥ipop`,`Ú\hÚaow`,`Í`,`eo`]

นั่นคือตอนนี้ 33 ไบต์การประหยัดที่เหมาะสม

ขั้นตอนที่ 1

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

`lo¥ipop
Ú\hÚaow
Í
eo`·

ลงไปที่ 26 ไบต์

ขั้นตอนที่ 2

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

`lo¥ipopzÚ\hÚaowzÍzeo`qz

อ้าถั่ว - ไม่มีการปรับปรุงเลย จำนวนไบต์ของเราเพิ่มขึ้นหนึ่งตัว! อาจจะมีจดหมายอีกฉบับหนึ่งคุณสามารถใช้ แต่ทั้งนี้ขึ้นอยู่กับสายของคุณอาจจะมีค่อนข้างน้อยที่จะลอง - ในตัวอย่างของเรามี b,c,d,f,j,k,q,v,x,y,z11: การลองใช้แต่ละครั้งจะค่อนข้างน่าเบื่อซึ่งเป็นที่ที่เครื่องมือที่มีประโยชน์นี้เข้ามา ป้อนสตริงขึ้นบรรทัดใหม่ของคุณให้แยกจากกันและจะพยายามกำหนดขอบเขตสตริงด้วยตัวอักษรแต่ละตัวที่ไม่มีอยู่ในสตริงเหล่านั้นและเอาต์พุต:

• สตริงที่บีบอัดที่สั้นที่สุด
• ตัวคั่นที่ใช้และ
• ความยาวของมัน

เรียกใช้สตริงตัวอย่างของเราผ่านมันแสดงให้เห็นว่าbให้ผลลัพธ์ที่ดีที่สุด:

`lo¥ipáæqrÚaowbÍÞo`qb

แล้วคุณก็มีเราเหลือเพียง 24 ไบต์

ขั้นตอนที่ 3

แต่ที่เราสามารถทำได้แม้จะดีกว่า! หากลำดับของสตริงในอาร์เรย์ของคุณไม่สำคัญอาจมีการเปลี่ยนแปลงที่แตกต่างกันรวมกับตัวคั่นอื่นที่สามารถทำงานได้สั้นลง การพยายามทำทุกสิ่งที่เป็นไปได้นั้นน่าเบื่อมากกว่า ด้วย 4 สายของเรามีการเปลี่ยนลำดับที่แตกต่างกัน 24 แบบให้ลอง ด้วยตัวอักษร 11 ตัวที่เป็นไปได้แต่ละข้อที่กลายเป็น 264! นั่นคือสิ่งที่เครื่องมือนี้เข้ามาเล่น อีกครั้งให้ป้อนสตริงขึ้นบรรทัดใหม่ของคุณและมันจะลองทุกการรวมกันของทุกการเปลี่ยนแปลงและจดหมายคั่นทุกฉบับ

• ลำดับของสตริงในสตริงที่บีบอัดสั้นที่สุด
• สตริงที่บีบอัด
• ตัวคั่นที่ใช้และ
• ความยาวของมัน

การรันสตริงตัวอย่างของเราผ่านมันแสดงให้เห็นว่า"nougat","oreo","lollipop","marshmallow"ด้วยbตัวคั่นให้ผลลัพธ์ที่ดีที่สุดโดยมีจำนวนไบต์สุดท้ายเพียง 23:

`ÍÞo½o¥ipáæqrÚaow`qb

เคล็ดลับโบนัส: การบีบอัดอาร์เรย์จำนวนเต็ม

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

[588181,156859,595676,475330,680474]

เราสามารถลดขนาดได้ถึง 29 ไบต์โดยการแปลงมันเป็นอาเรย์ของสตริง 32 ตัวแรกแล้วรันมันผ่านโปรแกรมบีบอัดแรก:

`huclt4p5r5ÛÊg62tkogq`qt mnH

หรือต่ำสุดที่ 27 ไบต์โดยใช้โปรแกรมที่สอง:

`4p5Ïcl5ÛÊg62tkogq`qt mnH

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

หมายเหตุ

1. อย่าลืมให้ปัจจัยใน 1 หรือ 2 ไบต์พิเศษค่าใช้จ่ายมากกว่าq<letter>(<space>) ·แม้ว่าคุณจะสามารถใช้ช็อตคัท Unicode ตัวใดตัวหนึ่งเพื่อรับไบต์กลับขึ้นอยู่กับตัวคั่นของคุณ ( qÊเช่นเดียวกับql<space>ตัวอย่าง)
2. คำเตือนเมื่อใช้เครื่องมือสุดท้าย: ยิ่งคุณมีจำนวนการเรียงสับเปลี่ยนมากขึ้นเท่าไหร่โปรแกรมก็จะยิ่งทำงานช้าลงจนกว่าจะหมดแรง ดังรายละเอียดข้างต้นด้วยสตริงตัวอย่าง 4 รายการของเราและตัวอักษรที่เป็นไปได้ 11 แบบให้ลองมีชุดค่าผสมที่เป็นไปได้ 264 ชุดเพิ่มจำนวนสายอักขระเพียง 1 ตัวด้วยตัวอักษร 11 ตัวเดียวกันและเรามี 1320 ชุดที่จะลอง (คุณสามารถใช้เครื่องมือนี้เพื่อนับจำนวนชุดค่าผสมได้หากต้องการ)

เครดิต

• โอลิเวอร์เป็นแรงบันดาลใจในการสร้างเครื่องมือที่พบในเคล็ดลับนี้
• ETHProductions สำหรับการพิสูจน์อักษร

การบีบอัดสตริง

Japt (ปัจจุบัน) ใช้ไลบรารีshocoสำหรับการบีบอัดสตริง คุณสามารถบีบอัดสตริงที่กำหนดเองได้โดยใช้Ocตราบเท่าที่มันมีการรันด้วยตัวอักษรตัวเล็ก:

Oc"Hello, World!"

เอาท์พุทนี้ HÁM, WŽld! (ดี, ในŽทางเทคนิคเป็นตัวอักษร unprintable) คุณสามารถขยายขนาดได้โดยใส่มันใน backticks:

`HÁM, WŽld!`

ทดสอบออนไลน์!

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

การทำให้ตัวเลขสั้นด้วย Char-Codes

ใน Japt คุณสามารถใช้ #ตามด้วยตัวละครเพื่อสร้างรหัสตัวอักษร สิ่งนี้มีประโยชน์เมื่อลดจำนวนที่สั้นลง

ดังที่ @ETHproductions กล่าวถึงสิ่งนี้จะทำงานเฉพาะกับการทำงานสามหลักในช่วง 100-255 เว้นแต่คุณจะยินดีเปลี่ยนเป็น UTF-8

ตัวอย่าง:

123 สามารถตัดให้สั้นลง #{

101 สามารถตัดให้สั้นลง #e

คุณสามารถเชื่อมโยงสิ่งเหล่านี้เข้าด้วยกัน:

123101 สามารถตัดให้สั้นลง #{#e

คุณสามารถใช้String.fromCharCode(123)ใน JavaScript หรือ123dใน Japt เพื่อค้นหาอักขระที่เหมาะสม

String.fromCharCode(123) ผลตอบแทน {

เคล็ดลับด่วน: อาร์เรย์ที่ว่างเปล่า []

Japt มีค่าคงที่สำหรับอาเรย์ที่ว่างเปล่า: A. แต่เพื่อที่จะเข้าถึงได้คุณต้องย่อหน้าอัฒภาค;ในการเขียนโปรแกรมของคุณเพื่อใช้ค่าคงที่ทางเลือกของ Japt มิฉะนั้นจะเป็นA 10ดังนั้นการใช้;Aจริงจะมีการบันทึกทับ 0 ไบต์[]แต่จะช่วยให้คุณประหยัดไบต์ได้ถ้าคุณต้องการกำหนดอาร์เรย์ให้กับตัวแปร (เช่นA=[])

อย่างไรก็ตามหาก (และถ้าเท่านั้น) โปรแกรมของคุณไม่รับอินพุตใด ๆ คุณสามารถเข้าถึงอาร์เรย์ว่างด้วย 1 ไบต์โดยใช้Nตัวแปรซึ่งเป็นอาร์เรย์ของอินพุต - โดยไม่มีอินพุตก็จะว่างเปล่า ลองมันออกจากที่นี่

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

การประเมินจาวาสคริปต์

Japt ช่วยให้คุณสามารถรัน JavaScript แบบดิบโดยล้อมรอบ $...$ดิบโดยการตัดมันไปรอบ ๆ

ตัวอย่างเช่น, $alert("hello world")$

นี้สามารถสั้นลงโดยการใช้ประโยชน์จากของ Japt อัตโนมัติปิดและ$)

$alert("hello world")$ สามารถตัดให้สั้นลง $alert("hello world"

การบีบอัด JavaScript

Oxนอกจากนี้คุณยังสามารถบีบอัดโดยใช้ JavaScript

หากมีฟังก์ชั่นจาวาสคริปต์ที่คุณต้องการใช้พูดscreen.widthคุณสามารถบีบอัดสตริง"screen.width"โดยใช้Ocแล้วแทรกผลในระหว่าง Ox` ... `

โปรดทราบว่าคุณไม่จำเป็นต้องปิดเครื่องหมายอัญประกาศใน Japt เมื่อไม่มีสิ่งอื่นตามมา

รู้ธง

ตามมติเมตาล่าสุด (ธ.ค. 2560)แฟล็กบรรทัดคำสั่งจะไม่ถูกนับรวมเป็นไบต์อีกต่อไป มันเป็นข่าวที่ดีสำหรับ Japtor เพราะมันมีธงมากมายสำหรับการดูแลเป็นพิเศษสำหรับอินพุต / เอาท์พุต

ธงที่มีอยู่ทั้งหมดใน Japt อธิบายไว้ด้านล่างในคำสั่งของการประเมินผล การตั้งค่าสถานะในกลุ่มเดียวกันเป็นเอกสิทธิ์ซึ่งกันและกัน โปรดทราบว่าการตั้งค่าสถานะในกลุ่มต่าง ๆ สามารถใช้ร่วมกันส่งผลให้เกิดสิ่งนี้ :)

mdefæ

โปรแกรมทั้งหมดถูกแมปผ่านอาร์กิวเมนต์แรก ( U)

หากข้อโต้แย้งมากขึ้นปัจจุบันพวกเขาจะถูกส่งผ่านตามที่เป็น (คือไม่ได้แมปคู่) U.mมิฉะนั้นอาร์กิวเมนต์ที่สองคือดัชนีและสามคืออาร์เรย์ทั้งหมดเช่นเดียวกับ ถ้าUเป็นตัวเลขมันจะถูกแปลงเป็นช่วง ถ้าสตริงมันจะถูกแปลงเป็นอาร์เรย์ของตัวอักษรและผลลัพธ์จะถูกรวมเข้าด้วยกัน

• -m: ใช้ข้างต้นและไม่มีอะไรอื่น
• -d: ส่งคืนtrueหากผลลัพธ์บางส่วนเป็นจริงfalseมิฉะนั้น
• -e: ส่งคืนtrueหากผลลัพธ์ทั้งหมดเป็นจริงfalseมิฉะนั้น
• -f: ส่งคืนอาร์เรย์ขององค์ประกอบของ Uที่ผลลัพธ์เป็นจริง
• -æ: ใช้-fและส่งคืนองค์ประกอบแรก

gh

รับองค์ประกอบที่ดัชนีที่ระบุ

• -g: ใช้องค์ประกอบแรก (ดัชนี 0)
• -gX: ใช้องค์ประกอบที่ดัชนี X (สามารถเป็นจำนวนเต็มบวกใด ๆ )
• -h: ใช้องค์ประกอบสุดท้าย

!¡

แปลงผลลัพธ์เป็นบูลีน

• -!: ใช้บูลีนไม่ได้
• -¡: ใช้บูลีนไม่ได้สองครั้ง (คืนค่าความจริง)

N

แปลงผลลัพธ์เป็นตัวเลข มีการใช้เครื่องหมายบวก

PRSQ

แปลงเป็นสตริงของการเรียงลำดับบางอย่าง

• -P: ""เข้าร่วมกับอาร์เรย์
• -R: "\n"เข้าร่วมกับอาร์เรย์
• -S: " "เข้าร่วมกับอาร์เรย์
• -Q: ใช้JSON.stringify(อาจเป็นวัตถุใด ๆ ไม่เพียง แต่อาร์เรย์) ตัวอย่าง

x

ใช้ฟังก์ชันxกับเอาต์พุต (แท้จริงxแล้วไม่ใช่ "ฟังก์ชั่นตัวอักษรตัวเล็กใด ๆ ")

• อาเรย์: ผลรวม
• สตริง: ตัดจากปลายทั้งสอง
• หมายเลข: ปัดเศษเป็นจำนวนเต็ม

ทางลัด Unicode

มีโครงสร้างที่พบบ่อยมากใน Japt ว่าเพียงแค่ไม่สามารถเก็บไว้ในถ่าน ASCII เดียวเช่นqS , p2 , mX{, } ฯลฯ ดังนั้นเพื่อให้ได้รอบนี้ Japt มี "ทางลัด Unicode" ซึ่งเป็นตัวละครในช่วง\xA1- \xDE( ¡- Þ) ซึ่งขยายไปยังโครงสร้างทั่วไปเหล่านี้ คุณสามารถค้นหารายชื่อเต็มของเหล่านี้ในเอกสารล่าม

นอกจากนี้ยัง@หมายถึงXYZ{และ_ย่อมาจากZ{Zเพื่อช่วยสร้างฟังก์ชั่น ดังนั้นลองเล่นกอล์ฟโปรแกรมตัวอย่างจากคำตอบอื่น :

UmX{Xc0 s16}

ประการแรกเราสามารถแทนที่X{Xด้วย_ซึ่งทำให้เรา:

Um_c0 s16}

จากนั้นเราสามารถแทนที่m_ด้วย®การบันทึกไบต์อื่น:

U®c0 s16}

หรือเราสามารถแทนที่X{ด้วย@ซึ่งทำให้เรา:

Um@Xc0 s16}

นี่ช่วยให้เราใช้¡ทางลัดเพื่อบันทึกสองไบต์:

¡Xc0 s16}

หนึ่งในสองเส้นทางนี้สามารถทำให้สั้นลง 1 ไบต์มากกว่าอีกเส้นทางหนึ่ง คุณคิดได้ไหมว่า

ใช้ประโยชน์จากตัวแปรที่ตั้งไว้ล่วงหน้า

ตัวแปรA- Sถูกตั้งค่าไว้ล่วงหน้าสำหรับค่าทั่วไปที่ใช้มากกว่าหนึ่งไบต์เพื่อเป็นตัวแทนใน Japt:

• A- Gมี-1016
• Hคือ32, Iคือ64, Jคือ-1, เป็นL100
• Kถูกกำหนดเป็นnew Date()ซึ่งคุณสามารถจัดการได้หลายวิธี
• MและOเป็นวัตถุที่มีฟังก์ชั่นที่มีประโยชน์มากมาย คุณสามารถเรียนรู้เพิ่มเติมในเอกสาร
• Pคือสตริงที่ว่างเปล่าQเป็นเครื่องหมายคำพูดRเป็นบรรทัดใหม่และSเป็นช่องว่าง
• Tมีการตั้งค่าเป็น0ดังนั้นคุณสามารถใช้มันเป็นตัวสะสมหากจำเป็น

ถ้าตัวอักษรตัวแรกในโปรแกรมเป็นอัฒภาค;, A-Lถูกรีเซ็ตดังนี้

• A[]คืออาร์เรย์ที่ว่างเปล่า
• B"ABCDEFGHIJKLMNOPQRSTUVWXYZ"เป็น
• C"abcdefghijklmnopqrstuvwxyz"เป็น
• D"QWERTYUIOP\nASDFGHJKL\nZXCVBNM"เป็น
• Eเป็น"[a-z]"และFเป็น"[A-Za-z]"(มีประโยชน์ก่อนที่ผมจะเพิ่มคุณสมบัติเหล่านี้เป็น regex)
• Gis 36, His 65และIis 91(มีประโยชน์สำหรับช่วงตัวอักษร)
• Jเป็นเครื่องหมายจุลภาคเดียว Lช่วงเวลาเดียว

ปัจจุบันเท่านั้นA, B, CและDจากรายการนี้มีประโยชน์จริงๆ ฉันวางแผนที่จะเพิ่มระบบที่ดีกว่าซึ่งอนุญาตให้ใช้ตัวแปรสองไบต์สูงสุด 256 ตัวซึ่งจะถูกตั้งค่าไว้ล่วงหน้าเพื่อค่าเหล่านี้และอีกมากมาย

ใช้ฟังก์ชั่นอัตโนมัติ

คุณมักจะรู้แล้วว่า@และ_เป็นทางลัดXYZ{และZ{Zตามลำดับ (ครอบคลุมในทางลัด Unicodeคำตอบ ) แต่บางครั้งคุณสามารถทำให้ฟังก์ชั่นสั้นลงได้

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

mX{Xc} 
m_c} 

แต่มีวิธีที่ดีกว่า หากวิธีการหรือผู้ประกอบการเป็นรายการแรกหลังจากวิธีอื่นหรือ a (ก็จะกลายเป็นสตริง ดังนั้นทั้งสองเส้นจึงเท่ากัน:

r'a'b  // Replace all "a"s with "b"s; transpiles to .r("a","b")
ra'b   // Does the same thing, 1 byte less; transpiles to the same thing

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

m_c}  // Map each item to its char code
m'c   // Does the same thing, 1 byte less
mc    // Also does the same thing, 2 bytes less

ฉันเรียกสิ่งเหล่านี้ว่า "ฟังก์ชั่นอัตโนมัติ" มีหลายสายพันธุ์ที่แตกต่างกัน:

• m@Xc} → mc
• m@Xc1} → mc1
• m@X+1} → m+1
• m@1+X} → m!+1
• m@2pX} → m!p2

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

การกำหนดตัวแปรโดยนัย

เมื่อใดก็ตามที่คุณเริ่มบรรทัดใหม่ใน Japtapt ผลลัพธ์ของบรรทัดก่อนหน้าจะถูกกำหนดให้กับหนึ่งในตัวแปรอินพุต ( U- Z) โดยอัตโนมัติโดยที่บรรทัดแรกจะเป็นบรรทัดUที่สองVและอื่น ๆ

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

U=Aõ V=Um² [do something with the arrays]

อย่างไรก็ตามการใช้การกำหนดตัวแปรอัตโนมัตินั้นสามารถย่อให้เป็น:

Aõ
Um²
[do something with the arrays]

เราได้บันทึก 4 ไบต์ที่นั่น แต่ในกรณีนี้เราสามารถบันทึกได้อีกหนึ่งไบต์เนื่องจากอาร์เรย์ของ 1-10 ถูกกำหนดให้UและUสามารถละเว้นได้ในบางสถานการณ์ :

Aõ
m²
[do something with the arrays]

ความระมัดระวัง

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

Aõ
Vm²
[do something with the arrays]

รู้จักจาวาสคริปต์

ตั้งแต่รหัส Japt ใด ๆ ทำงานเป็น JS transpiled ความเข้าใจที่ดีของผู้ประกอบการ JS และวิธีการในตัวช่วยมากในการเล่นกอล์ฟของรหัส Japt

เคล็ดลับ JS ที่เกี่ยวข้อง

• การหล่อโดยนัยการเพิ่ม / ลดตัวดำเนินการ
• สูตรคำนวณเลขคณิต / ตัวดำเนินการบางตัว
  • นี่ไม่จำเป็นต้องบันทึกไบต์เป็น Japt (เนื่องจากทางลัด) แต่ก็ควรจำไว้เสมอว่าผู้ประกอบการทำงานอย่างไร
• รู้จักเครื่องหมายจุลภาคและการมอบหมายที่ใดก็ได้
  • เครื่องหมายจุลภาค (โดยปกติจะแทรกอยู่ใน Japt) มีประโยชน์อย่างยิ่งเมื่อคุณต้องการเริ่มต้นตัวแปรแล้วทำงานบางอย่างกับมัน รหัสต่อไปนี้กำหนดอาร์เรย์ว่างแล้วประเมินU V.m(การมี newline เปิดใช้งานการกำหนดโดยนัยไปUที่บรรทัดแรก)

[]Vm@...
...

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

ฟังก์ชันในตัว JS ที่เกี่ยวข้อง

ดูพารามิเตอร์ที่ถูกส่งผ่านไปยังอาร์กิวเมนต์ของฟังก์ชันอย่างใกล้ชิด

• Array.prototype.map
  • วิธีการ Japt ที่เกี่ยวข้อง: Array.a/b/m/x/y/í, Number.o/õ,String.m/y/í
• Array.prototype.reduce
  • วิธีการที่เกี่ยวข้องกับ Japt: Array.r/å, String.å; สำหรับåอาร์กิวเมนต์ที่ 4 จะไม่ถูกส่งผ่าน
• Array.prototype.some
  • วิธี Japt ที่เกี่ยวข้อง: Array.d
• Array.prototype.every
  • วิธี Japt ที่เกี่ยวข้อง: Array.e

สำหรับวิธีการแบบสตริงเป็นการดีที่จะทราบว่าความแตกต่างของพฤติกรรมระหว่างการส่งผ่านสตริงหรือ regex ที่มีหรือไม่มีgแฟล็ก

• String.prototype.match
  • วิธี Japt ที่เกี่ยวข้อง: String.f/o
• String.prototype.search
  • วิธี Japt ที่เกี่ยวข้อง: String.â
• String.prototype.replace
  • วิธี Japt ที่เกี่ยวข้อง: String.e/k/r
  • สำหรับการe/rส่งผ่านฟังก์ชั่นเป็นอาร์กิวเมนต์ที่ 2 ก็โอเคและทำความเข้าใจกับพารามิเตอร์ฟังก์ชั่นได้รับการสนับสนุนอย่างมาก

ใช้หลายบรรทัดเมื่อจำเป็น

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

ลบ parens ปิด

ภารกิจ : กำหนดตัวเลขให้จับคู่แต่ละองค์ประกอบกับดัชนีกำลังสองแล้วเรียงตามผลรวม

[5,1,17,9,3] => [[5,0],[1,1],[17,4],[9,9],[3,16]] => [[1,1],[5,0],[9,9],[3,16],[17,4]]

โซลูชันหนึ่งบรรทัดคือíUm@Yp2})ñxแต่มี})ค่าใช้จ่ายสองไบต์ (และไม่มีทางลัดหนึ่งไบต์) คุณสามารถลบได้})โดยการย้ายส่วนท้ายñxไปยังบรรทัดถัดไปดังนั้นโค้ดจะมีลักษณะดังนี้:

íUm@Yp2
ñx

และ JS transpiled จะกลายเป็น:

U = U.í(U.m(function(X, Y, Z) { return Y.p(2) })); U.ñ("x")

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

ชดเชยด้วยการขัดแย้งโดยนัย

ฟังก์ชันการเรียกซ้ำßใช้UVWXYZพารามิเตอร์ implicit ทั้งหมดหากไม่ได้ระบุไว้ Uเห็นได้ชัดว่าเป็นอินพุตหลัก แต่คุณสามารถใช้VWXYZเพื่อติดตามค่าอื่น ๆ ที่คุณต้องการ ตัวอย่างเช่นคุณสามารถทำสิ่งต่อไปนี้:

(modify input and implicit assign to U)
(modify V and implicit assign to V)
(test something and call ß without arguments; U and V are passed automatically)

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

ใช้ฟังก์ชันที่ยาวนาน

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

• เพื่อที่จะนำฟังก์ชั่นกลับมาใช้ใหม่คุณจะต้องเก็บมันไว้ในตัวแปร เริ่มต้นสอดคล้องกับฟังก์ชั่นที่เปิด{, @หรือ_ไม่ทำงาน หรือคุณสามารถทำสิ่งที่ต้องการ(T=@...})ฝังการกำหนดฟังก์ชันภายในบรรทัดที่ซับซ้อนกว่าได้
• อันที่จริงมันไม่สำคัญที่จะเรียกฟังก์ชั่นที่เก็บไว้ สมมติว่าVเป็นฟังก์ชั่นและเราต้องการที่จะโทรV(U)ใน JS ไม่ทำงานตั้งแต่มันก็หมายถึงVU ไม่เหมือนกัน; มันเป็น แม้แต่วิธีการฟังก์ชั่นก็ไม่ได้มีประโยชน์อะไรมากมาย วิธีที่ดีที่สุดที่เราพบคือ: V,UV(UV,(U)
  • [U]xV (แผนที่และผลรวม) หากผลลัพธ์คือตัวเลข
  • UmVถ้าUเป็นถ่านตัวเดียวและVส่งกลับสตริงหรือ
  • $V($Uหรือ[U]mV gโดยทั่วไป
• อย่างไรก็ตามการทำแผนที่หรือการวนซ้ำกับมันค่อนข้างง่าย UmVต้องการแมมากกว่าอาร์เรย์ใช้ เพื่อหาจำนวนเต็มแรกที่ตอบสนองการใช้งานVVa

สนุกกับฟังก์ชั่นอัตโนมัติ

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

รับจำนวนเต็มที่ใหญ่ที่สุดในอาร์เรย์

สมมติว่าเรามีอาร์เรย์ที่[3,1,4,2]กำหนดให้กับตัวแปรUและเราได้รับจำนวนมากที่สุด เราสามารถทำได้ใน 4 ไบต์โดยการเรียงลำดับอาร์เรย์แล้ว popping องค์ประกอบสุดท้าย:

Un o

ข้อเสียคือเราได้ปรับเปลี่ยนอาร์เรย์เดิม Uตอนนี้[1,2,3]อาจไม่เป็นที่พึงปรารถนาเสมอไป โชคดีที่มีวิธีการทำโดยไม่ต้องแก้ไขอาร์เรย์ที่สั้นลงหนึ่งไบต์:

Urw

สิ่งที่เราทำไปแล้วจะมีการลดอาร์เรย์โดยใช้wวิธีการซึ่งเมื่อใช้กับจำนวนเต็มจะส่งกลับจำนวนเต็มที่มากกว่าและอาร์กิวเมนต์ของเมธอด (เช่น2w5ส่งคืน5) ดังนั้นที่กล่าวมาเป็นเทียบเท่าหรือUrÈwY UrXY{XwY}หมายเหตุแม้ว่าว่าเคล็ดลับนี้จะไม่ทำงานในกรณีของทุกจำนวนเต็มในอาร์เรย์เป็นเชิงลบ

เมื่อไม่ใช้í

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

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

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

UíUç hV @[XY]n o

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

Uy m_q n o

นี่เป็นข้อได้เปรียบของการขยายสายที่สั้นกว่าด้วยช่องว่างทำให้มันเป็นชิ้นส่วนของเค้กที่จะผ่านทั้งสองสาย

ตัวอย่างชีวิตจริง: 1 , 2

สร้างช่วง ASCII

อัปเดต: ตอนนี้ Japt มีค่าคงที่สำหรับช่วง ASCII; มูลค่าทางเลือกสำหรับการเข้าถึงได้ด้วยE ;ดูเคล็ดลับนี้สำหรับข้อมูลเพิ่มเติมเกี่ยวกับค่าคงที่ของ Japt

ในขณะที่ Japt ยังไม่มีบิวท์อินสำหรับช่วง ASCII คุณสามารถสร้างอาเรย์ของอักขระในเวลาเพียง 5 ไบต์:

95odH

ลองมัน

มันทำงานอย่างไร

95oสร้างช่วงที่[0,95)แต่ละองค์ประกอบถูกส่งผ่านฟังก์ชั่นอัตโนมัติ dซึ่งเมื่อใช้กับตัวเลขจะส่งคืนอักขระที่ codepoint นั้น ส่งผ่านตัวเลขเป็นอาร์กิวเมนต์ไปยังdเมธอดในกรณีนี้Hค่าคงที่ Japt สำหรับ 32 และจะถูกเพิ่มเข้าไปในหมายเลขเดิมก่อนที่จะถูกแปลง

โซลูชันที่เทียบเท่าใน JavaScript คือ:

[...Array(95)].map((_,x)=>String.fromCharCode(x+32))

ตัวละครแบบสุ่ม

ในการรับอักขระสุ่มในช่วง ASCII ให้ใช้öแทนซึ่งจะส่งกลับตัวเลขสุ่มจากช่วง[0,X)โดยที่Xเป็นหมายเลขที่ใช้งานอยู่

95ö dH

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

95öA mdH

ลบตัวอักษรโครงสร้างที่ไม่จำเป็น

โดยตัวอักษรโครงสร้างผมหมายถึง{}, (), $แม้และ" `โดยทั่วไปคุณสามารถลบตัวอักษรเหล่านี้ออกเมื่อใดก็ตามที่เกิดขึ้นในตอนท้ายของโปรแกรม (เช่นUmX{Xc +"; "} -> UmX{Xc +"; )

นอกจากนี้คุณสามารถลบ parens หรือช่องว่างเมื่อใดก็ตามที่ปรากฏในสถานที่ต่อไปนี้:

• ขึ้นกับเครื่องหมายอัฒภาค ; (หรือจุดสิ้นสุดของโปรแกรม);
• ไปทางขวาของ{(และนามสกุล@) หรือ[หรือซ้ายของหรือ]}

นอกจากนี้เครื่องหมายจุลภาคยังไม่ค่อยจำเป็นสำหรับการแยกอาร์กิวเมนต์ ABตัวอย่างเช่นถ้าคุณเขียนJapt รู้ว่าคุณหมายถึงAและBแยก คุณต้องใช้เครื่องหมายจุลภาคเพื่อแยกตัวอักษรสองตัวเช่นUs2,5คุณต้องการจริงๆจุลภาคเพื่อแยกสองตัวอักษรตัวเลขเช่น

ในที่สุดหากมีUการเริ่มต้นโปรแกรมหรือหลัง{หรือ;ตามด้วยการเรียกเมธอด (อักษรตัวพิมพ์เล็กหรือทางลัด Unicode ที่เกี่ยวข้อง) หรือตัวดำเนินการไบนารีใด ๆ+และ-( *, &, ==ฯลฯ ) คุณสามารถเอาUบันทึก ไบต์และ Japt จะแทรกสำหรับคุณ

ปรับเปลี่ยนองค์ประกอบสุดท้ายในอาร์เรย์

บางครั้งคุณอาจจำเป็นต้องแก้ไของค์ประกอบสุดท้ายในอาร์เรย์ดังนั้นนี่คือคำอธิบายเกี่ยวกับวิธีการทำสั้น ๆ เราจะทำงานกับอาร์เรย์ที่[2,4,8,32]กำหนดให้กับตัวแปรอินพุตUและหารจำนวนเต็มสุดท้าย (32 ) ด้วย 2

วิธีที่ชัดเจนในการบรรลุเป้าหมายนี้คือโซลูชัน 9 ไบต์ ( สาธิต ):

UhJUgJ /2

• hnxตั้งองค์ประกอบที่ดัชนีnเป็นxจะ
• gn ส่งคืนองค์ประกอบที่ดัชนี nส่งกลับองค์ประกอบที่ดัชนี
• J เป็นค่าคงที่ Japt สำหรับ -1ซึ่งขอบคุณการสนับสนุนของ Japt สำหรับดัชนีเชิงลบทำให้เราสามารถทำงานกับองค์ประกอบสุดท้ายในอาร์เรย์ มีประโยชน์เมื่อคุณไม่ทราบขนาดของอาเรย์
• และ/2ก็หารด้วย 2

ดังนั้นชุดดังกล่าวข้างต้นองค์ประกอบที่ดัชนี-1ในอาร์เรย์องค์ประกอบที่ดัชนี-1ในอาร์เรย์หารด้วย 2. หรือใน U[3]=U[3]/2JavaScript: เมื่อคุณเขียนมันออกมาแบบนั้นมันดูเหมือนจะเป็นเรื่องที่ยืดยาวเกินไป โชคดีที่มีเป็นวิธีที่สั้น; เราสามารถป๊อปอัพองค์ประกอบสุดท้ายจากอาเรย์แก้ไขมันและผลักมันกลับไปที่อาเรย์ การดำเนินการแต่ละอย่างนั้นจะใช้เวลามากกว่า 9 ไบต์ แต่เราสามารถทำได้ทั้งหมดในคราวเดียวเพียง 7 ไบต์, ประหยัด 2 ไบต์ ( สาธิต )

UpUo /2

แปลเป็น JS มันเทียบเท่ากับ:

U.push(U.pop()/2)&&U