Helloellolloloo Worldorldrldldd

Question

Make a program that takes the word you input, and adds that word to the back of itself minus its first letter, then repeats until all letters are gone. For example, cat would become catatt, and hello would become helloellolloloo.

Input
Any of the 26 letters of the English alphabet. There may be multiple words separated by spaces, and the change should be applied to every word.

Output
The word(s) inputted, with each word put after itself with its first letter missing, and then with its second letter missing, and so on until there are no more letters to add.

More examples:

ill eel outputs illlll eelell

laser bat outputs laserasersererr batatt

darth vader outputs dartharthrththh vaderaderdererr

This is code golf, so the shortest code wins.

Clarification:
You can treat the input or output as a list. You can separate words using newline instead of space. You can add a trailing space to the input.

Answer 1

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

Try it online!

Answer 2

Ruby, 42 bytes

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

Try it online!

Answer 3

JavaScript (Node.js), 33 bytes

s=>s.replace(/\B(?=(\S+))/g,"$1")

Try it online!

I don't really know JavaScript, but I just copied Arnauld's syntax with an idea I had for the regex substitution :P

Answer 4

Powershell, 29 23 bytes

Port of Javascript by @Arnauld

$args-replace'.',"$&$'"

Input and output are a list of word. Test script:

$f = {

$args-replace'.',"$&$'"

}

@(
    ,('illlll eelell', 'ill','eel')
    ,('laserasersererr batatt', 'laser','bat')
    ,('dartharthrththh vaderaderdererr', 'darth','vader')
) | % {
    $e,$s = $_
    $r = &$f @s
    $r = "$r"
    "$($r-eq$e): $r"
}

Output:

True: illlll eelell
True: laserasersererr batatt
True: dartharthrththh vaderaderdererr

Answer 5

Scala, 97 bytes

Scala main that takes a single String argument containing all the words.

args(0).split(" ").foreach(x=>{for(i<-0 to x.length)print(x.substring(i,x.length));print(" ")})

Try it online!

Answer 6

Perl 6, 44 32 bytes

-12 bytes thanks to nwellnhof!

~*.words>>.&{[~] $_,{S/.//}...0}

Try it online!

An anonymous Whatever lambda that takes a string and returns a string.

Explanation:

 *.words   # Split the given word by spaces
        >>.&{                  }  # Map each word to
                           ...  # A list composed of
                 $_              # The initial string
                   ,{S/.//}      # Remove the first character
                              0  # Until it's empty
             [~]   # All joined together
~   # Convert the list to a string, which joins by spaces

Answer 7

Python3, 58 bytes

Takes a space-separated string of words from stdin and returns stdout likewise.

f=lambda x:x and x+f(x[1:])
print(*map(f,input().split()))

It works by splitting the string into a list of words and using map() to call the recursive function f on each element. Honestly, I don't know exactly how f works. When the stack reaches the end of the word, x becomes the empty string (''), so the and statement returns False, which I suspect acts as the base case to end recursion.

Here's the same idea but without the functional aspects:

def f(x):
    return x and x + f(x[1:])

print(*( f(word) for word in input().split() ))

Answer 8

Java (JDK 10), 90 bytes

s->{var r="";for(var x:s){for(int i=0;i<x.length();)r+=x.substring(i++);r+=" ";}return r;}

Try it online!

Credits

• -11 bytes thanks to Kevin Cruijssen, notifying me of the rule change about the input.

Answer 9

Python3, 86 bytes

Reduced a lot, thanks to @ElPedro and @manatwork

def f(a):return a+f(a[1:])if''<a else'' 
for x in input().split():print(f(x),end=' ')

P.S. I tried removing split but then nothing is printing, its probably required in python3

Answer 10

Attache, 28 bytes

Join&sp##Sum@Suffixes=>Split

Try it online!

Alternatives

ReplaceF&(Sum@Suffixes)&/"\\w+"               ?? 31 bytes
ReplaceF«_,/"\\w+",Sum@Suffixes»              ?? 34 bytes, 32 chars
ReplaceF<~_,/"\\w+",Sum@Suffixes~>            ?? 34 bytes

Explanation

Join&sp##Sum@Suffixes=>Split    input, e.g.: "abc defg"
                       Split    split the input on spaces
                                e.g.: ["abc", "defg"]
                     =>         on each word:
                                  e.g.: "abc"
             Suffixes             take the suffixes of that word
                                  e.g.: ["abc", "bc", "c"]
         Sum@                     join them together
                                  e.g.: "abcbcc"
       ##                       then
Join&                           join the result by:
     sp                           spaces

Answer 11

MathGolf, 6 bytes

ÆÅ_╞↑ 

Try it online!

Outputs a trailing space, though you can add another byte to remove this.

Hopefully 6 bytes when implicit input is implemented. Yay.

Explanation:

        Implicit input
Æ       Implicit for loop over the next 5 instructions
 Å  ↑   While true without popping (empty string is false)
  _╞    Duplicate the top of stack and remove the first letter
        (space) Append a space to the stack
        Implicitly output the stack joined together

Answer 12

q 78 38 bytes

" "sv{r::x;{x,r::1_r}/[count x;x]}each

Answer 13

Scala, 81 bytes

def e(s:List[String])=s.map(_.foldRight(("","")){(a,b)=>(a+b._1,a+b._1+b._2)}._2)

Try it online!

As per comments, this can receive and output a List[String]. This builds the output from right to left, starting with the rightmost letter, then prepending the two rightmost letters, and so on down the line.

Answer 14

Pascal (FPC), 129 bytes

var s:string;i,j:int32;begin read(s);repeat j:=Pos(' ',s);for i:=1to j do write(s[i..j-1]);write(' ');Delete(s,1,j)until s=''end.

Try it online!

Requires that the input ends in space, allowed in this comment.

Answer 15

Pyth, 8 6 bytes

m_s.__

_{Decreased byte(s?) thanks to @Steven H.}

Try it online! Input and output are a list.

Expalanation:

        - implicit output
m       - map function d:
      _ -   ...d reversed...
    ._  -   ...get all prefixes of it...
  _s    -   ...joined and reversed
        - ...over implicit Q (input)

Answer 16

Twig, 73 bytes

Creates a macro with the function f() that receives an array of words, displaying the words separated by new lines.

{%macro f(a)%}{%for v in a%}{%for i in 0..v|length%}{{v[i:]}}{%endfor%}
{%endfor%}{%endmacro%}

To use it, just import:

{% import 'macro.twig' as a %}

{{ a.f(['a','sentence','is','a','list','of','words']) }}

{# to pass a string, you can split it #}
{{ a.f('a sentence is a list of words'|split(' ')) }}

You can try it on https://twigfiddle.com/8xech1
Warning: due to the way that output is handled in the link, I was forced to add a simple period (.) at the end of the line. This is NOT needed for normal operation.

Answer 17

Brachylog, 7 bytes

{a₁ᶠc}ᵐ

Try it online!

Explanation

{    }ᵐ          Map for each word:
 a₁ᶠ               Find all suffixes
    c              Concatenate into a single string

Answer 18

Haskell, 24 bytes

This solution is not optimal in two ways: 1) the other Haskell answer by nimi is 3 bytes shorter and 2) the input is limited to 9223372036854775807 characters (~36 exabytes), though I think it's an interesting find:

map.mconcat$drop<$>[0..]

Try it online! (sets a limit of 255 characters for TIO would time out otherwise)

Explanation

Since drop has type Int -> [a] -> [a] it forces [0..] to be [0..9223372036854775807] which is finite and thus the program terminates (eventually).

And mconcat takes the list of [drop 0, drop 1..] and gives us a function String -> String which is equivalent to:

\str-> drop 0 str ++ drop 1 str ++ .. ++ drop 9223372036854775807 str

_{Note: Once the argument of drop is greater or equal to the length of str it just appends empty strings.}

Practical solution, 40 bytes

This won't take as long as the shorter solution but at a great cost of 16 bytes:

map$mconcat=<<map drop.zipWith pure[0..]

Try it online!

Answer 19

Burlesque, 8 bytes

{iS\[}ww

Try it online!

{
 iS # All suffixes
 \[ # Concatenate
}ww # For each word

Answer 20

APOL, 23 bytes

ƒ(s(i) j(ƒ(∋ V(⋒ ∈)))))

Explanation

ƒ(         List-builder for loop
  s(       String-split instruction (splits at spaces by default)
    i      Input
  )
  j(       String join instruction
    ƒ(     List-builder for loop
      ∋    For item (the current word being processed)
      V(   Substring instruction
        ⋒  For iterator (the thing the current for loop is iterating through, in this case the current word)
        ∈  For counter
      )
    )
  )
)

Answer 21

Mathematica (Wolfram Language): 71 Characters

(a=Characters@#;StringJoin@Array[a[[#;;]] &,Length@a])&/@StringSplit[#]&

TIO Link

There pretty much has to be a better solution than this, but it works.

Explanation:

Takes a string and splits on spaces/newlines/punctuation, then iterates over this list. Finds a list of characters of each "word", then uses the Array to take all the elements, then all but the first, and so on. Then, these are joined (taking advantage of the fact that StringJoin ignores nested lists) and the function moves to the next word.

Answer 22

C#, 193 166 bytes

class a{static void Main(string[]b){foreach(var c in b)d(c,0);}static void d(string c,int e){if(e==c.Length)Console.Write(" ");else{Console.Write(c[e++..]);d(c,e);}}}

Try it Online!

Since .NET automatically splits the arguments at spaces, it's possible to loop over them without splitting them manually.
Other than that, this uses recursion to subtract one character at a time using the overload of string.Substring that takes only 1 argument which is the index to start at.

Answer 23

C (gcc), 94 bytes

f(char*s){char*e=s+strlen(s),*i=s;for(;i<e;*i++=*i-32?*i:0);for(i=s;i<e;i++)printf(*i?i:" ");}

Try it online!

Saves a pointer to the end of the string in char *e, then replaces spaces with null characters, then prints the string starting with each character and ending at the next null character, but printing a space if the current character is a null character.

Answer 24

JavaScript (Node.js), 88 bytes

f=s=>s.split(' ').map(e=>[...e].map((_,i,a)=>a.slice(i,a.length).join``).join``).join` `

Try it online!

Answer 25

C (gcc), 64 bytes

f(s,t)char*s,*t;{for(;*s;t+=*s<33)for(strcpy(t,s++);*t&31;t++);}

Take two char* parameters: The first one for input, and the second one for output. The caller is responsible for malloc and free. Like most string functions in C, this one is designed to be vulnerable by overflow the buffer.

Try it online!

Answer 26

Gema, 24 characters

<L>=@x{$0}
x:?*=?*@x{$2}

Sample run:

bash-4.4$ gema '<L>=@x{$0};x:?*=?*@x{$2}' <<< 'darth vader'
dartharthrththh vaderaderdererr

Answer 27

Kotlin, 87 bytes

fun f(s:String):String=if(s=="")s else s.split(" ").joinToString(" "){it+f(it.drop(1))}

Answer 28

Python 2, 55 bytes

for x in input():
 y=""
 while x:y+=x;x=x[1:]
 print y,

Try it online!

Takes input as a list. output is separated by spaces.

Answer 29

Red, 67 66 bytes

func[s][foreach w split s" "[until[prin w take w tail? w]prin" "]]

Try it online!

Answer 30

Java, 131 bytes

char[]e(char[]a){int b=0,l=a.length,c,d=0;char[]n=new char[l*(l+1)/2];for(;b<l;b++){for(c=l-b;c>0;c--){n[d]=a[l-c];d++;}}return n;}

I know there is a better Java answer but, wanted to do it just with char arrays

char[] e(char[]a){
    int b=0,l=a.length,c,d=0;      //l to keep length, b for each iteration, c for each letter in iteration 
    char[] n= new char[l*(l+1)/2]; //Create new array with length based in triangular number sequence
    for(;b<l;b++) {
        for(c=l-b;c>0;c--) {
            n[d]=a[l-c];          //Fill it
            d++;                   //d keeps position in new array
        }
    }
    return n;
}