Erstellen Sie ein Programm, das das eingegebene Wort aufnimmt und dieses Wort minus dem Anfangsbuchstaben auf die Rückseite setzt. Wiederholen Sie das Programm, bis alle Buchstaben verschwunden sind. Zum Beispiel catwürde werden catatt, und hellowürde werden helloellolloloo.

Eingabe
Beliebiger der 26 Buchstaben des englischen Alphabets. Es kann mehrere Wörter geben, die durch Leerzeichen voneinander getrennt sind, und die Änderung sollte auf jedes Wort angewendet werden.

Ausgabe
Das / die eingegebene (n) Wort (e), wobei jedes Wort nach dem ersten Buchstaben fehlt und dann der zweite Buchstabe fehlt und so weiter, bis keine Buchstaben mehr hinzugefügt werden müssen.

Mehr Beispiele:

ill eel Ausgänge illlll eelell

laser bat Ausgänge laserasersererr batatt

darth vader Ausgänge dartharthrththh vaderaderdererr

Dies ist Codegolf, also gewinnt der kürzeste Code.

Erläuterung:
Sie können die Eingabe oder Ausgabe als Liste behandeln. Sie können Wörter mit Zeilenvorschub anstelle von Leerzeichen trennen. Sie können der Eingabe ein Leerzeichen hinzufügen.

Japt -m, 6 3 Bytes

Eingabe und Ausgabe sind Arrays von Wörtern.

£sY

Versuch es

Erläuterung

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

Brainfuck , 60 56 Bytes

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

Probieren Sie es online!

Benötigt ein nachfolgendes Leerzeichen und druckt ein führendes Leerzeichen. Beide könnten umgangen werden, aber das ergibt 112 Bytes .

Erläuterung

,[  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 Bytes

map$concat.scanr(:)""

Probieren Sie es online!

Edit: -15 Bytes, aufgrund des neuen E / A-Formats (Liste der Wörter anstelle von durch Leerzeichen getrennten Wörtern)

Perl -p, 36 25 23 Bytes

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

Probieren Sie es online!

Dies ist eine einzelne Regsub. Zunächst werden alle Wortgrenzen oder Nicht-Leerzeichen abgeglichen:

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

Beachten Sie, dass jede dieser Übereinstimmungen durch den Rest des Wortes ersetzt werden sollte:

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

Dies können wir mit der speziellen Variablen erreichen $', die den Teil des Strings nach dem Match speichert. Wir müssen jedoch das verschachtelte regsub darauf anwenden s/ .*//, wodurch alles nach dem ersten Leerzeichen in entfernt wird $', um die verbleibenden Wörter in der Eingabe zu entfernen .

Danke an @nwellnhof für 2 Bytes.

Python 3 , 49 Bytes

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

Probieren Sie es online!

Dies macht sich die Tatsache zunutze, dass "".split()ein leeres Array zurückgegeben wird, das als Prüfung für den Basisfall in der Rekursion dient.

Gelee , 3 Bytes

ḊƬ€

Probieren Sie es online!

Benötigen Sie das Ks nicht mehr, da Array-Ein- / Ausgabe jetzt zulässig ist.

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

APL (Dyalog), 19 9 Bytes

{⌽∊,\⌽⍵}¨

Danke an @ H.PWiz für das Joggen meines Gehirns

Dies funktioniert, weil alle Zeichenfolgen in APL Zeichenarrays sind.

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

1 Byte dank @ShieruAsakoto gespeichert

E / A-Format: Array von Wörtern.

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

Probieren Sie es online!

JavaScript (ES6), 35 Byte

E / A-Format: Array von Wörtern.

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

Probieren Sie es online!

R , 82 75 67 Bytes

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

Probieren Sie es online!

Dank JayCe konnten mehrere Bytes eingespart werden

Trennt die Ausgabe mit Zeilenumbrüchen.

Der sapply(...)Ausdruck generiert einen Matrix- / Spaltenvektor der entsprechenden Teilzeichenfolgen und füllt diese ""nach Bedarf auf. writedruckt dann die Elemente der Matrix yzeilenweise aus und trennt sie mit "".

Brainfuck , 94 93 Bytes

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

Probieren Sie es online!

• 1 Byte gespart dank Nitrodon - Golfen .[-]>[.>]<[<]>bis [.>]<[<]>[-]>.

Erläuterung

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

Probieren Sie es online!

Zuschreibung

Esolangs Brainfuck-Konstantensammlung wurde für die anfängliche Raumbelastung verwendet.

05AB1E , 5 Bytes

€.síJ

Probieren Sie es online!

Erläuterung

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

Vim , 47 Bytes (38 Tastenanschläge)

Beginnen Sie mit Ihrer Eingabe als einzige Zeile in einem Vim-Puffer.

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

Erläuterung

Dies setzt jedes Wort in eine eigene Zeile, iteriert über jede Zeile und verbindet sie dann wieder alle. Bricht ab, wenn Wörter länger als 99 Zeichen sind oder wenn Ihre Eingabe mehr als 99 Wörter enthält.

1. :s/<Space>/\r/g<CR> ersetzt Leerzeichen durch neue Zeilen (\r )
2. gg positioniert den Cursor am Anfang der ersten Zeile
3. qabeginnt mit der Aufnahme von Makro a :
   • yw reißt den Rest des Wortes
   • P setzt es hinter den Cursor
   • lx Entfernt den ersten Buchstaben des letzten Wortes
   • qstoppt die Aufzeichnung von Makro a
4. qbbeginnt mit der Aufnahme von Makro b :
   • 99@aMakro führt eine neunundneunzig mal (führt die Zeichengrenze)
   • j0 positioniert den Cursor am Anfang der nächsten Zeile
   • qstoppt die Makroaufnahme b
5. 99@bMakro ausführt b neunundneunzig Zeiten (führt die Wortgrenze)
6. gg positioniert den Cursor in der ersten Zeile
7. 99J Verbindet die folgenden neunundneunzig Zeilen mit Leerzeichen (wieder Wortbegrenzung)

Für weitere 2 Bytes (2 Tastenanschläge) können Sie das Wortlimit auf 999 verlängern. Weitere 4 Bytes, 9999 usw.

Schale , 6 4 Bytes

^{-2 Bytes dank Jonathan Allan (Eingabe als Liste)!}

moΣṫ

Probieren Sie es online!

Erläuterung

Übernimmt die Eingabe als Liste von Zeichenfolgen und ordnet die folgende Funktion zu:

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

Retina 0.8.2 , 15 Bytes

 
¶
.
$&$%'
¶
 

Probieren Sie es online! Hinweis: Leerzeichen am Ende. Erläuterung:

 
¶

Auf Leerzeichen aufteilen.

.
$&$%'

Fügen Sie jedem Buchstaben das Suffix hinzu. Das %bedeutet, dass wir nur das Suffix des Wortes erhalten.

¶
 

Mit Leerzeichen verbinden.

Pepe , 167 153 Bytes

REEerEeeEeeeeeRrEEEEerEEEEEeerEErEEeerreErEEeErreEREEEEEEEreereErEerEEEErEEeerrEEreRRErEEEEreREEreeereReeRerEEEEEErEEEeerreEerEEeerEEEEerEEeEreereErEeree

Probieren Sie es online!

16-Bit-x86-Assemblycode, 24 Byte

     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

Aufruf mit si = Zeiger auf Quelltext, di = Zeiger auf Ausgabepuffer.
Die Quellzeichenfolge benötigt zum Beenden ein Null-Byte.
Der Code ist derselbe in 16- oder 32- oder 64-Bit (si / di wird entweder zu esi / edi oder rsi / rdi).
Der 32-Bit-Code ist aufgrund des erweiterten Aufrufs zwei Byte größer.
64-Bit-Code ist immer noch drei Bytes größer, da das Inc / Dec von RSI / RDI ein Präfix anzieht (wenn jedoch bekannt ist, dass sie sich innerhalb des 32-Bit-Speicherbereichs befinden, können sie erneut esi / edi sein, um diese Strafe zu vermeiden). .

MATL , 18 16 Bytes

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

Die Eingabe ist ein Zellenarray von Wörtern. Probieren Sie es online!

Erläuterung

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

Lösung:

,/'(1_)\'

Probieren Sie es online!

Erläuterung:

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

C ++ (clang) , 174 Bytes

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

Probieren Sie es online!

Es ist meine erste Einreichung, und ich wusste nicht, ob es in Ordnung ist, einen String zurückzugeben, anstatt ihn zu drucken :)

Stax , 3 Bytes

m|]

Führen Sie es aus und debuggen Sie es

Erläuterung:

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

Holzkohle , 14 Bytes

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

Probieren Sie es online! Hinweis: Leerzeichen am Ende. Link ist eine ausführliche Version des Codes. Erläuterung:

   Ｓ            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 Bytes

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

Probieren Sie es online!

Pip -s , 11 Bytes

J_@>,#_Mq^s

Nimmt die durch Leerzeichen getrennte Liste der Wörter von stdin. Probieren Sie es online!

Erläuterung

             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

Ruby , 42 Bytes

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

Probieren Sie es online!

Python 2 , 63 Bytes

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

Probieren Sie es online!

Canvas , 6 Bytes

±［±］⇵］

Probieren Sie es hier aus!

5 Bytes mit einem verrückten Ausgabeformat

C #, 111 90 Bytes

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

Probieren Sie es online!

Durch Ändern der Eingabe und Ausgabe in Arrays habe ich ein paar Bytes gespart:

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

Probieren Sie es online!

K (oK) , 17 13 Bytes

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

Probieren Sie es online!

Präfix anonyme Funktion; Die Eingabe erfolgt als Liste von Zeichenfolgen, bei denen es sich wiederum um Zeichenlisten handelt.

Danke @streetster für 4 Bytes.

Wie:

{,/|:'|,\|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 Bytes

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

Probieren Sie es online!

Dies ist mein erster Versuch, Golf zu spielen. Änderungen sind willkommen

Lua , 70 Bytes

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

Probieren Sie es online!

Erläuterung

Die Argumente in Lua sind in der Tabelle gespeichert argbei Index beginnend 1. Die unärer Operator #gibt die Größe der Tabelle und Funktion s:sub(a,b)gibt eine Teilzeichenfolge basierend auf sabgegrenzt durch ganze Zahlen aund b, falls B nicht bestanden wird den Rest des Strings zurück.

Ich hatte zu verwenden , io.write()anstatt print()zu vermeiden Zeilenumbrüche und fügte print()am Ende für den entgegengesetzten Grund.