Создайте программу, которая берет слово, которое вы вводите, и добавляет это слово на обороте минус его первую букву, а затем повторяется до тех пор, пока все буквы не исчезнут. Например, catстало бы catatt, и helloстал бы helloellolloloo.

Введите
любую из 26 букв английского алфавита. Может быть несколько слов, разделенных пробелами, и изменение должно применяться к каждому слову.

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

Больше примеров:

ill eel выходы illlll eelell

laser bat выходы laserasersererr batatt

darth vader выходы dartharthrththh vaderaderdererr

Это код гольф, поэтому выигрывает самый короткий код.

Пояснение:
Вы можете рассматривать ввод или вывод как список. Вы можете разделить слова, используя новую строку вместо пробела. Вы можете добавить завершающий пробел для ввода.

Japt -m, 6 3 байта

Ввод и вывод - это массивы слов.

£sY

Попробуй

объяснение

        :For each word in the input array
£       :Map each letter at index Y
 sY     :  Slice the current word from index Y

брейкфук , 60 56 байт

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

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

Требуется завершающий пробел и печать начального пробела. Оба из них могут быть обойдены, но это заканчивается в 112 байтов .

объяснение

,[  Loop over each byte of input
  Tape: 32 w o r-32 d'
  >++++++++[-<----<++++>>]   Subtract 32 from the character and add 32 to the previous char
  Tape: 32 w o r d-32 0'
  <[>>]<   If the last character was a space
  Tape: 32 w o r d-32 0'
  or
  Tape: 32 w o r d' space-32
  [
    [<]>.   Move to the end of the word and print out the space
    [   Loop over each letter
      [-]    Remove the first letter (initially space)
      >[.>]  Print the rest of the word
      <[<]>  Move back to the first letter
    ]
    Tape: clear
  ]
,]  Get the next byte of input

Haskell, 36 21 байт

map$concat.scanr(:)""

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

Изменить: -15 байт из-за нового формата ввода-вывода (список слов вместо слов, разделенных пробелом)

Perl -p, 36 25 23 байта

s!\b|\S!$'=~s/ .*//r!eg

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

Это единственный regsub. Во-первых, он соответствует всем границам слов или непробельным символам:

[][H][e][l][l][o] [][W][o][r][l][d]

Обратите внимание, что каждое из этих совпадений должно быть заменено остальной частью слова:

[→Hello][H→ello][e→llo][l→lo][l→o][o→] (...)

Мы можем сделать это с помощью специальной переменной $', которая хранит часть строки после совпадения. Однако нам нужно применить к нему вложенную regsub s/ .*//, которая удаляет все, что находится за первым пробелом в $', чтобы избавиться от оставшихся слов во входных данных.

Спасибо @nwellnhof за 2 байта.

Python 3 , 49 байт

d=lambda s:' '.join(n+d(n[1:])for n in s.split())

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

Это использует тот факт, что "".split()возвращает пустой массив, чтобы он служил проверкой базового случая в рекурсии.

Желе , 3 байта

ḊƬ€

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

Больше не нужны Ks, так как теперь разрешен ввод / вывод массива.

ḊƬ€
  €   For each word:
Ḋ       Remove the first letter
 Ƭ      until there are none left.

APL (Dyalog), 19 9 байтов

{⌽∊,\⌽⍵}¨

спасибо @ H.PWiz за пробежку по мозгу

Это работает, потому что все строки в APL являются символьными массивами.

{⌽∊,\⌽⍵}¨ 
        ¨ - for each string
      ⍵} - string argument - ex. "hello"
     ⌽ - reverse - "olleh"
   ,\ - scan magic - "o" "ol" "oll" "olle" "olleh"
  ∊ - enlist(join together) "oolollolleolleh"
{⌽ - reverse - "helloellolloloo"

TIO

JavaScript (ES6), 33 байта

Сохранено 1 байт благодаря @ShieruAsakoto

Формат ввода / вывода: массив слов.

a=>a.map(g=w=>w&&w+g(w.slice(1)))

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

JavaScript (ES6), 35 байт

Формат ввода / вывода: массив слов.

a=>a.map(w=>w.replace(/./g,"$&$'"))

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

R , 82 75 67 байт

write(sapply(x<-scan(,""),substring,1:(y=max(nchar(x))),y),1,y,,"")

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

Несколько байтов сохранено благодаря JayCe

Разделяет вывод символами новой строки.

sapply(...)Выражение генерирует матрицу / вектор - столбец соответствующих подстрок, дополняя с по ""мере необходимости. writeзатем печатает элементы матрицы в yкаждой строке, разделяя их с помощью "".

брейкфук , 94 93 байта

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

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

• Сохраненный один байт благодаря Nitrodon - игра .[-]>[.>]<[<]>в гольф [.>]<[<]>[-]>.

объяснение

[[[ (dynamic) tape layout: ... NUL STR ... STR CHR FLG BUF SPC NUL ... ]]]

load a 32 into SPC
-[-[-<]>>+<]>-

while FLG
<<+[

 read a word
 [
  clear FLG; read CHR
  [-]<,
  copy CHR to BUF (using FLG as a temporary)
  [->+>+<<]>[-<+>]
  subtract SPC from BUF and save SPC
  >>[-<->>+<]
  move tape layout one to the right
  <
 ]

 strip trailing space; set FLG to true
 << [>>+<<[-]]
 to STR's first character
 <[<]>
 print word in all reduced forms
 [
  [.>]<[<]>[-]>
 ]

 print SPC; move to FLG
 >>>>.<<
]

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

приписывание

Константная коллекция Эзоланга использовалась для начальной космической нагрузки.

05AB1E , 5 байтов

€.síJ

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

объяснение

€.s        # push suffixes of each
   í       # reverse each
    J      # join suffixes

Vim , 47 байт (38 нажатий клавиш)

Начните с ввода в качестве единственной строки в буфере Vim.

:s/<Space>/\r/g<CR>ggqaywPlxqqb99@aj0q99@bgg99J

объяснение

Это помещает каждое слово в отдельную строку, перебирает каждую строку, а затем объединяет их все. Разрывы, если слова длиннее 99 символов или если ваш ввод содержит более 99 слов.

1. :s/<Space>/\r/g<CR> заменяет пробелы новыми строками ( \r)
2. gg позиционирует курсор в начале первой строки
3. qaначинает запись макроса A :
   • yw дергает остальное слово
   • P помещает его за курсор
   • lx удаляет первую букву последнего слова
   • qостанавливает запись макроса A
4. qbначинается запись макроса б :
   • 99@aвыполняет макрос девяносто девять раз (вводит ограничение на количество символов)
   • j0 позиционирует курсор в начале следующей строки
   • qостанавливает запись макроса b
5. 99@bвыполняет макрос b девяносто девять раз (вводит ограничение по слову)
6. gg позиционирует курсор на первой строке
7. 99J объединяет следующие девяносто девять строк с пробелами (снова ограничение по числу слов)

Для других 2 байтов (2 нажатия клавиш) вы можете расширить ограничение по словам до 999. Еще 4 байта, 9999 и т. Д.

Шелуха , 6 4 байта

^{-2 байта благодаря Джонатану Аллану (принимая входные данные в виде списка)!}

moΣṫ

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

объяснение

Принимает ввод как список строк и отображает следующую функцию:

Σṫ  -- example argument: "abc"
 ṫ  -- tails: ["abc","bc","c"]
Σ   -- concat: "abcbcc"

Сетчатка 0.8.2 , 15 байт

 
¶
.
$&$%'
¶
 

Попробуйте онлайн! Примечание: завершающие пробелы. Объяснение:

 
¶

Сплит на пространствах.

.
$&$%'

Добавьте его суффикс к каждой букве. Это %означает, что мы получаем только суффикс слова.

¶
 

Присоединяйтесь с пробелами.

Пепе , 167 153 байта

REEerEeeEeeeeeRrEEEEerEEEEEeerEErEEeerreErEEeErreEREEEEEEEreereErEerEEEErEEeerrEEreRRErEEEEreREEreeereReeRerEEEEEErEEEeerreEerEEeerEEEEerEEeEreereErEeree

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

16-битный код сборки x86, 24 байта

     47             inc    di
     B020           mov    al,20h
l1:  3806           cmp    [si],al
     7212           jb     l5 ;less means end of string
     7401           je     l2  ;equal means space was seen
     4F             dec    di ;overwrite extra space
l2:  E80300         call   l3
     46             inc    si ;move to next character in word
     75F1           jne    l1
l3:  56             push   si
l4:  3806           cmp    [si],al
     A4             movsb      ;copy character
     77FB           ja     l4  ;until either zero or space is seen
     5E             pop    si
l5:  C3             ret

Вызов с si = указатель на исходную строку, di = указатель на выходной буфер.
Исходная строка требует нулевого байта для ее завершения.
Код одинаков в 16-, 32- или 64-битном формате (si / di становится либо esi / edi, либо rsi / rdi).
32-битный код на два байта больше из-за расширенного вызова.
64-битный код еще на три байта больше, потому что inc / dec rsi / rdi привлекает префикс (но если известно, что они находятся в пределах 32-битного пространства памяти, то они могут быть снова esi / edi, чтобы избежать этого штрафа) ,

MATL , 18 16 байтов

"@gXH"HX@Jh)]0&h

Ввод представляет собой массив слов. Попробуйте онлайн!

объяснение

"         % Implicit input: cell array of strings. For each cell
  @g      %   Push content of current cell, that is, a word
  XH      %   Copy into clipboard H
  "       %   For each letter
    H     %     Push word
    X@    %     Push iteration index
    Jh)   %     Index from that until the end into current word
  ]       %   End
  0       %   Push 0. Will be cast to char. Char(0) is displayed as space
  &h      %   Concatenate horizontally all elements so far. Implicit display

K4 / K (ок) , 9 байт

Решение:

,/'(1_)\'

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

Объяснение:

,/'(1_)\' / the solution
        ' / apply to each
       \  / scan
   (  )   / do this together
    1_    / drop first
,/'       / flatten (,/) each (')

C ++ (лязг) , 174 байта

#include<map>
#include<string.h>
std::string r(std::string w){while(auto x=strchr(w.c_str(),32))return r(w.substr(0,x-w.c_str()))+" "+r(x+1);return w!=""?w+r(w.substr(1)):w;}

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

Это мое первое представление, и я не знаю, нормально ли возвращать строку вместо печати :)

Stax , 3 байта

m|]

Запустите и отладьте его

Объяснение:

m   Map over the lines
 |] Get all suffixes (suffices?)
    Implicit flatten and output

Древесный уголь , 14 байтов

⪫Ｅ⪪Ｓ ⭆ι✂ιμＬι¹ 

Попробуйте онлайн! Примечание: место в конце. Ссылка на подробную версию кода. Объяснение:

   Ｓ            Input string
  ⪪             Split on spaces
 Ｅ              Map over each word
      ι         Current word
     ⭆          Map over each character and join
        ι       Current word
         μ      Current index
           ι    Current word
          Ｌ     Length
            ¹   Literal 1
       ✂        Slice
⪫               Join with spaces
                Implicitly print

C (gcc) , 79 байтов

f(s,t)char*s,*t;{for(;*s;printf("%.*s",*s^32?t?t-s:~0:1,s),s++)t=strchr(s,32);}

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

Пип -s , 11 байт

J_@>,#_Mq^s

Принимает разделенный пробелами список слов из stdin. Попробуйте онлайн!

объяснение

             s is space (implicit)
        q    Read a line of stdin
         ^s  Split it on spaces
       M     Map this lambda function to each word:
 _            The word...
  @>          sliced starting at index...
    ,#_       range(len(word))
              This creates len(word) slices ["word" "ord" "rd" "d"]
J             Join those into a single string
             The resulting list of modified words is printed; the -s flag uses space
             as the separator

Рубин , 42 байта

->s{s.map{|a|(w=a.b).chars{a[0]='';w<<a}}}

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

Python 2 , 63 байта

lambda s:' '.join(map(g,s.split()))
g=lambda s:s and s+g(s[1:])

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

Холст , 6 байтов

±［±］⇵］

Попробуй это здесь!

5 байтов с сумасшедшим форматом вывода

C #, 111 90 байтов

b=>string.Join(" ",(b.Split(' ').Select(x=>string.Concat(x.Select((y, i)=>x.Substring(i))))))

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

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

b=>b.Select(x=>string.Concat(x.Select((y,i)=>x.Substring(i)))).ToArray()

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

K (ок) , 17 13 байт

{,/|:'|,\|x}'

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

Префикс анонимной функции; Ввод принимается как список строк, которые в свою очередь являются списками символов.

Спасибо @streetster за 4 байта.

Как:

{,/|:'|,\|x}' //Main function, argument x → ("ill";"eel")
            ' // For each element of the argument
         |x}  // Flip it. x → ("lli";"lee")
       ,\     // Concatenate each element, keeping intermediates. x → (("l";"ll";"lli");("l";"le";"lee")
      |       // Flip it again. x → (("lli";"ll";"l");("lee";"le";"l"))
   |:'        // Now flip each element. x → (("ill";"ll";"l");("eel";"el";"l"))
{,/           // Concatenation scan. x → ("illlll";"eelell")

Common Lisp , 179 байт

(defun r(s)(cond((endp s)nil)((eql(first s)#\Space)(princ " ")(r(rest s)))(t(q s)(r(rest s)))))(defun q (l)(cond((eql(first l)#\Space)t)((endp l)t)(t(princ(first l))(q(rest l)))))

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

Это моя первая попытка игры в гольф. Любые изменения приветствуются.

Луа , 70 байт

for i=1,#arg do x=arg[i]for i=1,#x do io.write(x:sub(i))end print()end

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

объяснение

Аргументы в Lua хранятся в таблице, argначиная с индекса 1. Унарный оператор #возвращает размер таблицы, а функция s:sub(a,b)возвращает подстроку на основе строки, sразделенной целыми числами, aи b, если b не передано, она возвращает остальную часть строки.

Я должен был использовать io.write()вместо того, print()чтобы избежать разрыва строки, и добавил print()в конце по противоположной причине.