Hoặc, "Hoán đổi chữ cái đầu tiên và cuối cùng của mỗi từ"

Thách thức của bạn là, đưa ra một chuỗi các ký tự ASCII theo thứ tự chữ cái cũng như một ký tự khác để sử dụng làm dấu phân cách (để phân tách từng từ), hoán đổi các chữ cái đầu tiên và cuối cùng của mỗi từ. Nếu có một từ một ký tự, hãy để nó một mình.

Các ví dụ / testcase sử dụng các chữ cái viết thường và khoảng trắng làm dấu phân cách.

Bạn không cần phải xử lý dấu câu; tất cả các đầu vào sẽ chỉ bao gồm các chữ cái từ a đến z, được phân tách bằng dấu phân cách, tất cả các trường hợp thống nhất.

Ví dụ: với chuỗi "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"

LƯU Ý: dấu phân cách không cần phải nhập riêng. Dấu phân cách chỉ là ký tự được sử dụng để phân tách các từ. Nó có thể là bất cứ thứ gì. Tôi muốn để các tùy chọn mở cho những người chơi golf sáng tạo, vì vậy tôi không muốn giới hạn nó chỉ trong không gian hoặc dòng mới. Dấu phân cách chỉ là một ký tự phân tách các từ trong chuỗi đầu vào.

Các trường hợp thử nghiệm:

"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"

TeX, 216 byte (mỗi dòng 4 ký tự)

Bởi vì nó không phải là về số byte, mà là về chất lượng của đầu ra sắp chữ :-)

{\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 }}

Hãy thử trực tuyến! (Overleaf; không chắc nó hoạt động như thế nào)

Tập tin kiểm tra đầy đủ:

{\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

Đầu ra:

Đối với LaTeX, bạn chỉ cần bản tóm tắt:

\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}

Giải trình

TeX là một con thú kỳ lạ. Đọc mã bình thường và hiểu nó là một kỳ công của chính nó. Hiểu mã TeX bị xáo trộn đi thêm một vài bước. Tôi sẽ cố gắng làm cho điều này trở nên dễ hiểu đối với những người không biết TeX, vì vậy trước khi chúng tôi bắt đầu đây là một vài khái niệm về TeX để làm cho mọi thứ dễ theo dõi hơn:

Dành cho người mới bắt đầu TeX tuyệt đối

• Đầu tiên và là mục quan trọng nhất trong danh sách này: mã không phải ở dạng hình chữ nhật, mặc dù văn hóa nhạc pop có thể khiến bạn nghĩ như vậy .

• TeX là một ngôn ngữ mở rộng vĩ mô. Bạn có thể, ví dụ, xác định \def\sayhello#1{Hello, #1!}và sau đó viết \sayhello{Code Golfists}để có được TeX để in Hello, Code Golfists!. Đây được gọi là một macro macro không giới hạn, và để cung cấp cho nó tham số đầu tiên (và duy nhất, trong trường hợp này), bạn đặt nó trong dấu ngoặc nhọn. TeX loại bỏ các dấu ngoặc nhọn khi macro lấy đối số. Bạn có thể sử dụng tối đa 9 tham số: \def\say#1#2{#1, #2!}sau đó \say{Good news}{everyone}.

• Bản sao của các macro không được phân tách là, không có gì đáng ngạc nhiên, các macro được phân tách :) Bạn có thể làm cho định nghĩa trước đó trở nên khó hiểu hơn về ngữ nghĩa : \def\say #1 to #2.{#1, #2!}. Trong trường hợp này, các tham số được theo sau bởi cái gọi là văn bản tham số . Văn bản tham số như vậy phân định đối số của macro ( #1được phân định bởi ␣to␣, khoảng trắng được bao gồm và #2được phân định bởi .). Sau định nghĩa đó bạn có thể viết \say Good news to everyone., nó sẽ mở rộng ra Good news, everyone!. Đẹp phải không? :) Tuy nhiên, một đối số được phân tách là (trích dẫn TeXbook ) là chuỗi các mã thông báo ngắn nhất (có thể trống) với các {...}nhóm được lồng đúng cách được theo sau trong danh sách cụ thể của các mã thông báo không tham số cụ thể này. Điều này có nghĩa là việc mở rộng\say Let's go to the mall to Martinsẽ tạo ra một câu kỳ lạ. Trong trường hợp này, bạn cần phải ẩn giấu đầu tiên ␣to␣với {...}: \say {Let's go to the mall} to Martin.

• Càng xa càng tốt. Bây giờ mọi thứ bắt đầu trở nên kỳ lạ. Khi TeX đọc một ký tự (được xác định bởi mã ký tự của người dùng), nó sẽ gán cho nhân vật đó một mã thể loại Mã số (mã hóa, cho bạn bè :) xác định nghĩa của ký tự đó. Sự kết hợp giữa mã ký tự và mã danh mục này tạo ra một mã thông báo ( ví dụ thêm về điều đó ở đây ). Những người quan tâm đến chúng tôi ở đây về cơ bản là:

  • catcode 11 , xác định mã thông báo có thể tạo thành chuỗi điều khiển (tên posh cho macro). Theo mặc định, tất cả các chữ cái [a-zA-Z] là catcode 11, vì vậy tôi có thể viết \hello, đó là một chuỗi điều khiển duy nhất, trong khi đó \he11olà chuỗi điều khiển \hetheo sau bởi hai ký tự 1, theo sau là chữ cái o, vì 1không phải là catcode 11. Nếu tôi đã làm \catcode`1=11, từ thời điểm đó trở đi \he11osẽ là một chuỗi điều khiển. Một điều quan trọng là mã hóa được thiết lập khi TeX lần đầu tiên nhìn thấy nhân vật trong tay và mã số như vậy bị đóng băng ... TUYỆT VỜI ! (điều khoản và điều kiện có thể áp dụng)

  • catcode 12 , hầu hết các ký tự khác, chẳng hạn như 0"!@*(?,.-+/vv. Chúng là loại catcode ít đặc biệt nhất vì chúng chỉ phục vụ cho việc viết nội dung trên giấy. Nhưng này, ai dùng TeX để viết?!? (một lần nữa, các điều khoản và điều kiện có thể được áp dụng)

  • catcode 13 , đó là địa ngục :) Thật vậy. Ngừng đọc và đi làm một cái gì đó ra khỏi cuộc sống của bạn. Bạn không muốn biết catcode 13 là gì. Bạn đã bao giờ nghe đến thứ Sáu ngày 13 chưa? Đoán xem nó có tên từ đâu! Tiếp tục có nguy cơ của riêng bạn! Một ký tự 13 mã catcode, còn được gọi là một nhân vật hoạt động của người dùng, không chỉ là một nhân vật nữa, nó là một macro! Bạn có thể định nghĩa nó để có các tham số và mở rộng thành một cái gì đó như chúng ta đã thấy ở trên. Sau khi bạn làm \catcode`e=13bạn nghĩ rằng bạn có thể làm \def e{I am the letter e!}, NHƯNG. BẠN. KHÔNG THỂ! ekhông phải là một bức thư nữa, vì vậy \defkhông phải là \defbạn biết, nó là \d e f! Oh, chọn một chữ cái bạn nói? Đuợc! \catcode`R=13 \def R{I am an ARRR!}. Rất tốt, Jimmy, hãy thử nó! Tôi dám bạn làm điều đó và viết một Rmã số của bạn! Đó là những gì một catcode 13 là. TÔI BÌNH TĨNH! Tiếp tục nào.

• Được rồi, bây giờ để nhóm. Điều này khá đơn giản. Bất kỳ nhiệm vụ nào ( \deflà một hoạt động chuyển nhượng, \let(chúng tôi sẽ thực hiện) là một nhiệm vụ khác) được thực hiện trong một nhóm được khôi phục lại trước khi nhóm đó bắt đầu trừ khi nhiệm vụ đó là toàn cầu. Có một số cách để bắt đầu các nhóm, một trong số đó là với catcode 1 và 2 ký tự (oh, lại mã hóa). Theo mặc định {là catcode 1, hoặc nhóm bắt đầu và }là catcode 2 hoặc nhóm cuối. Một ví dụ: \def\a{1} \a{\def\a{2} \a} \aBản in này 1 2 1. Bên ngoài nhóm \alà 1, sau đó bên trong nó được xác định lại 2và khi nhóm kết thúc, nó được khôi phục lại 1.

• Các \lethoạt động là một hoạt động phân công như thế \def, nhưng khá khác nhau. Với \defbạn xác định các macro sẽ mở rộng thành công cụ, với \letbạn tạo các bản sao của những thứ đã tồn tại. Sau \let\blub=\def( =tùy chọn), bạn có thể thay đổi bắt đầu eví dụ từ mục catcode 13 ở trên sang \blub e{...và vui chơi với mục đó. Hoặc tốt hơn, thay vì phá vỡ những thứ bạn có thể sửa chữa (bạn sẽ xem xét điều đó!) RVí dụ : \let\newr=R \catcode`R=13 \def R{I am an A\newr\newr\newr!}. Câu hỏi nhanh: bạn có thể đổi tên thành \newR?

• Cuối cùng, cái gọi là không gian giả mạo tinh vi. Đây là một chủ đề cấm kỵ bởi vì có những người cho rằng danh tiếng kiếm được trong Sàn giao dịch TeX - LaTeX bằng cách trả lời các không gian giả mạo của Wikipedia không nên xem xét các câu hỏi, trong khi những người khác hết lòng không đồng ý. Bạn đồng ý với ai? Đặt cược! Trong khi đó: TeX hiểu một ngắt dòng là một khoảng trắng. Cố gắng viết một vài từ có ngắt dòng (không phải là một dòng trống ) giữa chúng. Bây giờ thêm một %ở cuối của những dòng này. Có vẻ như bạn đã bình luận về những không gian cuối dòng này. Đó là nó :)

(Sắp xếp) không mã hóa mã

Chúng ta hãy làm cho hình chữ nhật đó thành một cái gì đó (có thể nói là) dễ theo dõi hơn:

{
\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 }
}

Giải thích từng bước

mỗi dòng chứa một lệnh duy nhất. Chúng ta hãy đi từng người một, mổ xẻ chúng:

{
Trước tiên, chúng tôi bắt đầu một nhóm để giữ một số thay đổi (cụ thể là thay đổi catcode) cục bộ để chúng không làm rối văn bản đầu vào.

\let~\catcode
Về cơ bản tất cả các mã mã hóa TeX bắt đầu với hướng dẫn này. Theo mặc định, cả trong TeX và LaTeX đơn giản, ~ký tự là một ký tự hoạt động có thể được tạo thành macro để sử dụng tiếp. Và công cụ tốt nhất để làm lạ mã TeX là thay đổi catcode, vì vậy đây thường là sự lựa chọn tốt nhất. Bây giờ thay vì \catcode`A=13chúng ta có thể viết ~`A13( =là tùy chọn):

~`A13
Bây giờ bức thư Alà một nhân vật hoạt động và chúng ta có thể định nghĩa nó để làm một cái gì đó:

\defA#1{~`#113\gdef}
Abây giờ là một macro có một đối số (nên là một ký tự khác). Đầu tiên, catcode của đối số được thay đổi thành 13 để kích hoạt nó: ~`#113(thay thế ~bằng \catcodevà thêm một =và bạn có \catcode`#1=13:). Cuối cùng, nó để lại một \gdef(toàn cầu \def) trong luồng đầu vào. Nói tóm lại, Alàm cho một nhân vật khác hoạt động và bắt đầu định nghĩa của nó. Hãy thử nó:

AGG#1{~`#113\global\let}
AGĐầu tiên, kích hoạt Gvà kích hoạt \gdef, và tiếp theo là Gbắt đầu định nghĩa. Định nghĩa của Gnó rất giống với định nghĩa của A, ngoại trừ thay vì \gdefnó làm một \global\let(không \gletgiống như \gdef). Nói tóm lại, Gkích hoạt một nhân vật và biến nó thành một thứ khác. Hãy tạo lối tắt cho hai lệnh chúng ta sẽ sử dụng sau:

GFF\else
GHH\fi
Bây giờ thay vì \elsevà \fichúng ta chỉ có thể sử dụng Fvà H. Ngắn hơn nhiều :)

AQQ{Q}
Bây giờ chúng tôi sử dụng Amột lần nữa để xác định một macro khác , Q. Các tuyên bố trên về cơ bản là (trong một ngôn ngữ ít bị xáo trộn) \def\Q{\Q}. Đây không phải là một định nghĩa thú vị khủng khiếp, nhưng nó có một tính năng thú vị. Trừ khi bạn muốn phá vỡ một số mã, macro duy nhất mà mở rộng để Qlà Qchính, vì vậy nó hoạt động như một dấu hiệu duy nhất (nó được gọi là một quark ). Bạn có thể sử dụng \ifxđiều kiện để kiểm tra nếu đối số của macro là quark như vậy với \ifx Q#1:

AII{\ifxQ}
vì vậy bạn có thể khá chắc chắn rằng bạn đã tìm thấy một điểm đánh dấu như vậy. Lưu ý rằng trong định nghĩa này, tôi đã loại bỏ khoảng trắng giữa \ifxvà Q. Thông thường, điều này sẽ dẫn đến một lỗi (lưu ý rằng phần tô sáng cú pháp cho rằng đó \ifxQlà một điều), nhưng vì bây giờ Qlà catcode 13 nên nó không thể tạo thành một chuỗi điều khiển. Tuy nhiên, hãy cẩn thận, không mở rộng quark này hoặc bạn sẽ bị mắc kẹt trong một vòng lặp vô hạn vì Qmở rộng tới Qđó mở rộng tới Q...

Bây giờ việc sơ bộ đã xong, chúng ta có thể đi đến thuật toán thích hợp để pwas eht setterl. Do mã thông báo của TeX, thuật toán phải được viết ngược. Điều này là do tại thời điểm bạn thực hiện một định nghĩa, TeX sẽ mã hóa (gán mã số) cho các ký tự trong định nghĩa bằng cách sử dụng các cài đặt hiện tại, ví dụ, nếu tôi làm:

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

đầu ra là E1, trong khi nếu tôi thay đổi thứ tự của các định nghĩa:

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

đầu ra là 11. Điều này là do trong ví dụ đầu tiên, Etrong định nghĩa đã được mã hóa thành một chữ cái (catcode 11) trước khi thay đổi catcode, vì vậy nó sẽ luôn là một chữ cái E. Tuy nhiên, trong ví dụ thứ hai, Elần đầu tiên được kích hoạt và chỉ sau đó \oneđược xác định và bây giờ định nghĩa chứa mã số 13 Emở rộng 1.

Tuy nhiên, tôi sẽ bỏ qua thực tế này và sắp xếp lại các định nghĩa để có thứ tự hợp lý (nhưng không hoạt động). Trong đoạn văn sau đây bạn có thể giả định rằng các chữ cái B, C, D, và Eđang hoạt động.

\gdef\S#1{\iftrueBH#1 Q }
. )
Trước tiên, chúng tôi xác định macro cấp độ người dùng , \S. Đây không phải là một nhân vật hoạt động để có cú pháp thân thiện (?), Vì vậy macro cho gwappins eht setterl là \S. Macro bắt đầu với một điều kiện luôn luôn đúng \iftrue(nó sẽ sớm rõ ràng tại sao), và sau đó gọi Bmacro theo sau H(mà chúng ta đã xác định trước đó là \fi) để khớp với \iftrue. Sau đó, chúng ta để lại đối số của macro #1theo sau là khoảng trắng và quark Q. Giả sử chúng ta sử dụng \S{hello world}, sau đó là luồng đầu vàosẽ giống như thế này: \iftrue BHhello world Q␣(Tôi đã thay thế không gian cuối cùng bằng cách ␣để kết xuất của trang web không ăn nó, giống như tôi đã làm trong phiên bản mã trước đó). \iftruelà đúng, vì vậy nó mở rộng và chúng tôi còn lại với BHhello world Q␣. TeX không không loại bỏ các \fi( H) sau khi có điều kiện được đánh giá, thay vào đó nó để lại nó ở đó cho đến khi \fiđược thực sự mở rộng. Bây giờ Bmacro được mở rộng:

ABBH#1 {HI#1FC#1|BH}
Blà một macro được phân tách có văn bản tham số H#1␣, vì vậy đối số là bất cứ thứ gì nằm giữa Hvà một khoảng trắng. Tiếp tục ví dụ trên luồng đầu vào trước khi mở rộng Blà BHhello world Q␣. Bđược theo sau bởi Hvì nếu không (nếu không TeX sẽ phát sinh lỗi), thì khoảng trắng tiếp theo nằm giữa hellovà world, từ đó #1cũng vậy hello. Và ở đây chúng tôi phải phân chia văn bản đầu vào tại các khoảng trắng. Yay: D Việc mở rộng Bđể loại bỏ việc tất cả mọi thứ lên đến không gian đầu tiên từ input stream và thay thế bằng HI#1FC#1|BHvới #1là hello: HIhelloFChello|BHworld Q␣. Lưu ý rằng có một BHluồng mới sau trong luồng đầu vào, để thực hiện đệ quy đuôiBvà xử lý các từ sau. Sau khi từ này được xử lý xử Blý từ tiếp theo cho đến khi từ được xử lý là quark Q. Không gian cuối cùng sau Qlà cần thiết vì macro được phân tách B yêu cầu một ở cuối đối số. Với phiên bản trước (xem lịch sử chỉnh sửa), mã sẽ hoạt động sai nếu bạn sử dụng \S{hello world}abc abc(khoảng trắng giữa các abcs sẽ biến mất).

OK, quay lại luồng đầu vào : HIhelloFChello|BHworld Q␣. Đầu tiên có H( \fi) hoàn thành ban đầu \iftrue. Bây giờ chúng ta có cái này (pseudocoding):

I
  hello
F
  Chello|B
H
world Q␣

Các I...F...Hsuy nghĩ thực sự là một \ifx Q...\else...\ficấu trúc. Các \ifxkiểm tra thử nghiệm nếu (đầu tiên dấu chỉ về sự) từ nắm lấy là Qquark. Nếu không có gì khác để thực hiện và việc thực thi chấm dứt, nếu không thì còn lại là : Chello|BHworld Q␣. Bây giờ Cđược mở rộng:

ACC#1#2|{D#2Q|#1 }
Đối số đầu tiên Clà không bị giới hạn, vì vậy trừ khi được kết hợp, nó sẽ là một mã thông báo duy nhất, Đối số thứ hai được phân định bởi |, do đó, sau khi mở rộng C(với #1=hvà #2=ello) luồng đầu vào là : DelloQ|h BHworld Q␣. Chú ý rằng khác |được đặt ở đó, và hcủa hellođược đặt sau đó. Một nửa trao đổi được thực hiện; chữ cái đầu tiên ở cuối Trong TeX, thật dễ dàng để lấy mã thông báo đầu tiên của danh sách mã thông báo. Một macro đơn giản \def\first#1#2|{#1}nhận được chữ cái đầu tiên khi bạn sử dụng \first hello|. Vấn đề cuối cùng là một vấn đề vì TeX luôn lấy danh sách mã thông báo nhỏ nhất, có thể trống rỗng, làm đối số, vì vậy chúng tôi cần một vài cách giải quyết. Mục tiếp theo trong danh sách mã thông báo là D:

ADD#1#2|{I#1FE{}#1#2|H}
Đây Dvĩ mô là một trong những công việc ở quanh và nó rất hữu ích trong trường hợp duy nhất mà từ có một chữ cái. Giả sử thay vì hellochúng ta đã có x. Trong trường hợp này, luồng đầu vào sẽ là DQ|x, sau đó Dsẽ mở rộng (có #1=Qvà #2trống) thành : IQFE{}Q|Hx. Điều này tương tự với khối I...F...H( \ifx Q...\else...\fi) B, sẽ thấy rằng đối số là quark và sẽ làm gián đoạn việc thực hiện chỉ để lại xcho việc sắp chữ. Trong các trường hợp khác (trở lại helloví dụ), Dsẽ mở rộng (có #1=evà #2=lloQ) thành : IeFE{}elloQ|Hh BHworld Q␣. Một lần nữa, I...F...Hsẽ kiểm tra Qnhưng sẽ thất bại và lấy \elsechi nhánh : E{}elloQ|Hh BHworld Q␣. Bây giờ là phần cuối cùng của điều này,E vĩ mô sẽ mở rộng:

AEE#1#2#3|{I#3#2#1FE{#1#2}#3|H}
Văn bản tham số ở đây khá giống với Cvà D; đối số thứ nhất và thứ hai không bị giới hạn và đối số cuối cùng được phân định bởi |. Luồng đầu vào trông như thế này : E{}elloQ|Hh BHworld Q␣, sau đó Emở rộng (với #1khoảng trống #2=e, và #3=lloQ) : IlloQeFE{e}lloQ|HHh BHworld Q␣. Một I...F...Hkhối khác kiểm tra quark (nhìn thấy lvà trả về false) : E{e}lloQ|HHh BHworld Q␣. Bây giờ Emở rộng lại (với #1=etrống #2=l, và #3=loQ) : IloQleFE{el}loQ|HHHh BHworld Q␣. Và một lần nữa I...F...H. Macro thực hiện thêm một vài lần lặp cho đến khi Qcuối cùng được tìm thấy và truenhánh được thực hiện: E{el}loQ|HHHh BHworld Q␣-> IoQlelFE{ell}oQ|HHHHh BHworld Q␣-> E{ell}oQ|HHHHh BHworld Q␣-> IQoellFE{ello}Q|HHHHHh BHworld Q␣. Bây giờ quark được tìm thấy và điều kiện mở rộng thành : oellHHHHh BHworld Q␣. Phù.

Oh, đợi đã, đây là những gì? THƯ VIỆN BÌNH THƯỜNG? Oh Boy! Các chữ cái cuối cùng được tìm thấy và TeX ghi lại oell, sau đó một bó H( \fi) được tìm thấy và mở rộng (thành không có gì) để lại luồng đầu vào với : oellh BHworld Q␣. Bây giờ từ đầu tiên có các chữ cái đầu tiên và cuối cùng được hoán đổi và những gì TeX tìm thấy tiếp theo là từ còn Blại để lặp lại toàn bộ quá trình cho từ tiếp theo.

}
Cuối cùng, chúng tôi kết thúc nhóm bắt đầu trở lại đó để tất cả các bài tập địa phương được hoàn tác. Các bài tập địa phương là những thay đổi catcode của các chữ cái A, B, C, ... mà đã được thực hiện macro để họ quay trở lại ý nghĩa bức thư bình thường của họ và có thể được sử dụng an toàn trong văn bản. Và đó là nó. Bây giờ \Smacro được xác định trở lại ở đó sẽ kích hoạt xử lý văn bản như trên.

Một điều thú vị về mã này là nó có thể mở rộng hoàn toàn. Đó là, bạn có thể sử dụng nó một cách an toàn trong việc di chuyển các đối số mà không lo rằng nó sẽ phát nổ. Bạn thậm chí có thể sử dụng mã để kiểm tra xem chữ cái cuối cùng của từ có giống với từ thứ hai không (vì bất kỳ lý do gì bạn sẽ cần điều đó) trong một \ifbài kiểm tra:

\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

Xin lỗi vì lời giải thích (có lẽ quá xa). Tôi cũng đã cố gắng làm cho nó rõ ràng nhất có thể đối với những người không phải TeXies :)

Tóm tắt cho người thiếu kiên nhẫn

Macro \Schuẩn bị đầu vào với một ký tự hoạt động B, lấy danh sách các mã thông báo được phân tách bằng khoảng trắng cuối cùng và chuyển chúng đến C. Clấy mã thông báo đầu tiên trong danh sách đó và di chuyển nó đến cuối danh sách mã thông báo và mở rộng Dvới những gì còn lại. Dkiểm tra xem những gì còn lại là trống rỗng, trong trường hợp đó, một từ đơn lẻ được tìm thấy, sau đó không làm gì cả; nếu không thì mở rộng E. Ecác vòng lặp thông qua danh sách mã thông báo cho đến khi tìm thấy chữ cái cuối cùng trong từ, khi tìm thấy nó để lại chữ cái cuối cùng, theo sau là từ giữa, sau đó là chữ cái đầu tiên ở cuối dòng mã thông báo C.

JavaScript (ES6),  39  36 byte

Đã lưu 3 byte nhờ @FryAmTheEggman

Sử dụng một nguồn cấp dữ liệu như là dấu phân cách.

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

Hãy thử trực tuyến!

Võng mạc ,số 8 5 byte

,V,,`

Hãy thử trực tuyến!

Đã lưu 3 byte nhờ Kevin Cruijssen !

Sử dụng một dòng mới là dấu phân cách. Chúng tôi sử dụng giai đoạn đảo ngược của Retina và một số giới hạn. Giới hạn đầu tiên là phù hợp để áp dụng đảo ngược, vì vậy chúng tôi chọn tất cả chúng ,. Sau đó, chúng tôi muốn chữ cái đầu tiên và cuối cùng của mỗi trận đấu được hoán đổi, vì vậy chúng tôi lấy từng chữ cái trong phạm vi ,,dịch thành một phạm vi từ đầu đến cuối với kích thước bước bằng không.

Pepe , 107 105 byte

REEeREeeEeeeeerEEreREEEeREEEEEEeREEEErEEREEEEEEEreererEEEeererEEEerEEeERrEEEeerEEeerereeerEEEEeEEEReEeree

Hãy thử trực tuyến!

Giải trình:

Ký hiệu về ý kiến: 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

Python 3 , 72 58 byte

print(*[x[-1]+x[1:-1]+x[:x>x[0]]for x in input().split()])

Hãy thử trực tuyến!

laskelH , 71 byte

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

Hãy thử trực tuyến!

Ví dụ trong / đầu ra:

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
```

05AB1E , 10 byte

#vyRćsRćðJ

Hãy thử trực tuyến!

-3 Cảm ơn @Kevin Cruijssen .

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

J , 23 17 byte

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

Hãy thử trực tuyến!

Ruby với -p, 42 41 29 byte

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

Hãy thử trực tuyến!

Haskell, 54 byte

unwords.map f.words
f[a]=[a]
f(a:b)=last b:init b++[a]

Hãy thử trực tuyến!

Japt -S , 7 byte

¸®ÎiZÅé

Thử nó

PowerShell , 37 byte

$args-replace'(\w)(\w*)(\w)','$3$2$1'

Hãy thử trực tuyến!

Stax , 8 byte

Σq╞♪áZN¢

Chạy và gỡ lỗi nó

Sử dụng các dòng mới như dấu phân cách từ.

Khoảng trắng , 179 byte

[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]

Chữ cái S(dấu cách), T(tab) và N(dòng mới) được thêm vào dưới dạng chỉ tô sáng.
[..._some_action]chỉ thêm vào giải thích.

Tab là dấu phân cách. Đầu vào phải chứa một dòng mới (hoặc tab), nếu không chương trình không biết khi nào nên dừng, vì lấy đầu vào trong Khoảng trắng chỉ có thể được thực hiện một ký tự một lần.

Dùng thử trực tuyến (chỉ có khoảng trắng, tab và dòng mới).

Giải thích bằng mã giả:

$[0, ..., \text{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

Chương trình kết thúc với một lỗi khi nó cố đọc một ký tự khi không có ký tự nào được đưa ra trong TIO (hoặc nó bị treo chờ đợi một đầu vào trong một số trình biên dịch Whitespace như vii5ard ).

Ngôn ngữ Wolfram (Mathicala) , 58 byte

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

Hãy thử trực tuyến!

-22 byte từ @attinat

-12 byte từ @ M.Stern

QuadR , 20 byte

(\w)(\w*)(\w)
\3\2\1

Đơn giản chỉ cần tạo ba nhóm bắt gồm 1, 0 hoặc nhiều hơn và 1 ký tự từ, sau đó đảo ngược thứ tự của chúng.

Hãy thử trực tuyến!

APL + THẮNG, 50 byte

(∊¯1↑¨s),¨1↓¨(¯1↓¨s),¨↑¨s←((+\s=' ')⊂s←' ',⎕)~¨' '

Nhắc cho chuỗi và sử dụng không gian làm dấu phân cách.

Hãy thử trực tuyến! Lịch sự của Dyalog Classic

Japt -S , 10 byte

Tin chắc rằng phải có một cách tiếp cận ngắn hơn (và tôi đã đúng ) nhưng điều này sẽ làm ngay bây giờ.

¸ËhJDg)hDÌ

Thử nó

¸Ë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

sed, 64 byte

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

sed , 34 byte

Và có lẽ ý tưởng mẫu sẽ hoạt động với hầu hết các công cụ RE (và tôi biết có sự khác biệt giữa RE tiêu chuẩn và RE mở rộng).

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

Hãy thử trực tuyến!

Ruby, 53 byte

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

Tôi đã thử nó mà không có regex. Đầu ra in từng từ trên một dòng mới. Nếu đó là trái với quy tắc, hãy cho tôi biết và tôi sẽ sửa nó.

Ung dung:

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

Hội 8088, IBM PC DOS, 39 38 byte

$ 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

Chưa được lắp ráp:

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 độc lập thực thi. Nhập thông qua dòng lệnh args, đầu ra màn hình.

Tải xuống và kiểm tra PWAS.COM .

Perl 5 -p , 24 byte

s/(\w)(\w*)(\w)/$3$2$1/g

Hãy thử trực tuyến!

Mẻ, 141 byte

@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%

Lấy đầu vào là tham số dòng lệnh. Thao tác chuỗi rất tệ trong Batch, và việc sử dụng các từ đơn trong trường hợp đặc biệt không giúp ích được gì.

C # (Trình biên dịch tương tác Visual C #) , 90 byte

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

Sử dụng dòng mới dưới dạng dấu phân cách, mặc dù thực sự có thể sử dụng bất kỳ khoảng trắng nào.

Hãy thử trực tuyến!

Biểu tượng , 76 byte

link segment
procedure f(s)
w:=!seglist(s,' ')&w[1]:=:w[-1]&writes(w)&\x
end

Hãy thử trực tuyến!

Java, 110 109 byte

-1 byte bằng cách sử dụng một dòng mới cho một phân số

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

Haskell , 75 74 byte

Đã sửa lỗi được chỉ ra bởi Cubic và cũng đánh xuống 1 byte.

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

Hãy thử trực tuyến!

Scala, 100 byte

(b:String,c:String)=>b.split(c)map(f=>f.tail.lastOption++:(f.drop(1).dropRight(1)+f.head))mkString c

T-SQL, 126 byte

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

Đầu vào là thông qua một bảng t có sẵn với trường varchar v , theo các tiêu chuẩn IO của chúng tôi .

Đọc từ sau ra trước, STRING_SPLITngắt một chuỗi thành các hàng riêng lẻ thông qua một dấu phân cách, STUFFsửa đổi các ký tự tại các vị trí đã chỉ định, sau đó STRING_AGGtrộn chúng lại với nhau.