Stwórz program, który pobiera wpisane słowo i dodaje to słowo z tyłu samego siebie minus pierwszą literę, a następnie powtarza, aż znikną wszystkie litery. Na przykład catstałby się catatti hellostałby się helloellolloloo.

Wpisz
dowolną z 26 liter alfabetu angielskiego. Może istnieć wiele słów oddzielonych spacjami, a zmianę należy zastosować do każdego słowa.

Wyjście
Wprowadzone słowo (a), z każdym słowem umieszczonym po sobie z brakującą pierwszą literą, a następnie z brakującą drugą literą i tak dalej, dopóki nie będzie więcej liter do dodania.

Więcej przykładów:

ill eel wyjścia illlll eelell

laser bat wyjścia laserasersererr batatt

darth vader wyjścia dartharthrththh vaderaderdererr

To jest kod golfowy, więc wygrywa najkrótszy kod.

Wyjaśnienie:
Możesz traktować dane wejściowe lub wyjściowe jako listę. Możesz rozdzielić słowa używając znaku nowej linii zamiast spacji. Możesz dodać końcową spację do wejścia.

Japt -m, 6 3 bajty

Wejście i wyjście to tablice słów.

£sY

Spróbuj

Wyjaśnienie

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

pieprzenie mózgu , 60 56 bajtów

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

Wypróbuj online!

Wymaga spacji końcowej i drukuje spację wiodącą. Oba można obejść, ale kończy się to na 112 bajtach .

Wyjaśnienie

,[  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 bajtów

map$concat.scanr(:)""

Wypróbuj online!

Edycja: -15 bajtów, z powodu nowego formatu IO (lista słów zamiast słów oddzielonych spacją)

Perl -p, 36 25 23 bajtów

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

Wypróbuj online!

To jest pojedynczy regsub. Po pierwsze, pasuje do wszystkich granic słów lub znaków spacji:

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

Pamiętaj, że każde z tych dopasowań należy zastąpić resztą słowa:

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

Możemy to osiągnąć za pomocą specjalnej zmiennej $', która przechowuje część łańcucha po dopasowaniu. Musimy jednak zastosować do niego zagnieżdżony regsub s/ .*//, który usuwa wszystko poza pierwszą spacją $', aby pozbyć się pozostałych słów na wejściu.

Dzięki @nwellnhof za 2 bajty.

Python 3 , 49 bajtów

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

Wypróbuj online!

Wykorzystuje to fakt, że "".split()zwraca pustą tablicę, co działa jak sprawdzanie przypadku podstawowego w rekurencji.

Galaretka , 3 bajty

ḊƬ€

Wypróbuj online!

Nie potrzebuję Kjuż s, ponieważ wejście / wyjście z tablicy jest teraz dozwolone.

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

APL (Dyalog), 19 9 bajtów

{⌽∊,\⌽⍵}¨

dzięki @ H.PWiz za jogging mój mózg

Działa to, ponieważ wszystkie ciągi w APL są tablicami znaków.

{⌽∊,\⌽⍵}¨ 
        ¨ - 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 bajty

Zapisano 1 bajt dzięki @ShieruAsakoto

Format I / O: tablica słów.

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

Wypróbuj online!

JavaScript (ES6), 35 bajtów

Format I / O: tablica słów.

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

Wypróbuj online!

R , 82 75 67 bajtów

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

Wypróbuj online!

Kilka bajtów zaoszczędzonych dzięki JayCe

Oddziela dane wyjściowe od nowych linii.

sapply(...)Ekspresji generuje wektor osnowy / kolumnę odpowiedniego podciągów wyściółkę ze ""w razie potrzeby. writenastępnie drukuje elementy macierzy, yw linii, oddzielając je "".

pieprzenie mózgu , 94 93 bajty

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

Wypróbuj online!

• Oszczędność jednego bajtu dzięki Nitrodon - gra .[-]>[.>]<[<]>w golfa [.>]<[<]>[-]>.

Wyjaśnienie

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

Wypróbuj online!

Przypisanie

Do początkowego obciążenia przestrzeni wykorzystano ciągłą kolekcję Esolanga .

05AB1E , 5 bajtów

€.síJ

Wypróbuj online!

Wyjaśnienie

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

Vim , 47 bajtów (38 naciśnięć klawiszy)

Zacznij od wprowadzenia jako jedynej linii w buforze Vima.

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

Wyjaśnienie

To umieszcza każde słowo w osobnej linii, iteruje każdą linię, a następnie łączy je wszystkie. Łamie się, jeśli słowa są dłuższe niż 99 znaków lub jeśli dane wejściowe zawierają więcej niż 99 słów.

1. :s/<Space>/\r/g<CR> zamienia spacje na nowe linie ( \r)
2. gg ustawia kursor na początku pierwszego wiersza
3. qarozpoczyna rejestrowanie makra a :
   • yw szarpnie resztę słowa
   • P umieszcza go za kursorem
   • lx usuwa pierwszą literę tego ostatniego słowa
   • qzatrzymuje rejestrowanie makra a
4. qbrozpoczyna rejestrowanie makra b :
   • 99@awykonuje makro a dziewięćdziesiąt dziewięć razy (wprowadza limit znaków)
   • j0 ustawia kursor na początku następnego wiersza
   • qzatrzymuje rejestrowanie makra b
5. 99@bwykonuje makro b dziewięćdziesiąt dziewięć razy (wprowadza limit słów)
6. gg ustawia kursor w pierwszym wierszu
7. 99J łączy następujące dziewięćdziesiąt dziewięć linii ze spacjami (ponownie limit słów)

Dla kolejnych 2 bajtów (2 naciśnięcia klawiszy) możesz zwiększyć limit słów do 999. Kolejne 4 bajty, 9999 itd.

Łuska , 6 4 bajtów

^{-2 bajty dzięki Jonathanowi Allanowi (przyjmuje dane jako listę)!}

moΣṫ

Wypróbuj online!

Wyjaśnienie

Pobiera dane wejściowe jako listę ciągów i odwzorowuje następującą funkcję:

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

Retina 0.8.2 , 15 bajtów

 
¶
.
$&$%'
¶
 

Wypróbuj online! Uwaga: końcowe spacje. Wyjaśnienie:

 
¶

Podziel na spacje.

.
$&$%'

Dołącz sufiks do każdej litery. Te %środki, które możemy dostać tylko przyrostek tego sformułowania.

¶
 

Połącz ze spacjami.

Pepe , 167 153 bajtów

REEerEeeEeeeeeRrEEEEerEEEEEeerEErEEeerreErEEeErreEREEEEEEEreereErEerEEEErEEeerrEEreRRErEEEEreREEreeereReeRerEEEEEErEEEeerreEerEEeerEEEEerEEeEreereErEeree

Wypróbuj online!

16-bitowy kod zestawu x86, 24 bajty

     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

Wywołaj si = wskaźnik do łańcucha źródłowego, di = wskaźnik do bufora wyjściowego.
Łańcuch źródłowy wymaga zerowego bajtu, aby go zakończyć.
Kod jest taki sam w 16-, 32- lub 64-bitowym (si / di stają się albo esi / edi albo rsi / rdi).
Kod 32-bitowy jest o dwa bajty większy z powodu rozszerzonego wywołania.
Kod 64-bitowy jest wciąż o trzy bajty większy, ponieważ inc / dec rsi / rdi przyciąga prefiks (ale jeśli wiadomo, że znajdują się w 32-bitowej przestrzeni pamięci, mogą być ponownie esi / edi, aby uniknąć tej kary) .

MATL , 18 16 bajtów

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

Dane wejściowe to tablica słów. Wypróbuj online!

Wyjaśnienie

"         % 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 bajtów

Rozwiązanie:

,/'(1_)\'

Wypróbuj online!

Wyjaśnienie:

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

C ++ (clang) , 174 bajty

#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;}

Wypróbuj online!

To moje pierwsze zgłoszenie i nie wiedziałem, czy zwracanie ciągu zamiast drukowania jest w porządku :)

Stax , 3 bajty

m|]

Uruchom i debuguj

Wyjaśnienie:

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

Węgiel drzewny , 14 bajtów

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

Wypróbuj online! Uwaga: końcowe miejsce. Link jest do pełnej wersji kodu. Wyjaśnienie:

   Ｓ            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 bajtów

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

Wypróbuj online!

Pip -s , 11 bajtów

J_@>,#_Mq^s

Pobiera rozdzieloną spacją listę słów ze standardowego wejścia. Wypróbuj online!

Wyjaśnienie

             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

Rubin , 42 bajty

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

Wypróbuj online!

Python 2 , 63 bajty

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

Wypróbuj online!

Płótno , 6 bajtów

±［±］⇵］

Wypróbuj tutaj!

5 bajtów z szalonym formatem wyjściowym

C #, 111 90 bajtów

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

Wypróbuj online!

Zmieniając dane wejściowe i wyjściowe na tablice, zapisałem kilka bajtów:

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

Wypróbuj online!

K (oK) , 17 13 bajtów

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

Wypróbuj online!

Funkcja anonimowego prefiksu; Dane wejściowe są traktowane jako lista ciągów, które z kolei są listami znaków.

Dzięki @streetster za 4 bajty.

W jaki sposób:

{,/|:'|,\|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 bajtów

(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)))))

Wypróbuj online!

To moja pierwsza próba gry w golfa. Wszelkie modyfikacje są mile widziane

Lua , 70 bajtów

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

Wypróbuj online!

Wyjaśnienie

Argumenty w Lua są przechowywane w tabeli argpocząwszy od indeksu 1. Operator jednoargumentowy #zwraca rozmiar tabeli, a funkcja s:sub(a,b)zwraca podłańcuch oparty na ciągu sograniczonym liczbami całkowitymi, aa bjeśli b nie zostanie przekazane, zwróci resztę ciągu.

Musiałem użyć io.write()zamiast, print()aby uniknąć łamania linii, i dodałem print()na końcu z przeciwnego powodu.