В чате, мы часто быстро-TYPERS и на самом деле не смотреть на того , из писем , прежде чем отправлять сообщение. Поскольку мы ленивы, нам нужна программа, которая автоматически меняет последние две буквы в наших словах, но поскольку мы не хотим отвечать слишком поздно, код должен быть коротким.

Ваша задача, если вы хотите принять это, - написать программу, которая переворачивает последние две буквы каждого слова в заданной строке (таким образом, слово Thanskпревращается в Thanks). Слово представляет собой последовательность из двух или более букв в английском алфавите , ограниченной одной пространства.

• Строка / список символов, которые вы получаете в качестве входных данных, гарантированно содержат только буквенные символы и пробелы (ASCII [97 - 122], [65 - 90] и 32).

• Вы можете принимать и выводить данные любым стандартным методом , на любом языке программирования , при этом отмечая, что эти лазейки по умолчанию запрещены.

• Вывод может иметь один завершающий пробел и / или один завершающий символ новой строки.

• Ввод всегда будет содержать только слова (и соответствующий пробел) и будет состоять как минимум из одного слова.

Это код-гольф, поэтому выигрывает самая короткая подача (в байтах) на каждом языке!

Контрольные примеры

Обратите внимание, что строки заключены в кавычки для удобства чтения.

Вход -> Выход

"Thansk" -> "Спасибо"
"Youer Welcoem" -> "Добро пожаловать"
"Это яблоко" -> "Thsi si na appel"
"Flippign Lettesr Aroudn" -> "Листать буквы вокруг"
"ЗАДАЧА ВЫЗОВА С ОБМЕННЫМИ БУКВАМИ" -> "ЗАДАЧА С ЗАМЕНАМИ БУКВ"

Или, для удобства набора тестов, здесь отдельно представлены входы и соответствующие им выходы:

Thansk
Youer Welcoem
Это яблоко
Flippign Lettesr Aroudn
ШАЛЕНЕГ С ОБМЕНАМИ

Благодарность
Пожалуйста
Это на апелляция
Листать буквы
С ОДНОВРЕМЕННОЙ ЗАДАЧЕЙ

Спасибо DJMcMayhem за титул. Первоначально это была CMC .

V , 4 5 байт

òeXp

Попробуйте онлайн!

|| обозначает курсор

Буфер начинается с |w|ord and more wordsи курсор находится на первом символе.

Рекурсивный ò

перейти к eконцу слова

wor|d| and more words

удалить Xсимвол слева от курсора

wo|d| and more words

pоцените следующий символ

wod|r| and more words

Неявное окончание ò, повторите тот же процесс для других слов, пока не будет достигнут конец буфера

Желе , 7 байт

Ḳœ?@€2K

Монадическая ссылка, берущая и возвращающая списки символов

Попробуйте онлайн!

Как?

Ḳœ?@€2K - Link: list of characters
Ḳ       - split at spaces
     2  - literal two
    €   - for €ach:
   @    -   with sw@pped arguments:
 œ?     -     nth permutation (the 2nd permutation has the rightmost elements swapped)
      K - join with spaces

Brain-Flak , 122 байта

{(({})[((((()()){}){}){}){}])((){[()](<{}>)}{}){{}<>(({}({}))[({}[{}])])(<>)}{}({}<>)<>}<>(({}({}))[({}[{}])]){({}<>)<>}<>

Попробуйте онлайн!

Худший язык для работы :)

Читаемая Чуть более читаемая версия:

{
    (({})[((((()()){}){}){}){}])((){[()](<{}>)}{})

    {
        {}
        <>

        (({}({}))[({}[{}])])

        (<>)
    }
    {}

    ({}<>)<>

}<>

(({}({}))[({}[{}])])

{

    ({}<>)
    <>
}<>

Haskell , 40 байт

(f=<<).words
f[a,b]=b:a:" "
f(x:r)=x:f r

Попробуйте онлайн! Пример использования: (f=<<).words $ "abc xyz"доходность "acb xzy ".

Сетчатка , 13 байт

(.)(.)\b
$2$1

Попробуйте онлайн! Ссылка включает в себя тестовые случаи.

Python 3 , 50 байт

print(*(w[:-2]+w[:-3:-1]for w in input().split()))

Попробуйте онлайн!

Этот ответ нарушает поведение печати в Python 3: несколько аргументов печатаются с одним пробелом между ними. Конечно, мы не можем просто дать ему несколько аргументов, потому что мы не знаем, сколько слов будет на входе. Поэтому мы используем оператор splat . В основном

print(*[a,b,c])

точно так же, как

print(a,b,c)

Злоупотребление приводит к тому, что полная программа оказывается короче, чем функция / лямбда, где мы должны были бы использовать ' '.joinили что-то подобное.

Matlab (R2016b), 51 50 байт

Сохранено 49 50 (!) Байт благодаря @Giuseppe.

function s(a),regexprep(a,'(\w)(\w)( |$)','$2$1 ')

И мой предыдущий ответ:

Matlab (R2016b), 100 байт

(Просто для удовольствия: P)

function s(a),a=regexp(a,' ','split');for i=1:length(a),fprintf('%s ',a{i}([1:end-2 end end-1])),end

Объяснение:

function s(a) % Defining as a function...
a=regexp(a,' ','split'); % Splits the input string at the spaces
for i=1:length(a) % Loops through each word
    fprintf('%s ',a{i}([1:end-2 end end-1])) % And prints everything with the last two characters swapped.
end

C  62   58  54 байта

Спасибо @Dennis за сохранение  четырех  восьми байтов!

f(char*s){s[1]>32||(*s^=s[-1]^=*s^=s[-1]);*++s&&f(s);}

Попробуйте онлайн!

Пролог (SWI) , 60 байт

[A,B]+[B,A].
[A,B,32|U]+[B,A,32|Y]:-U+Y,!.
[A|U]+[A|Y]:-U+Y.

Попробуйте онлайн!

объяснение

Сначала мы определим базовый случай:

p([A,B],[B,A]).

Это означает, что последние две буквы всегда будут поменяны местами.

Затем мы определяем, что произойдет, если мы будем рядом с пробелом:

p([A,B,32|U],[B,A,32|Y]):-p(U,Y),!.

Две строки совпадают, если перед пробелом буквы перед пробелами поменялись местами, а остальные - если строки совпадают. Затем мы используем !для резки.

Наш последний случай - если мы не рядом с пробелом, первые две буквы должны совпадать.

p([A|U],[A|Y]):-p(U,Y).

Wolfram Language , 117 байт

StringReplace[RegularExpression["\\b[[:alpha:]]{2,}\\b"]:>StringDrop[StringInsert["$0",StringTake["$0",{-1}],-3],-1]]

Попробуйте онлайн!

Применяется к тестовым строкам.

StringReplace[
  RegularExpression["\\b[[:alpha:]]{2,}\\b"] :> 
   StringDrop[StringInsert["$0", StringTake["$0", {-1}], -3], -1]] /@
 {"Thansk", "Youer welcoem", "This is an apple", 
  "Flippign Lettesr Aroudn", "tHe oDd chALlEneg wiht swappde lettesR"} // Column

Thanks
Youre welcome
Thsi si na appel
Flipping Letters Around
teH odD chALlEnge with swapped letteRs

R , 111 51 41 байт

Предоставлено @Giuseppe, подходом регулярных выражений, который выбрасывает мой старый метод из воды.

cat(gsub("(.)(.)\\b",'\\2\\1',scan(,"")))

APL (Dyalog Classic) , 28 байтов

1↓∊((¯2↓⊢),2↑⌽)¨' '(,⊂⍨⊣=,)⍞

⎕MLи ⎕IOоба 1,

Попробуйте онлайн!

объяснение

• ... (,⊂⍨⊣=,) ... Разделить (сохраняя границы и добавляя границу к началу) ...
• ... ⍞ ... вход ...
• ... ' ' ... ... в местах
• ... ( ... )¨ ... Затем для каждого элемента этого:
  • ... , ... Объединить ...
  • ... (¯2↓⊢) ... ... каждый предмет, кроме двух последних ...
  • ... 2↑⌽ ... ... с обратной стороны двух последних элементов.
• 1↓∊ ... Наконец, верните все, кроме первого элемента сглаженного результата.

Фанки , 34 байта

s=>s::gsub("(.)(.)( |$)","$2$1$3")

Попробуйте онлайн!

Haskell , 45 байт

-2 байта благодаря H.PWiz.

(r.g.r=<<).words
g(x:y:z)=' ':y:x:z
r=reverse

Попробуйте онлайн!

J , 20 19 11 байт

Кредит @Bolce Bussiere

1&A.&.>&.;:

Попробуйте онлайн!

       &.;:      on words
    &.>          on each
  A.             apply the permutation
1&               number 1, swap the last two elements

Алиса , 24 байта

/0RR'.%$1\' o
\ix*o ne@/

Попробуйте онлайн!

объяснение

/...\' o
\.../

Это формирует цикл, в котором тело цикла представляет собой линейный ординальный фрагмент, и мы выполняем ' oв кардинальном режиме между каждыми двумя итерациями цикла. Последний просто печатает пробел.

Развернув зигзагообразную структуру ординального кода, тело линейного цикла выглядит следующим образом:

iR*' %e10xRo.n$@

Разбивая это:

i     Read all input. On subsequent iterations, this will push an empty string.
R     Reverse.
*     Join. On the first iteration, this joins the input to an implicit empty string,
      which does nothing. On subsequent iterations, it will join the empty string to
      the word on top of the string, thereby getting rid of the empty string.
' %   Split around spaces. On the first iteration, this will split the input
      into individual words. On subsequent iterations, this does nothing.
e10   Push "10".
x     Use this to permute the (reversed) word on top of the stack. In
      particular, the word is rearranged with the same permutation that is
      required to sort the string "10", which means the first two letters
      get swapped (which correspond to the last two letters of the actual
      word).
R     Reverse the swapped word.
o     Print it.
.n$@  If there are no words left on the stack, terminate the program.

бред , 109 100 байт

Изменить: не нужно обрабатывать слова одной буквы

,[>++++[-<-------->],]>+[-<[>++++[<++++++++>-]<[->>+<<]<]<<[->>+<<]>[[-<+>]>]<<[>+>+>]-<]>>>>>>>[.>]

Попробуйте онлайн!

Печать пробела

Как это работает

,[>++++[-<-------->],] Puts input on the tape and subtracts 32 from each character
                       This separates each word

>+[- Start the loop
   <[>++++[<++++++++>-]<[->>+<<]<] Add 32 to each letter of the word
                                   Skip this on the first iteration for the last word

   <<[->>+<<]>[[-<+>]>] Swaps the last two letters of the word
   <<[>+>+>]- If there is another word to the left continue loop
              Also set up to add a space to the end of the word
 <] End loop
 >>>>>>>[.>] Print the modified string

Предыдущая версия, 109 байт

,[>++++[-<-------->],]>+[-<[>++++[<++++++++>-]<[->>+<<]<]<<[[->>+<<]>[[-<+>]>]<<[<]]>[>]<[>+>+>]-<]>>>>>>[.>]

Попробуйте онлайн!

QuadR , 8 байт

..\b
⌽⍵M

Попробуйте онлайн!

PHP , 119 107 байт

Редактировать: благодаря полностью человеку

<?php foreach(explode(" ",trim(fgets(STDIN)))as$w)echo substr($w,0,strlen($w)-2).strrev(substr($w,-2))," ";

Попробуйте онлайн!

Haskell , 41 байт

foldr(%)" "
a%(b:' ':r)=b:a:' ':r
a%s=a:s

Попробуйте онлайн!

Выходы с завершающим пробелом.

Повторное ' ':rвыглядит расточительным. Но a%(b:t@(' ':r))=b:a:tтакой же длины и a%(b:t)|' ':_<-t=b:a:tна один байт длиннее.

Haskell , 41 байт

f(a:b:t)|t<"A"=b:a:f t|1>0=a:f(b:t)
f e=e

Попробуйте онлайн!

sed , 20 17 + 1 (-r) = 18 байт

s/(.)(.)\b/\2\1/g

Попробуйте онлайн!

PHP, 65 байт

требует PHP 7.1 (или позже)

for(;$s=$argv[++$i];$s[-1]=$s[-2],$s[-2]=$c,print"$s ")$c=$s[-1];

принимает предложение в качестве отдельных аргументов командной строки. Беги с -nr.

работая над одной строкой, 77 + 1 байт :

foreach(explode(" ",$argn)as$s){$c=$s[-1];$s[-1]=$s[-2];$s[-2]=$c;echo"$s ";}

Беги как труба с -nR.

... или попробуйте их онлайн .

Java 8, 35 байт

s->s.replaceAll("(.)(.)\\b","$2$1")

Порт из @TaylorScott Google Sheets отвечает , после того, как я забил два байта. РЕДАКТИРОВАТЬ: я вижу, что теперь это порт ответа Neil Retina после моих двух байтов в гольф.

Объяснение:

Попробуйте онлайн.

s->                           // Method with String as both parameter and return-type
   s.replaceAll("(.)(.)       //  Replace any two characters,
                       \\b",  //  with a word-boundary after it (space or end of String)
                "$2$1")       //  With the two characters swapped

Google Sheets, 33 байта

Функция анонимного рабочего листа, которая принимает входные данные из ячейки A1и выводит их в вызывающую ячейку

=RegExReplace(A1,"(.)(.)\b","$2$1

-2 байта Спасибо @KevinCruijssen за использование (.)более(\w)

JavaScript (Node.js) , 38 36 32 байта

s => s.replace (/ (.) (.) (| $) / г, "$ 2 $ 1") 

s=>s.replace(/(.)(.)\b/g,"$2$1")

Попробуйте онлайн!

RegExp подход любезно @Giuseppe (хотя я думал об этом независимо), предполагая, что слова разделены только одним пробелом

-2 только за 1 пробел и добавление пробела

-4 Спасибо @Shaggy

K (ок) , 23 22 байта

" "/{x@prm[!#x]1}'" "\

Попробуйте онлайн!

Пример:

" "/{x@prm[!#x]1}'" "\"Hello World"
"Helol Wordl"

Объяснение:

Порт решения FrownyFrog для сохранения 1 байта .

Я вернусь к этому.

" "/{prm[x]1}'" "\ / the solution
              " "\ / split input on " "
    {       }'     / apply lambda to each
     prm[x]        / permute input x
           1       / and take the 2nd result
" "/               / join with " "

Предыдущее решение:

• " "/-2{(x_y),|x#y}'" "\ 23 байта

05AB1E , 7 байтов

#vy`sðJ

Попробуйте онлайн!

-1 благодаря волшебной урне осьминога .

Печать одного пробела

Желе , 10 байт

ḲṪ,¥\€Ḋ€UK

Попробуйте онлайн!

СНОБОЛ4 (CSNOBOL4) , 136 119 байт

	I =INPUT
B	I SPAN(&LCASE &UCASE) . Y ARBNO(' ') =:F(O)
	Y RPOS(2) REM . Z =REVERSE(Z)
	O =O Y ' '	:(B)
O	OUTPUT =O
END

Попробуйте онлайн!

Печатает с пробелом. Вы знаете, что сделали что-то не так, когда язык является обратным для StriNg Oriented и symBOlic Language, а ваш код длиннее, чем Brain-Flak :( теперь он немного лучше.

Строка Bберется Iи заменяется (alphabetic characters saved as Y)(some number of spaces)пустой строкой.

Следующая строка извлекает последние 2 символов , Yкак Zи заменяет их в Zобратном, а в следующей строке Сцепляет O, Yи один символ пробела.

Наконец, он печатает, когда Iбольше не соответствует требуемому шаблону в строке B.

Perl 5 , 19 + 1 ( -p) = 20 байт

s/(\w)(\w)\b/$2$1/g

Попробуйте онлайн!