pwaS eht tirsf dna tasl setterl สำหรับ hace dorw


30

หรือ "สลับอักษรตัวแรกและตัวสุดท้ายของแต่ละคำ"

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

ตัวอย่าง / testcases ใช้อักษรตัวพิมพ์เล็กและช่องว่างเป็นตัวคั่น

คุณไม่จำเป็นต้องจัดการเครื่องหมายวรรคตอน อินพุตทั้งหมดจะประกอบด้วยตัวอักษร a ถึง z เท่านั้นคั่นด้วยตัวคั่นตัวพิมพ์ทั้งหมด

ตัวอย่างเช่นกับสตริง "hello world":

Input string: "hello world"
Identify each word: "[hello] [world]"
Identify the first and last letters of each word: "[[h]ell[o]] [[w]orl[d]]"
Swap the first letters of each word: "[[o]ell[h]] [[d]orl[w]]"
Final string: "oellh dorlw"

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

กรณีทดสอบ:

"swap the first and last letters of each word" -> "pwas eht tirsf dna tasl setterl fo hace dorw"
"hello world" -> "oellh dorlw"
"test cases" -> "test sasec"
"programming puzzles and code golf" -> "grogramminp suzzlep dna eodc folg"
"in a green meadow" -> "ni a nreeg weadom"
"yay racecar" -> "yay racecar"

3
เครื่องหมายวรรคตอนควรได้รับการปฏิบัติอย่างไร? Hello, world!กลายเป็น,elloH !orldw(การสลับเครื่องหมายวรรคตอนเป็นตัวอักษร) หรือoellH, dorlw!(ใช้เครื่องหมายวรรคตอนแทน) หรือไม่
Phelype Oleinik

3
@PhelypeOleinik คุณไม่จำเป็นต้องใช้เครื่องหมายวรรคตอน อินพุตทั้งหมดจะประกอบด้วยตัวอักษร a ถึง z เท่านั้นและเป็นตัวพิมพ์ใหญ่ทั้งหมด
สหาย SparklePony

4
วรรคสองอ่านเช่นเดียวกับตัวละครตัวหนึ่งอื่น ๆ ที่จะใช้เป็นตัวคั่นในขณะที่สี่อ่านคั่นด้วยช่องว่าง อันไหน?
อดัม

@ Adámอักขระที่ไม่ใช่ตัวอักษรใด ๆ ฉันจะแก้ไขเพื่อชี้แจง
สหาย SparklePony

1
@BenjaminUrquhart ใช่ คุณสามารถรับอินพุตเป็นอาร์กิวเมนต์ฟังก์ชันได้หากคุณต้องการเช่นกัน
สหาย SparklePony

คำตอบ:


59

TeX, 216 ไบต์ (4 บรรทัด, 54 ตัวอักษร)

เพราะมันไม่เกี่ยวกับจำนวนไบต์มันเกี่ยวกับคุณภาพของการเรียงพิมพ์ :-)

{\let~\catcode~`A13 \defA#1{~`#113\gdef}AGG#1{~`#1 13%
\global\let}GFF\elseGHH\fiAQQ{Q}AII{\ifxQ}AEE#1#2#3|{%
I#3#2#1FE{#1#2}#3|H}ADD#1#2|{I#1FE{}#1#2|H}ACC#1#2|{D%
#2Q|#1 }ABBH#1 {HI#1FC#1|BH}\gdef\S#1{\iftrueBH#1 Q }}

ลองออนไลน์! (Overleaf ไม่แน่ใจว่ามันทำงานอย่างไร)

ไฟล์ทดสอบเต็มรูปแบบ:

{\let~\catcode~`A13 \defA#1{~`#113\gdef}AGG#1{~`#1 13%
\global\let}GFF\elseGHH\fiAQQ{Q}AII{\ifxQ}AEE#1#2#3|{%
I#3#2#1FE{#1#2}#3|H}ADD#1#2|{I#1FE{}#1#2|H}ACC#1#2|{D%
#2Q|#1 }ABBH#1 {HI#1FC#1|BH}\gdef\S#1{\iftrueBH#1 Q }}

\S{swap the a first and last letters of each word}

pwas eht a tirsf dna tasl setterl fo hace dorw

\S{SWAP THE A FIRST AND LAST LETTERS OF EACH WORD}

\bye

เอาท์พุท:

ป้อนคำอธิบายรูปภาพที่นี่


สำหรับ LaTeX คุณเพียงแค่ต้องการแผ่นสำเร็จรูป:

\documentclass{article}
\begin{document}

{\let~\catcode~`A13 \defA#1{~`#113\gdef}AGG#1{~`#1 13%
\global\let}GFF\elseGHH\fiAQQ{Q}AII{\ifxQ}AEE#1#2#3|{%
I#3#2#1FE{#1#2}#3|H}ADD#1#2|{I#1FE{}#1#2|H}ACC#1#2|{D%
#2Q|#1 }ABBH#1 {HI#1FC#1|BH}\gdef\S#1{\iftrueBH#1 Q }}

\S{swap the a first and last letters of each word}

pwas eht a tirsf dna tasl setterl fo hace dorw

\S{SWAP THE A FIRST AND LAST LETTERS OF EACH WORD}

\end{document}

คำอธิบาย

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

สำหรับผู้เริ่มต้น TeX แบบสัมบูรณ์

  • รายการแรกและสำคัญที่สุดในรายการนี้: รหัสไม่จำเป็นต้องอยู่ในรูปสี่เหลี่ยมผืนผ้าแม้ว่า วัฒนธรรมป๊อป อาจทำให้คุณ คิดเช่นนั้น

  • TeX เป็นภาษาส่วนขยายของแมโคร ยกตัวอย่างเช่นคุณสามารถกำหนด\def\sayhello#1{Hello, #1!}และเขียน\sayhello{Code Golfists}เพื่อให้ TeX พิมพ์Hello, Code Golfists!ได้ สิ่งนี้เรียกว่า“ มาโครที่ไม่ถูก จำกัด ” และเพื่อให้ฟีดพารามิเตอร์แรก (และเฉพาะในกรณีนี้) ที่คุณใส่ไว้ในวงเล็บ TeX ลบวงเล็บปีกกาเหล่านั้นเมื่อแมโครคว้าอาร์กิวเมนต์ คุณสามารถใช้งานได้ถึง 9 พารามิเตอร์แล้ว\def\say#1#2{#1, #2!}\say{Good news}{everyone}

  • คู่ของแมโคร undelimited จะแปลกใจคนคั่น :) คุณสามารถทำให้คำนิยามก่อนหน้าตาดเพิ่มเติมsemantical\def\say #1 to #2.{#1, #2!} : ในกรณีนี้พารามิเตอร์ที่จะตามมาด้วยสิ่งที่เรียกว่าข้อความพารามิเตอร์ ข้อความพารามิเตอร์ดังกล่าวคั่นอาร์กิวเมนต์ของแมโคร ( #1คั่นด้วย␣to␣, รวมช่องว่างและ#2คั่นด้วย.) หลังจากที่ความหมายที่คุณสามารถเขียนซึ่งจะขยายตัวออกไป\say Good news to everyone. Good news, everyone!ดีใช่มั้ย :) อย่างไรก็ตามอาร์กิวเมนต์ที่มีการคั่นคือ (อ้างถึงTeXbook )“ ลำดับที่สั้นที่สุด (อาจว่างเปล่า) ของโทเค็นที่มี{...}กลุ่มซ้อนกันอย่างเหมาะสมที่ตามมาในการป้อนข้อมูลโดยรายการเฉพาะของโทเค็นที่ไม่ใช่พารามิเตอร์นี้ " ซึ่งหมายความว่าการขยายตัวของ\say Let's go to the mall to Martinจะสร้างประโยคแปลก ๆ ในกรณีนี้คุณจะต้อง“ซ่อน” ครั้งแรก␣to␣กับ:{...}\say {Let's go to the mall} to Martin

  • จนถึงตอนนี้ดีมาก ตอนนี้ทุกอย่างเริ่มแปลก ๆ เมื่อ TeX อ่านตัวอักษร (ซึ่งถูกกำหนดโดย“ รหัสตัวอักษร”) มันจะกำหนดตัวอักษรนั้นเป็น“ รหัสหมวดหมู่” (catcode สำหรับเพื่อน ๆ :) ซึ่งจะกำหนดความหมายของตัวละครนั้น การรวมกันของตัวละครและรหัสหมวดหมู่นี้ทำให้โทเค็น (ตัวอย่างเพิ่มเติมที่นี่ ) คนที่น่าสนใจสำหรับเราที่นี่เป็นพื้น:

    • catcode 11ซึ่งกำหนดโทเค็นซึ่งสามารถสร้างลำดับการควบคุม (ชื่อ posh สำหรับแมโคร) โดยค่าเริ่มต้นตัวอักษรทั้งหมด [a-zA-Z] เป็น catcode 11 ดังนั้นฉันสามารถเขียน\helloซึ่งเป็นหนึ่งในลำดับการควบคุมเดียวในขณะ\he11oที่ลำดับการควบคุม\heตามด้วยอักขระสองตัว1ตามด้วยตัวอักษรoเพราะ1ไม่ใช่ catcode 11 ถ้าฉัน ได้\catcode`1=11จากจุด\he11oนั้นไปเป็นลำดับการควบคุมหนึ่ง สิ่งหนึ่งที่สำคัญคือการที่มีการตั้งค่า catcodes เมื่อเท็กซ์แรกที่เห็นตัวละครที่อยู่ในมือและ catcode ดังกล่าวเป็นแช่แข็ง ... ตลอดไป! (ข้อกำหนดและเงื่อนไขอาจนำมาใช้)

    • catcode 12ซึ่งเป็นอักขระส่วนใหญ่เช่น0"!@*(?,.-+/และอื่น ๆ พวกมันเป็นประเภท catcode พิเศษที่น้อยที่สุดเพราะมันทำหน้าที่สำหรับการเขียนเนื้อหาบนกระดาษเท่านั้น แต่เดี๋ยวก่อนใครใช้ TeX ในการเขียน?!? (อาจมีข้อกำหนดและเงื่อนไขอีกครั้ง)

    • catcode 13ซึ่งเป็นนรก :) จริง ๆ หยุดอ่านและไปทำอะไรบางอย่างในชีวิตของคุณ คุณไม่ต้องการที่จะรู้ว่า catcode 13 คืออะไร เคยได้ยินวันศุกร์ที่ 13 ไหม ลองเดาดูว่ามันได้ชื่อมาจากไหน! ดำเนินการต่อด้วยความเสี่ยงของคุณเอง! catcode 13 ตัวละครหรือที่เรียกว่าตัวละคร“ แอคทีฟ” ไม่ได้เป็นเพียงตัวละครอีกต่อไปมันเป็นมาโครเอง คุณสามารถกำหนดให้มีพารามิเตอร์และขยายไปยังสิ่งที่เราเห็นด้านบน หลังจากที่คุณทำ\catcode`e=13คุณคิดว่าคุณสามารถทำได้\def e{I am the letter e!}แต่ คุณ. ไม่ได้! eไม่ใช่ตัวอักษรอีกต่อไปดังนั้น\defไม่ใช่\defคุณรู้ว่ามันเป็น\d e f! โอ้เลือกจดหมายอีกฉบับที่คุณพูด? เอาล่ะ! \catcode`R=13 \def R{I am an ARRR!}. เยี่ยมมากจิมมี่ลองสิ! ฉันกล้าที่คุณทำและเขียนRในรหัสของคุณ! นั่นคือสิ่งที่ catcode 13 เป็น ฉันใจเย็น! ไปกันเถอะ

  • โอเคตอนนี้เพื่อจัดกลุ่ม ค่อนข้างตรงไปตรงมา สิ่งที่ได้รับมอบหมาย ( \defเป็นการดำเนินการที่ได้รับมอบหมาย\let(เราจะเข้าสู่มัน) เป็นอีกสิ่งหนึ่ง) ที่ทำในกลุ่มจะถูกเรียกคืนเป็นสิ่งที่พวกเขาเคยทำก่อนที่กลุ่มนั้นจะเริ่มต้นเว้นแต่ว่าการมอบหมายนั้นจะเป็นระดับโลก มีหลายวิธีในการเริ่มกลุ่มโดยหนึ่งในนั้นคือ catcode 1 และ 2 ตัวอักษร (โอ้ catcodes อีกครั้ง) โดยค่าเริ่มต้น{คือ catcode 1 หรือกลุ่มเริ่มต้นและ}เป็น catcode 2 หรือกลุ่มปลาย ตัวอย่าง: \def\a{1} \a{\def\a{2} \a} \aพิมพ์1 2 1นี้ นอกกลุ่ม\aเป็น1แล้วภายในนั้นถูกนิยามใหม่ไปและเมื่อกลุ่มสิ้นสุดวันที่มันจะถูกเรียกคืนไป21

  • การ\letดำเนินการเป็นการดำเนินการที่ได้รับมอบหมายอื่น\defแต่แตกต่างกันมาก เมื่อ\defคุณกำหนดมาโครที่จะขยายไปยังสิ่งของ\letคุณจะสร้างสำเนาของสิ่งที่มีอยู่แล้ว หลังจาก\let\blub=\def( =เป็นตัวเลือก) คุณสามารถเปลี่ยนการเริ่มต้นeตัวอย่างจากรายการ catcode 13 ด้านบนเป็น\blub e{...และสนุกกับสิ่งนั้น หรือดีกว่าแทนการทำลายสิ่งที่คุณสามารถแก้ไข (คุณจะดูที่!) ด้วยเช่น:R \let\newr=R \catcode`R=13 \def R{I am an A\newr\newr\newr!}คำถามด่วน: คุณสามารถเปลี่ยนชื่อเป็น\newR?

  • ในที่สุดสิ่งที่เรียกว่า "ช่องว่างปลอม" นี่เป็นหัวข้อที่ต้องห้ามเพราะมีคนที่อ้างว่าชื่อเสียงที่ได้รับจากTeX - LaTeX Stack Exchangeโดยการตอบคำถาม "ช่องว่างปลอม" ไม่ควรได้รับการพิจารณาในขณะที่คนอื่นไม่เห็นด้วยอย่างสุดใจ คุณเห็นด้วยกับใคร วางเดิมพันของคุณ! ในขณะเดียวกัน: TeX เข้าใจการแตกบรรทัดเป็นพื้นที่ ลองเขียนหลาย ๆ คำโดยใช้ตัวแบ่งบรรทัด (ไม่ใช่บรรทัดว่าง ) ระหว่างคำเหล่านั้น ตอนนี้เพิ่ม a %ท้ายบรรทัดเหล่านี้ มันเหมือนกับว่าคุณกำลัง“ คอมเม้นท์” จุดสิ้นสุดของบรรทัดเหล่านี้ แค่นั้นแหละ :)

(เรียงจาก) ถอดรหัสออก

ให้สี่เหลี่ยมผืนผ้านั้นเป็นสิ่งที่ง่ายขึ้น (ตามเนื้อหา):

{
\let~\catcode
~`A13
\defA#1{~`#113\gdef}
AGG#1{~`#113\global\let}
GFF\else
GHH\fi
AQQ{Q}
AII{\ifxQ}
AEE#1#2#3|{I#3#2#1FE{#1#2}#3|H}
ADD#1#2#3|{I#2FE{#1}#2#3|H}
ACC#1#2|{D{}#2Q|#1 }
ABBH#1 {HI#1FC#1|BH}
\gdef\S#1{\iftrueBH#1 Q }
}

คำอธิบายของแต่ละขั้นตอน

แต่ละบรรทัดมีหนึ่งคำสั่งเดียว ไปทีละคนแล้วผ่าพวกเขา:

{
ก่อนอื่นเราเริ่มกลุ่มเพื่อให้การเปลี่ยนแปลงบางอย่าง (เช่นการเปลี่ยนแปลง catcode) อยู่ในเครื่องเพื่อไม่ให้สับสนกับข้อความที่ป้อนเข้า

\let~\catcode
โดยทั่วไปทุกรหัสเท็กซ์ obfuscation เริ่มต้นด้วยการเรียนการสอนนี้ โดยค่าเริ่มต้นทั้งใน TeX ธรรมดาและ LaTeX ~ตัวละครเป็นตัวละครที่ใช้งานหนึ่งตัวซึ่งสามารถทำเป็นแมโครเพื่อใช้งานต่อไป และเครื่องมือที่ดีที่สุดสำหรับ weirdifying รหัส TeX คือการเปลี่ยนแปลง catcode ดังนั้นโดยทั่วไปนี่เป็นตัวเลือกที่ดีที่สุด ตอนนี้แทนที่จะ\catcode`A=13เราสามารถเขียน~`A13( =เป็นตัวเลือก):

~`A13
ตอนนี้ตัวอักษรAเป็นตัวละครที่ใช้งานอยู่และเราสามารถกำหนดให้ทำอะไรบางอย่าง:

\defA#1{~`#113\gdef}
Aเป็นแมโครที่รับอาร์กิวเมนต์หนึ่งตัว (ซึ่งควรเป็นอักขระอื่น) แรก catcode ของการโต้แย้งที่มีการเปลี่ยนแปลงถึง 13 ที่จะทำให้มันใช้งาน: ~`#113(แทนที่~โดย\catcodeและเพิ่ม=และคุณมี: \catcode`#1=13) ในที่สุดก็ปล่อยให้\gdef(โกลบอล\def) ในอินพุตสตรีม ในระยะสั้นAทำให้ตัวละครอื่นที่ใช้งานและเริ่มต้นการกำหนด มาลองดูกัน:

AGG#1{~`#113\global\let}
AGเริ่มแรก "เปิดใช้งาน" Gและทำ\gdefซึ่งตามด้วยถัดไปGเริ่มต้นคำจำกัดความ คำจำกัดความของGคล้ายกับของAยกเว้นว่าแทนที่จะ\gdefเป็น\global\let(ไม่มีไม่\gletเหมือน\gdef) ในระยะสั้นGเปิดใช้งานตัวละครและทำให้มันเป็นอย่างอื่น ลองทำทางลัดสำหรับสองคำสั่งที่เราจะใช้ในภายหลัง:

GFF\else
GHH\fi
ตอนนี้แทน\elseและ\fiเราก็สามารถใช้และF Hสั้นกว่ามาก :)

AQQ{Q}
ตอนนี้เราใช้Aอีกครั้งเพื่อกำหนดแมโครอื่น, Q. ข้อความข้างต้นโดยทั่วไปจะ \def\Q{\Q}(ในภาษาที่เข้าใจยากน้อยกว่า) นี่ไม่ใช่คำจำกัดความที่น่าสนใจอย่างยิ่ง แต่มันมีคุณสมบัติที่น่าสนใจ ยกเว้นว่าคุณต้องการทำลายรหัสบางส่วนแมโครเดียวที่ขยายQเป็นของQตัวเองดังนั้นมันจึงทำหน้าที่เหมือนเครื่องหมายที่ไม่ซ้ำกัน (เรียกว่าควาร์ก ) คุณสามารถใช้\ifxเงื่อนไขเพื่อทดสอบว่าอาร์กิวเมนต์ของแมโครนั้นเป็นควาร์กดังกล่าวด้วย\ifx Q#1:

AII{\ifxQ}
เพื่อให้คุณมั่นใจได้ว่าคุณพบเครื่องหมายดังกล่าว ขอให้สังเกตว่าในความหมายนี้ฉันลบช่องว่างระหว่างและ\ifx Qโดยปกติสิ่งนี้จะนำไปสู่ข้อผิดพลาด (โปรดทราบว่าการเน้นไวยากรณ์คิดว่า\ifxQเป็นเรื่องหนึ่ง) แต่เนื่องจากขณะนี้Qcatcode 13 ไม่สามารถสร้างลำดับการควบคุมได้ ระวัง แต่ไม่ได้ที่จะขยายควาร์กนี้หรือคุณจะได้รับการติดอยู่ในวง จำกัด เพราะQการขยายตัวในการQที่จะขยายQซึ่ง ...

ตอนนี้การแข่งขันรอบแรกเสร็จสิ้นแล้วเราสามารถไปยังอัลกอริทึมที่เหมาะสมกับ pwas eht setterl เนื่องจากโทเค็นของ TeX จะต้องเขียนอัลกอริทึมไปข้างหลัง นี่เป็นเพราะในเวลาที่คุณทำการกำหนด TeX จะทำเครื่องหมาย (กำหนด catcodes) ให้กับตัวละครในการกำหนดโดยใช้การตั้งค่าปัจจุบันดังนั้นตัวอย่างเช่นถ้าฉันทำ:

\def\one{E}
\catcode`E=13\def E{1}
\one E

ผลลัพธ์คือE1ในขณะที่ถ้าฉันเปลี่ยนลำดับของคำจำกัดความ:

\catcode`E=13\def E{1}
\def\one{E}
\one E

11ผลลัพธ์คือ นี่เป็นเพราะในตัวอย่างแรกEคำนิยามในโทเค็นเป็นตัวอักษร (catcode 11) ก่อนที่ catcode จะเปลี่ยนดังนั้นมันจะเป็นตัวอักษรEเสมอ ในตัวอย่างที่สอง แต่Eเป็นครั้งแรกที่ใช้งานและเพียงแล้ว\oneถูกกำหนดและตอนนี้ความหมายมี catcode 13 ซึ่งจะขยายE1

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

\gdef\S#1{\iftrueBH#1 Q }
(สังเกตว่ามีข้อผิดพลาดเล็ก ๆ ในรุ่นก่อนหน้านี้มันไม่ได้มีช่องว่างสุดท้ายในคำนิยามข้างต้นฉันสังเกตเห็นเพียงในขณะที่เขียนนี้อ่านต่อไปและคุณจะเห็นว่าทำไมเราต้องการที่จะยุติแมโครอย่างถูกต้อง ) ครั้งแรกที่เรากำหนดแมโครระดับผู้ใช้
\Sหนึ่งนี้ไม่ควรจะเป็นตัวละครที่ใช้งานให้มีความเป็นมิตร (?) ไวยากรณ์ดังนั้นแมโครสำหรับ gwappins EHT setterl \Sมี แมโครเริ่มต้นด้วยเงื่อนไขที่เป็นจริงเสมอ\iftrue(ในไม่ช้ามันก็จะชัดเจนว่าทำไม) แล้วเรียกBแมโครตามด้วยH(ซึ่งเรากำหนดไว้ก่อนหน้านี้เพื่อ\fiให้ตรงกับ\iftrue) จากนั้นเราจะออกจากข้อโต้แย้งของแมโครตามด้วยช่องว่างและควาร์ก#1 Qสมมติว่าเราใช้\S{hello world}แล้วสตรีมอินพุตควรมีลักษณะดังนี้: \iftrue BHhello world Q␣(ฉันแทนที่พื้นที่สุดท้ายด้วยเพื่อให้การแสดงผลของไซต์ไม่กินมันเหมือนที่ฉันทำในรหัสรุ่นก่อนหน้า) เป็นความจริงดังนั้นจึงขยายตัวและเราจะเหลือ\iftrue BHhello world Q␣TeX จะไม่ลบ\fi( H) หลังจากเงื่อนไขถูกประเมิน แต่จะปล่อยไว้ที่นั่นจนกว่า\fiจะขยายออกจริง ตอนนี้Bแมโครถูกขยาย:

ABBH#1 {HI#1FC#1|BH}
Bเป็นแมโครที่คั่นด้วยข้อความพารามิเตอร์H#1␣ดังนั้นอาร์กิวเมนต์จึงเป็นสิ่งที่อยู่ระหว่างHและเว้นวรรค อย่างต่อเนื่องตัวอย่างข้างต้นสตรีมใส่ก่อนที่จะมีการขยายตัวของมีB ตามด้วยตามที่ควร (มิฉะนั้นเท็กซ์จะยกข้อผิดพลาด) แล้วพื้นที่ต่อไปคือระหว่างและเพื่อให้เป็นคำว่า และที่นี่เราต้องแยกข้อความอินพุตที่ช่องว่าง ยาย: D การขยายตัวของเอาทุกอย่างขึ้นอยู่กับพื้นที่เป็นครั้งแรกจากสตรีมใส่และแทนที่โดยมีเป็น: โปรดสังเกตว่ามีใหม่ในสตรีมอินพุตในภายหลังเพื่อทำการวนรอบแบบซ้ำBHhello world Q␣BHhelloworld#1helloBHI#1FC#1|BH#1helloHIhelloFChello|BHworld Q␣BHBและประมวลผลคำภายหลัง หลังจากคำนี้มีการประมวลผลกระบวนการคำถัดไปจนกว่าจะมีคำพูดเพื่อจะประมวลผลเป็นควาร์กB Qต้องการพื้นที่สุดท้ายหลังQเนื่องจากแมโครที่B มีการคั่นต้องการหนึ่งที่ท้ายอาร์กิวเมนต์ ด้วยเวอร์ชันก่อนหน้า (ดูประวัติการแก้ไข) รหัสจะทำงานผิดปกติหากคุณใช้\S{hello world}abc abc(ช่องว่างระหว่างabcs จะหายไป)

HIhelloFChello|BHworld Q␣ตกลงกลับไปยังสตรีมใส่: ครั้งแรกที่มีเป็นH( \fi) \iftrueที่เสร็จสิ้นการเริ่มต้น ตอนนี้เรามีสิ่งนี้ (ปลอม):

I
  hello
F
  Chello|B
H
world Q␣

การI...F...Hคิดเป็น\ifx Q...\else...\fiโครงสร้างจริงๆ การ\ifxทดสอบจะตรวจสอบว่าคำศัพท์ (โทเค็นแรกของคำศัพท์) นั้นถูกจับQหรือไม่ หากไม่มีสิ่งใดที่ต้องทำและการดำเนินการสิ้นสุดลงมิฉะนั้นสิ่งที่เหลืออยู่คือ: Chello|BHworld Q␣. ตอนนี้Cถูกขยาย:

ACC#1#2|{D#2Q|#1 }
อาร์กิวเมนต์แรกของการCเป็น undelimited ดังนั้นถ้ายันมันจะเป็นโทเค็นเดียวอาร์กิวเมนต์ที่สองจะถูกคั่นด้วย|ดังนั้นหลังจากการขยายตัวของC(ที่มี#1=hและ#2=ello) DelloQ|h BHworld Q␣สตรีมใส่เป็น: ขอให้สังเกตว่าคนอื่น|ใส่ที่นั่นและhจากhelloนั้นก็ใส่หลังจากนั้น การสลับเปลี่ยนครึ่งหนึ่งเสร็จสิ้น ตัวอักษรตัวแรกอยู่ท้าย ใน TeX นั้นง่ายต่อการคว้าโทเค็นแรกของรายการโทเค็น แมโครง่ายได้รับตัวอักษรตัวแรกเมื่อคุณใช้\def\first#1#2|{#1} \first hello|อันสุดท้ายเป็นปัญหาเพราะ TeX คว้ารายการโทเค็นที่เล็กที่สุดและว่างเปล่าว่าเป็นอาร์กิวเมนต์ดังนั้นเราจึงต้องแก้ไขปัญหาบางอย่าง รายการถัดไปในรายการโทเค็นคือD:

ADD#1#2|{I#1FE{}#1#2|H}
Dมาโคร นี้เป็นหนึ่งในการแก้ไขและมีประโยชน์ในกรณีเดียวที่คำนั้นมีตัวอักษรเดียว สมมติว่าแทนการที่เรามีhello xในกรณีนี้กระแสอินพุทจะเป็นDQ|xแล้วDจะขยายตัว (ที่มี#1=Qและ#2ที่ว่างเปล่า) IQFE{}Q|Hxไปที่: นี้คล้ายกับบล็อกI...F...H( \ifx Q...\else...\fi) ในBซึ่งจะเห็นว่าอาร์กิวเมนต์เป็นควาร์กและจะขัดจังหวะการดำเนินการออกจากxการเรียงพิมพ์เท่านั้น ในกรณีอื่น ๆ (กลับไปhelloเป็นต้น) Dจะขยายตัว (ที่มี#1=eและ#2=lloQ) IeFE{}elloQ|Hh BHworld Q␣เพื่อ: อีกครั้งI...F...HจะตรวจสอบQแต่จะล้มเหลวและใช้สาขา:\else E{}elloQ|Hh BHworld Q␣ตอนนี้ชิ้นสุดท้ายของสิ่งนี้,E มาโครจะขยาย:

AEE#1#2#3|{I#3#2#1FE{#1#2}#3|H}
ข้อความพารามิเตอร์ที่นี่ค่อนข้างคล้ายกับCและD; การขัดแย้งครั้งแรกและครั้งที่สองจะ undelimited |และคนสุดท้ายที่ถูกคั่นด้วย กระแสการป้อนข้อมูลลักษณะเช่นนี้E{}elloQ|Hh BHworld Q␣แล้วEการขยายตัว (มี#1ที่ว่างเปล่า#2=eและ):#3=lloQ IlloQeFE{e}lloQ|HHh BHworld Q␣อีกประการหนึ่งI...F...Hการตรวจสอบบล็อกควาร์ก (ซึ่งเห็นlและผลตอบแทน):false E{e}lloQ|HHh BHworld Q␣ตอนนี้Eขยายตัวอีกครั้ง (ด้วยความ#1=eว่างเปล่า#2=lและ):#3=loQ และอีกครั้งIloQleFE{el}loQ|HHHh BHworld Q␣ I...F...Hแมโครไม่ซ้ำอีกไม่กี่จนกว่าQจะพบในที่สุดและtrueสาขาจะได้รับการ: E{el}loQ|HHHh BHworld Q␣-> IoQlelFE{ell}oQ|HHHHh BHworld Q␣-> ->E{ell}oQ|HHHHh BHworld Q␣ ตอนนี้ควาร์กพบและขยายตัวตามเงื่อนไขเพื่อ:IQoellFE{ello}Q|HHHHHh BHworld Q␣ oellHHHHh BHworld Q␣วุ้ย.

โอ้เดี๋ยวก่อนพวกนี้คืออะไร? ตัวอักษรปกติ? โอ้เด็ก! ตัวอักษรเป็นที่สุดพบและเท็กซ์เขียนลงoellแล้วพวงของH( \fi) ที่พบและการขยายตัว (เพื่ออะไร) oellh BHworld Q␣ออกจากสตรีมใส่ด้วย: ตอนนี้คำแรกมีตัวอักษรตัวแรกและตัวสุดท้ายสลับและสิ่งที่ TeX พบต่อไปคืออีกคำBเพื่อทำซ้ำกระบวนการทั้งหมดสำหรับคำถัดไป

}
ในที่สุดเราก็สิ้นสุดกลุ่มเริ่มต้นที่นั่นเพื่อให้การมอบหมายงานในพื้นที่ทั้งหมดถูกยกเลิก การกำหนดท้องถิ่นคือการเปลี่ยนแปลง catcode ของตัวอักษรA, B, C... ซึ่งได้ทำแมโครเพื่อให้พวกเขากลับไปที่ความหมายตัวอักษรปกติและสามารถใช้ได้อย่างปลอดภัยในข้อความ และนั่นคือมัน ตอนนี้\Sแมโครที่นิยามไว้ด้านหลังจะทำให้เกิดการประมวลผลข้อความดังกล่าว

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

\if\S{here} true\else false\fi % prints true (plus junk, which you would need to handle)
\if\S{test} true\else false\fi % prints false

ขออภัยสำหรับคำอธิบายที่มากเกินไป ฉันพยายามทำให้มันชัดเจนที่สุดสำหรับ TeXies ที่ไม่ใช่ :)

สรุปสำหรับคนใจร้อน

แมโคร\Sprepends การป้อนข้อมูลด้วยตัวใช้งานที่คว้ารายการของสัญญาณที่คั่นด้วยช่องว่างสุดท้ายและผ่านพวกเขาไปB ใช้โทเค็นแรกในรายการนั้นและย้ายไปยังจุดสิ้นสุดของรายการโทเค็นและขยายด้วยสิ่งที่เหลืออยู่ ตรวจสอบว่า“ สิ่งที่เหลืออยู่” นั้นว่างเปล่าหรือไม่ซึ่งในกรณีนี้จะพบคำตัวอักษรเดียวแล้วไม่ทำอะไรเลย มิฉะนั้นการขยายตัว วนรอบรายการโทเค็นจนกระทั่งพบตัวอักษรตัวสุดท้ายในคำเมื่อพบว่าออกจากตัวอักษรตัวสุดท้ายตามด้วยคำกลางซึ่งตามด้วยตัวอักษรตัวแรกที่เหลือในตอนท้ายของกระแสโทเค็นด้วย.CCDDEEC


2
ฉันชอบคำอธิบายทั้งหมดของอันนี้ ฉันอยากรู้ว่ามันทำงานอย่างไร!
LambdaBeta

1
@ LambdaBeta ฉันสามารถทำได้ แต่ไม่ใช่ตอนนี้ โปรดรอและฉันจะ ping คุณเมื่อฉันทำ :)
Phelype Oleinik

1
@LambdaBeta เรียบร้อยแล้ว! ขออภัยบางครั้งฉันพูดมากเกินไป :-)
Phelype Oleinik

13

JavaScript (ES6),  39  36 ไบต์

บันทึกแล้ว 3 ไบต์ขอบคุณ @FryAmTheEggman

ใช้ตัวป้อนบรรทัดเป็นตัวคั่น

s=>s.replace(/(.)(.*)(.)/g,'$3$2$1')

ลองออนไลน์!


5
(.)(.*)(.)อิโมติคอนการเรียกคืนรวมคืออะไร
MikeTheLiar

1
@ MikeTheLiar ชนิดของฉันเดา : D
Arnauld

การกำหนดระบุสตริงที่มีตัวคั่น
Cees Timmerman

@CeesTimmerman ฉันไม่แน่ใจว่าคุณหมายถึงอะไร รหัสนี้คาดว่า linefeed เป็นตัวแยกดังนั้นจึงใช้สตริงที่มี linefeeds เป็นอินพุต (ส่วนท้ายของลิงก์ TIO จะแปลงช่องว่างเป็น linefeeds แล้วกลับไปที่ช่องว่างเพื่อให้อ่านได้)
Arnauld

"กำหนดสตริงอักขระ ASCII เรียงตามตัวอักษรเช่นเดียวกับอักขระอื่นหนึ่งตัวเพื่อใช้เป็นตัวคั่น (เพื่อคั่นแต่ละคำ) " - Nm ฉันคิดว่ามันเป็นพารามิเตอร์ที่แยกต่างหาก
Cees Timmerman

11

จอประสาทตา8 5 ไบต์

,V,,`

ลองออนไลน์!

บันทึกแล้ว 3 ไบต์ขอบคุณKevin Cruijssen !

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


Dangit ฉันเพิ่งค้นหาเอกสารเพื่อหาคำตอบของฉัน แต่คุณเอาชนะฉันได้ ฉันรู้Vแต่ไม่ทราบว่าสามารถใช้กับดัชนี1,-2เช่นนั้นได้ ทำได้ดีนี่!
Kevin Cruijssen

1
@KevinCruijssen ฉันโกงนิดหน่อยและตรวจสอบว่าการ จำกัด ช่วงการทำงานในขณะที่อยู่ในกล่องทราย :) ฉันยังรู้สึกว่าควรจะมีวิธีที่ดีกว่าการสลับช่วง แต่ฉันไม่สามารถหาอะไรที่สั้นกว่านี้ได้
FryAmTheEggman

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

@KevinCruijssen ดีมาก! ไม่อยากเชื่อเลยว่าฉันพลาดไป
FryAmTheEggman

3
ดังนั้น 5 ไบต์และ 3 ตัวอักษรที่แตกต่างกันเพียง? นั่นเรียบง่าย
Cœur

9

Pepe , 107 105 ไบต์

REEeREeeEeeeeerEEreREEEeREEEEEEeREEEErEEREEEEEEEreererEEEeererEEEerEEeERrEEEeerEEeerereeerEEEEeEEEReEeree

ลองออนไลน์!

คำอธิบาย:

สัญลักษณ์เกี่ยวกับความคิดเห็น: command-explanation -> (stack) // explanation

REEe # input -> (R)
REeeEeeeee # push space to last -> (R) // this prevents an infinite loop

rEE # create loop labeled 0 and automatically push 0 
  re # pop 0 -> (r)
  REEEe # go to last item -> (R)
  REEEEEEe # ...then copy the char to other stack
  REEEE # go to first item -> (R)

  rEE # create loop labeled 32 // detect space
    REEEEEEE # move item to other stack (R)
  ree # do this while char != 32

  re # pop 32 -> (r)
  rEEEee # push item (dup to end) -> (r)
  re # ...then pop -> (r)
  rEEEe rEEeE # go to 2nd to last item -> (r)
  RrEEEee # push the item (R flag: dup to first) -> (r)
  rEEee # go to next -> (r) //
  re # ...then pop -> (r)
  reee rEEEEeEEE # out all as char then clear -> (r)
  ReEe # out 32 as char -> (R)
ree # do this while stack != 0

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

@lirtosiast เพิ่มคำอธิบายแล้ว
u_ndefined


6

laskelH , 71 ไบต์

h=reverse
s(x:y:o)=a:h(x:r)where(a:r)=h$y:o
s o=o
f=unwords.map s.words

ลองออนไลน์!

ตัวอย่างเข้า / ออก:

Swap the first and last letter in each word
This also works with single letter words like a

It is basically just a straight up implementation in which
I for words consisting of two or more letters cons the head
of the reversed tail on the reverse of the original head consed
on the reversed tail

Note that the rules say that we only have to support one kind
of separator - I am choosing spaces Technically it works with
other whitespace as well, but it will turn everything into spaces
in the end Line endings in this example usage are handled separately
to make the example output look nicer
pwaS eht tirsf dna tasl rettel ni hace dorw
shiT olsa sorkw hitw eingls rettel sordw eikl a

tI si yasicallb tusj a ttraighs pu nmplementatioi ni hhicw
I rof sordw gonsistinc fo owt ro eorm setterl sonc eht deah
fo eht deverser lait no eht eeversr fo eht lriginao deah donsec
no eht deverser lait

eotN that eht suler yas that ew ynlo eavh ot tuppors eno dink
fo reparatos - I ma ghoosinc spaces yechnicallT ti sorkw hitw
rtheo ehitespacw sa ,ellw tub ti lilw nurt gverythine onti spaces
ni eht dne einL sndinge ni shit example esagu era dandleh yeparatels
ot eakm eht example tutpuo kool ricen
```

1
การมอบหมายในwhereข้อสามารถย้ายไปยังการรวมในยามเพื่อบันทึก 5 ไบต์: ลองออนไลน์!
Laikoni

1
ฉันเห็นสิ่งที่คุณทำที่นั่นด้วยชื่อ "Haskell" ในชื่อเรื่อง ฉันทำสิ่งเดียวกันกับคำตอบ PHP ของฉัน
640KB

5

05AB1E , 10 ไบต์

#vyRćsRćðJ

ลองออนไลน์!


-3 ขอบคุณที่@ Kevin Cruijssen

#           | Split into words.
 vy         | For each word...
   RćsRć    | Reverse, split head, swap, reverse, split tail
        ðJ  | Join by spaces.


1
@KevinCruijssen ฉันต้องการลบมันและมอบมันให้กับคุณนั่นคือ 99% พลังสมองของคุณในการเรียงลำดับของข้อโต้แย้งฮ่าฮ่า
Magic Octopus Urn

1
พบ 9 byter แต่การทำงานเฉพาะในรุ่นเดิม:|ʒRćsRćJ,
เควิน Cruijssen

1
น่าเสียดายที่เราไม่มีloop_as_long_as_there_are_inputsแล้วฉันก็จะรู้จัก 8-byter: [RćsRćJ,8-byter นี้โดยที่[ไม่เคยมีเอาท์พุทในทางทฤษฎี แต่เมื่อคุณจำไม่ได้หรือหมดเวลาเหมือน TIO (และต้องมีการต่อท้าย ขึ้นบรรทัดใหม่ในการป้อนข้อมูลมิฉะนั้นจะให้ใช้คำพูดสุดท้าย) ..
เควิน Cruijssen

1
น่าเสียดายที่คุณต้องการð¡ป้อนคำเดียวได้ แต่ð¡εćsÁì}ðýยังทำงานที่ 10 ไบต์
Emigna

5

J , 23 17 ไบต์

({:,1|.}:)&.>&.;:

ลองออนไลน์!


เคล็ดลับที่ดีมากในการสลับอักษรตัวแรก / ตัวสุดท้ายโดยการหมุนและใช้1 A.!
Galen Ivanov

1
1&A.&.(1&|.)-> ({:,1|.}:)จากนั้นคุณสามารถลบ::]
ngn

น่าทึ่งขอบคุณ
FrownyFrog

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

4

Ruby with -p, 42 41 29 ไบต์

gsub /(\w)(\w*)(\w)/,'\3\2\1'

ลองออนไลน์!



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

ค่อนข้างแน่ใจว่าฉันทามติได้เปลี่ยนไปมากกว่า 8 เดือนที่ผ่านมา แต่ในกรณีที่คุณพลาด: "การไม่แข่งขัน" ก็ไม่ใช่เรื่องอีกต่อไป
ปุย

ทำได้ดีมาก ฉันคิดว่าภายใต้กฎที่คุณสามารถใช้การขึ้นบรรทัดใหม่เป็นตัวคั่นและแทนที่\wด้วย.s
ฮิสโทแกต





3

ช่องว่าง , 179 ไบต์

[N
S S S N
_Create_Label_OUTER_LOOP][S S S N
_Push_n=0][N
S S T   N
_Create_Label_INNER_LOOP][S N
S _Duplicate_n][S N
S _Duplicate_n][S N
S _Duplicate_n][T   N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve_input][S S S T    S T T   N
_Push_11][T S S T   _Subtract_t=input-11][N
T   T   S S N
_If_t<0_jump_to_Label_PRINT][S S S T    N
_Push_1][T  S S S _Add_n=n+1][N
S N
T   N
_Jump_to_Label_INNER_LOOP][N
S S S S N
_Create_Label_PRINT][S S S T    N
_Push_1][T  S S T   _Subtract_n=n-1][S N
S _Duplicate_n][S N
S _Duplicate_n][N
T   S N
_If_n==0_jump_to_Label_PRINT_TRAILING][T    T   T   _Retrieve][T    N
S S _Print_as_character][S S S N
_Push_s=0][N
S S S T N
_Create_Label_PRINT_LOOP][S S S T   N
_Push_1][T  S S S _Add_s=s+1][S N
S _Duplicate_s][S T S S T   S N
_Copy_0-based_2nd_n][T  S S T   _Subtract_i=s-n][N
T   S N
_If_0_Jump_to_Label_PRINT_TRAILING][S N
S _Duplicate_s][T   T   T   _Retrieve][T    N
S S _Print_as_character][N
S T S T N
_Jump_to_Label_PRINT_LOOP][N
S S N
_Create_Label_PRINT_TRAILING][S S S N
_Push_0][T  T   T   _Retrieve][T    N
S S _Print_as_character][S S S T    S S T   N
_Push_9_tab][T  N
S S _Print_as_character][N
S N
S N
_Jump_to_Label_OUTER_LOOP]

เพิ่มตัวอักษรS(ช่องว่าง), T(แท็บ) และN(บรรทัดใหม่) เป็นการเน้นเท่านั้น
[..._some_action]เพิ่มเป็นคำอธิบายเท่านั้น

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

ลองใช้ออนไลน์ (ด้วยพื้นที่ว่างเปล่าแท็บและบรรทัดใหม่เท่านั้น)

คำอธิบายในรหัสเทียม:

[0,...,word_length]

Start OUTER_LOOP:
  Integer n = 0
  Start INNER_LOOP:
    Character c = STDIN as character, saved at heap-address n
    If(c == '\t' OR c == '\n'):
      Jump to PRINT
    n = n + 1
    Go to next iteration of INNER_LOOP

  PRINT:
    n = n - 1
    If(n == 0): (this means it was a single-letter word)
      Jump to PRINT_TRAILING
    Character c = get character from heap-address n
    Print c as character
    Integer s = 0

    Start PRINT_LOOP:
      s = s + 1
      If(s - n == 0):
        Jump to PRINT_TRAILING
      Character c = get character from heap-address s
      Print c as character
      Go to next iteration of PRINT_LOOP

    PRINT_TRAILING:
      Character c = get character from heap-address 0
      Print c as character
      Print '\t'
      Go to next iteration of OUTER_LOOP

โปรแกรมยุติการทำงานพร้อมข้อผิดพลาดเมื่อพยายามอ่านตัวอักษรเมื่อไม่มีการกำหนดไว้ใน TIO (หรือแฮงก์กำลังรอสัญญาณเข้าในคอมไพเลอร์ Whitespace เช่นvii5ard )


3

ภาษา Wolfram (Mathematica) , 58 ไบต์

StringReplace[#,a:u~~w:u..~~b:u:>b<>w<>a/.{u->Except@#2}]&

ลองออนไลน์!

-22 ไบต์จาก @attinat

-12 ไบต์จาก @ M.Stern


70 bytesใช้StringReplaceกับStringExpressions
attinat

1
64 ไบต์ใช้StringTakeแทนStringReplace:StringRiffle[StringSplit@##~StringTake~{{-1},{2,-2},{1}},#2,""]&
โรมัน

2
นี่เป็นวิธีที่ตรงกว่า:StringReplace[#, a : u ~~ w : u .. ~~ b : u :> b <> w <> a /. {u -> Except@#2}] &
เอ็มสเติร์น

1
{และ} เป็นทางเลือก :)
M. Stern

1
55 ไบต์ยังแก้ไขคำ 2 ตัวอักษร
attinat



2

Japt -S , 10 ไบต์

เชื่อว่าจะต้องมีวิธีการที่สั้นกว่า (และฉันพูดถูก ) แต่ตอนนี้จะทำ

¸ËhJDg)hDÌ

ลองมัน

¸ËhJDg)hDÌ     :Implicit input of string
¸              :Split on spaces
 Ë             :Map each D
  h            :  Set the character at
   J           :    Index -1 to
    Dg         :    The first character in D
      )        :  End set
       h       :  Set the first character to
        DÌ     :    The last character in D
               :Implicit output, joined by spaces

สั้นกว่า 12 byter ของฉัน:¸®Ì+Zs1J +Zg
ศูนย์รวมแห่งความไม่รู้

@EmbodimentofIgnorance นั่นเป็นจุดเริ่มต้นของฉันเช่นกัน แต่มันจะล้มเหลวในคำตัวอักษรเดียว ¸®ÎiZÌ+Zs1Jคุณสามารถประหยัดไบต์บนที่แม้ว่าด้วย
Shaggy

1
@EmbodimentofIgnorance พบ7 byter
Oliver

2

sed, 64 ไบต์

sed -E 's/\b([[:alpha:]])([[:alpha:]]*)([[:alpha:]])\b/\3\2\1/g'

แน่นอนว่าเราสามารถใช้.แทนได้[[:alpha:]]แต่จริง ๆ แล้วจะต้องเป็น[^ ]ซึ่งจะลดลงเหลือ 43 แต่จะหยุดพักในเครื่องหมายวรรคตอนและเช่นนั้น การใช้[a-zA-Z]นำมันได้ถึง 55 โดยที่ชี้ให้ฉันแค่อยากได้หลังจากที่หวานหน่วยงานที่สามารถอ่านได้เหล่านั้นหวานมนุษย์ ...
รวย

2
You do not need to handle punctuation; all of the inputs will only consist of the letters a through z, separated by a delimiter, all of a uniform case.กล่าวอีกนัยหนึ่งคุณไม่จำเป็นต้องกังวลเกี่ยวกับเครื่องหมายวรรคตอน "ทำลาย" รหัสของคุณและสามารถไปได้อย่างปลอดภัย[^ ];)
Value Ink

@ValueInk Yeah แต่ก็[^ ]ควร[^[:space:]]ที่จะนำไปสู่ ​​67 ตัวอักษร
คนรวย

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

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

2

sed , 34 ไบต์

และน่าจะเป็นความคิดรูปแบบที่จะทำงานกับเครื่องมือ RE ส่วนใหญ่ (และฉันรู้ว่ามีความแตกต่างระหว่าง RE มาตรฐานและขยาย RE)

s,\b\(\w\)\(\w*\)\(\w\)\b,\3\2\1,g

ลองออนไลน์!


1
ยินดีต้อนรับสู่ PPCG! ลองนึกดูว่าธรรมชาติของการแข่งขัน regex นั้นทำให้คุณสามารถตัด\bการแข่งขันได้: ลองออนไลน์!
หมึกมูลค่า

ตกลง @ValueInk - แต่ฉันถูกต้องกับการแข่งขัน การลบ\bจะนำไปสู่ ​​30 ไบต์
PJF

ใช้ -E สำหรับ regex ขั้นสูงและคุณสามารถใช้วงเล็บที่ไม่ใช้ค่า Escape ใช้.สำหรับตัวอักษรที่สลับสับเปลี่ยนและคุณจะสูญเสียตัวอักษรสองตัวได้อีก นี่จะทำให้คุณลดลงเหลือ 26 ไบต์; หนึ่งในโซลูชั่นที่เล็กที่สุดที่สามารถอ่านได้ s,\b(.)(\w*)(.)\b,\3\2\1,g
รวย

1
- ไม่ฉันผิดคุณต้องการ\ws ที่สุด s,\b(\w)(\w*)(\w)\b,\3\2\1,g28 ตัวอักษร
รวย

เป็นงานที่ดีมาก @rich แต่ฉันบอกว่าฉันรู้เกี่ยวกับมาตรฐานและการขยาย RE ฉันเลือกที่จะทำให้มันเป็นมาตรฐานและอ่านง่าย แองเคอร์จะต้องซึ่งฉันละเลยที่จะพูดถึงในการตอบกลับของฉันไปที่ ValueInk
PJF

2

Ruby, 53 ไบต์

gets.split(" ").map{|z|print z[-1]+z[1..-2]+z[0]," "}

ฉันพยายามโดยไม่ต้อง regex เอาต์พุตพิมพ์แต่ละคำบนบรรทัดใหม่ หากมันผิดกฎโปรดแจ้งให้เราทราบและฉันจะแก้ไข

Ungolfed:

gets.split(" ").map {|z|
    print z[-1] + z[1..-2] + z[0], " "
}

ยินดีต้อนรับสู่ PPCG! การพิมพ์แต่ละคำในบรรทัดใหม่ควรจะใช้ได้ แต่โซลูชันเก่าของคุณpไม่ดีเพราะนั่นเพิ่มการเสนอราคาให้กับเอาต์พุต คุณสามารถใช้putsแทนได้เสมอเนื่องจากมีหนึ่งรายการต่อท้ายบรรทัดใหม่และสั้นกว่าprint! นอกจากนี้หากคุณโทรsplitโดยไม่มีอาร์กิวเมนต์มันจะแยกช่องว่างโดยอัตโนมัติ
มูลค่าหมึก

2

8088 Assembly, IBM PC DOS, 39 38 ไบต์

$ xxd pwas.com
00000000: d1ee ac8a c8fd 03f1 c604 244e 8bfe ac3c  ..........$N...<
00000010: 2075 098a 2586 6402 8825 8bfe e2f0 b409   u..%.d..%......
00000020: ba82 00cd 21c3

แต่อย่างใด:

D1 EE       SHR  SI, 1          ; point SI to DOS PSP (080H) 
AC          LODSB               ; load string length into AL 
8A C8       MOV  CL, AL         ; load string length into CX for loop
FD          STD                 ; set LODSB to decrement 
03 F1       ADD  SI, CX         ; point SI to end of string 
C6 04 24    MOV  BYTE PTR[SI], '$' ; put a '$' DOS string terminator at end 
4E          DEC  SI             ; start at last char of word 
8B FE       MOV  DI, SI         ; point DI to last char of word 
        CHR_LOOP: 
AC          LODSB               ; load next (previous?) char into AL 
3C 20       CMP  AL, ' '        ; is it a space? 
75 0A       JNE  END_CHR        ; if so, continue loop 
8A 25       MOV  AH, [DI]       ; put last char in AH 
86 64 02    XCHG AH, [SI][2]    ; swap memory contents of first char with last 
                                ; (unfortunately XCHG cannot swap mem to mem)
88 25       MOV  [DI], AH       ; put first char value into last char position 
8B FE       MOV  DI, SI         ; point DI last char of word 
        END_CHR:
E2 EF       LOOP CHR_LOOP       ; continue loop 
B4 09       MOV  AH, 9          ; DOS display string function 
BA 0082     MOV  DX, 082H       ; output string is at memory address 82H 
CD 21       INT  21H            ; display string to screen 
C3          RET                 ; return to DOS 

PC DOS แบบสแตนด์อโลน อินพุตผ่าน args ของบรรทัดคำสั่งส่งออกไปยังหน้าจอ

ป้อนคำอธิบายรูปภาพที่นี่

ดาวน์โหลดและการทดสอบ PWAS.COM



1

รุ่นที่ 141 ไบต์

@set t=
@for %%w in (%*)do @call:c %%w
@echo%t%
@exit/b
:c
@set s=%1
@if not %s%==%s:~,1% set s=%s:~-1%%s:~1,-1%%s:~,1%
@set t=%t% %s%

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


1

C # (Visual C # Interactive Compiler) , 90 ไบต์

n=>n.Split().Any(x=>WriteLine(x.Length<2?x:x.Last()+x.Substring(1,x.Length-2)+x[0])is int)

ใช้บรรทัดใหม่เป็นตัวคั่นแม้ว่าช่องว่างใด ๆ สามารถใช้งานได้

ลองออนไลน์!


SelectMany (นั่นคือแม็พและแบน) สำหรับ 84 ไบต์ แต่ส่งออกพื้นที่ต่อท้ายเดียว ลองออนไลน์!
สรรพนามของฉันคือ monicareinstate


1

Java, 110 109 ไบต์

-1 ไบต์โดยใช้บรรทัดใหม่สำหรับ delimeter

s->{int l;for(var i:s.split("\n"))System.out.println(i.charAt(l=i.length()-1)+i.substring(1,l)+i.charAt(0));}

TIO


มันใช้งานได้กับคำตัวอักษรเดียว?
Neil

@ ไม่เลยเพราะฉันไม่ดี ฉันจะแก้ไขในภายหลัง
Benjamin Urquhart

109โดยใช้บรรทัดใหม่เป็นตัวคั่น
ศูนย์รวมของความไม่รู้

1

Haskell , 75 74 ไบต์

แก้ไขข้อผิดพลาดที่ชี้ไปที่ลูกบาศก์และยังลง 1 ไบต์

f=unwords.map(#v).words
x#g=g(r$tail x)++[x!!0]
r=reverse
v[]=[]
v x=r$x#r

ลองออนไลน์!


map gสั้นกว่า(g<$>)
Cubic

1
นอกจากนี้ถ้าคุณมองไปที่กรณีการทดสอบของคุณคุณจะเห็นว่ามันไม่ทำงานสำหรับตัวอักษรคำหนึ่งก็จะเปิดaเข้าaa
Cubic


1

T-SQL, 126 ไบต์

SELECT STRING_AGG(STUFF(STUFF(value,1,1,RIGHT(value,1)),LEN(value),1,LEFT(value,1)),' ')
FROM STRING_SPLIT((SELECT*FROM t),' ')

การป้อนข้อมูลผ่านทางตารางที่มีอยู่ก่อนทีมีเขต varchar วี , ตามมาตรฐาน IO ของเรา

อ่านจากด้านหลังไปข้างหน้าSTRING_SPLITแบ่งสตริงออกเป็นแต่ละแถวผ่านตัวคั่นSTUFFปรับเปลี่ยนอักขระตามตำแหน่งที่ระบุจากนั้นSTRING_AGGนำกลับมารวมกันอีกครั้ง

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