Створіть програму, яка бере слово, яке ви вводите, і додає це слово на звороті за мінусом першої літери, а потім повторюється, поки всі літери не зникнуть. Наприклад, 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 байт через новий формат IO (список слів замість пробілів, розділених пробілом)

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

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

Спробуйте в Інтернеті!

Це єдина регламентація. По-перше, він відповідає всім меж слів або символам, що не містять пробілів:

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

ТІО

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

Спробуйте в Інтернеті!

Атрибуція

Постійна колекція Esolang у мозку була використана для початкового космічного навантаження.

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починається запис макросу b :
   • 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 (oK) , 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;}

Спробуйте в Інтернеті!

Це моє перше подання, і я не знав, чи повертається рядок замість друку, це нормально :)

Стакс , 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 (oK) , 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")

Лист звичайний , 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()наприкінці з протилежної причини.