[Question]
  [
I thought of a new way to generate my passwords, and even though it's probably not very clever in the long run, it could still make for a fun code-golf.
Taking a string of words, the password is generated thus:
* Pick the *nth* character in the *nth* word
* If *n* is larger than the word, continue counting backwards
Example:
```
This is a fun task!
T     s a  u      !
```
T is the first character  
s is the second  
a is the first, but going back and forth it is also the third  
u is the second but because of counting backwards it's also the fourth  
'!' is the fifth character in 'task!' and thus will be included in the final password, `Tsau!`
**Rules**
* Input will be a string
* Separate the string on spaces, all other characters must be included
* Uppercase letters must remain uppercase, same with lowercase
* You take *n* steps in each word, where *n* is the number of words that have come before plus one
* If *n* is larger than the word, you must step backwards through the word, if you hit the start, you go forward again until you have stepped *n* times
* The first and last character is only stepped once, so 'fun' on the seventh position as an example goes 'funufun' and ends on n, not 'funnuff' and ends on f
* Output must be a string
Examples:
```
Input              Output
Once Upon A Time   OpAe
There was a man    Taaa
Who made a task    Waak
That was neat!     Taa
This is a long string to display how the generator is supposed to work  Tsagnoyotoipto
```
The shortest code in bytes wins!
  
[Answer]
# [Python 2](https://docs.python.org/2/), 72 bytes
```
lambda s:''.join((-~i*(w+w[-2:0:-1]))[i]for i,w in enumerate(s.split()))
```
[Try it online!](https://tio.run/##bZCxTsNADIb3PIUjhtwBqaBjJIY@QZegDqWDIU5ybWKfchedsvDq4Q5R6IDlzZ8@@7ddfC@8XduXt3XA8b1BcFVRbM5iWKny09yr8BCO5bZ6qsrnk9ZHc2plAvMYwDAQzyNN6Em5jbOD8UprvdrJsIdWFXVvHMRGaGcGj@6SF/oOaodznv1Se/4geLXCsIPajJSQWHu7o@xGRRNBwCQbkX8YqBHxDzr0EocNRSYtu0IHxMutCf23iAl9fmWSKfvn8EG4A@fjoAMv0JgYExfoJYDvCTrilD99xIGbrRVHTQKDTHE/RHlM27Es4sVYkfUL "Python 2 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 11 bytes
```
#vyN©Fû}®è?
```
[Try it online!](https://tio.run/##MzBNTDJM/f9fuazS79BKt8O7aw@tO7zC/v//kIzMYgUgSlTIyc9LVyguKcoEUiX5CimZxQU5iZUKGfnlCiUZqQrpqXmpRYkl@UUg1cWlBQX5xakpIIXl@UXZAA "05AB1E – Try It Online")
**Explanation**
```
#             # split input on spaces
 vy           # for each word in input
   N©F        # N times do, where N is the current iteration
      û}      # palendromize the word
        ®è    # use N to index into the resulting word
          ?   # print
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 12 bytes
```
ḲJị"ŒBṖȯ$€$Ɗ
```
[Try it online!](https://tio.run/##y0rNyan8///hjk1eD3d3Kx2d5PRw57QT61UeNa1ROdb1////kIzMYgUgSlTIyc9LVyguKcoEUiX5CimZxQU5iZUKGfnlCiUZqQrpqXmpRYkl@UUg1cWlBQX5xakpIIXl@UXZAA "Jelly – Try It Online")
[Answer]
# Java 10, ~~148~~ ~~117~~ ~~114~~ 110 bytes
```
s->{int i=-1,j;for(var a:s.split(" "))System.out.print(a.charAt((j=a.length()-1)>0*i++?i/j%2<1?i%j:j-i%j:0));}
```
-31 bytes thanks to *@SamYonnou* by creating a port of [*@user71546*'s JavaScript answer](https://codegolf.stackexchange.com/a/165808/52210).  
-4 bytes thanks to *@SamYonnou* again, optimizing the algorithm for Java.
[Try it online.](https://tio.run/##hVJNTwIxEL37KwYSk1bdRTyyouHgUT2I8WA8jLsD22Vpm3YWJIbfjt0PFdHEpm3SZl7f67xX4AqjIlvs0hK9h1tU@v0IQGkmN8OU4K4@AqyMyiAVD@yUnoOXSbjdhhWmZ2SVwh1oGMPOR1fvAQ1qHA3PimRmnFihAxz52NtSsehDX8qHjWdaxqbi2IYXWWCc5ugmLEQxxrgkPedcyGgor85P1OnptRoUxxeXw2t1XIyKqN7PpUy2u6TVYKvXMmjopDRil@Ernd7nF0DZ/oPJBwnTXHkIE2FWaWD0i15fJgCDAdy8WUqZshFMPVa9PdC9Du14tEbDBKZqSQ0CDkD3dkI/iMgRrLGmWqL@hBwQIeIe5ik3oTajAKmV/Y15Qlz84EFuaDQh974gv3j@7EFpaktbZ9lApoJRuIHcrIFzgjlpcsjG1dW@stZ4yurCtXG1uiP4dxz2da7NxrBRlk2To@8UNdY1AruoKW0r7szTcSrac0t6mKJSiy6Y290H)
**Explanation:**
```
s->{                            // Method with String parameter and no return-type
  int i=-1,                     // Step integer, starting at -1
      j;                        // Temp integer
  for(var a:s.split(" "))       // Loop over the parts split by spaces
    System.out.print(           // Print:
     a.charAt((j=a.length()-1)  //  Set `j` to the the length of the part minus 1
               >0               //  If the length of the part is larger than 1 (`j` > 0)
                 *i++?          //  (and increase `i` by 1 in the process with `i++`)
                i/j%2<1?        //   If `i` integer-divided by `j` is even:
                 i%j            //    Print the character at index `i` modulo-`j`
                :               //   Else:
                 j-i%j          //    Print the character at index `j` minus `i` modulo-`j`
               :                //  Else:
                0));}           //   Print the first (and only) character
                                //   (the >0 check is added to prevent divided-by-0 errors)
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 16 bytes
```
⭆⪪Ｓ §⁺ι✂ι±²¦⁰±¹κ
```
[Try it online!](https://tio.run/##PYzBCsIwEETvfsXiaQsV1Ksnjz0ohfoDS7skoSEbkq3Vr4@pgrDMzgyPGS2lUciX0icXFAetz9wo4hC9U@xCXPRXYtPCHvZVr9qFiV/Y@yWja2HwbuTN3NmQMp4rc/ynU9PUPFe9lPKwLkM9Ai/BQP4ugwpMLkdPb7CygloGw4ETqaSNzkuMknnawFXSvCuHp/8A "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
  Ｓ                 Input string
 ⪪                  Split on spaces
⭆                   Map over words and join
      ι ι           Current word
       ✂ ±²¦⁰±¹     Slice backwards from 2nd last character to start exclusive
     ⁺              Concatenate
    §          κ    Cyclically index on current word index
                    Implicitly print
```
I don't often get to use Slice's last parameter.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 9 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
éñ~╗D¡┤Gq
```
[Run and debug it](https://staxlang.xyz/#p=82a47ebb44adb44771&i=Once+Upon+A+Time%0AThere+was+a+man%0AWho+made+a+task%0AThat+was+neat%21%0AThis+is+a+long+string+to+display+how+the+generator+is+supposed+to+work&a=1&m=2)
Unpacked, ungolfed, and commented, it looks like this.
```
j       split into words
{       start block for mapping
  cDrD  copy word; remove first and last character; reverse
  +     concatenate with original word
  i@    modularly (wrap-around) index using map iteration index
m       perform map
```
[Run this one](https://staxlang.xyz/#c=j+++++%09split+into+words%0A%7B+++++%09start+block+for+mapping%0A++cDrD%09copy+word%3B+remove+first+and+last+character%3B+reverse%0A++%2B+++%09concatenate+with+original+word%0A++i%40++%09modularly+%28wrap-around%29+index+using+map+iteration+index%0Am+++++%09perform+map&i=Once+Upon+A+Time%0AThere+was+a+man%0AWho+made+a+task%0AThat+was+neat%21%0AThis+is+a+long+string+to+display+how+the+generator+is+supposed+to+work&a=1&m=2)
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~78~~ ~~70~~ ~~69~~ 68 bytes
-1 byte @Arnauld
```
x=>x.split` `.map((y,i)=>y[a=i%(l=y.length-1)|0,i/l&1?l-a:a]).join``
```
[Try it online!](https://tio.run/##ddDBasMwDAbg@55CLWwk0HjrdSUde4JdMnYYg4hEid06krHdpYG9e@YUdhktCHTQxy@hA35jaLxxsWBpae7K@Vzuzyo4a2INtRrQZdm0MXm5nz6xNPeZLSdlifuoi23@87Qxj/Zh@2ILfMavXB3EcF3Pu0Y4iCVlpc@6bF1pEyAVQndiiBiOq3We7@7@uzduCN6dMLxCZQa6iipNnmDEJW5Avmo@tKRZS4ks227kYLzEMGFc3SB/d1vhHkL0JrUo0Jr0IpxAywhRE/TE5DGKX3Q4OSeB2gWO4i/b518 "JavaScript (Node.js) – Try It Online")
**Explanation**
```
x=>
 x.split` `                    // Split the words by spaces
 .map((y,i)=>                  // For each word:
  y[                           //  Get the character at index:
                               //   A walk has cycle of length (2 * y.length - 2)
   a=i%(l=y.length-1)|0,       //   Calculate index a = i % (y.length - 1)
   i/l&1                       //   Check in which half the index i in
   ?l-a                        //   If in the second half of cycle, use y.length - 1 - a
   :a                          //   If in the first half of cycle, use a                  
  ]
 ).join``                      // Join back the letters
```
[Answer]
# [Red](http://www.red-lang.org), 135 bytes
```
func[s][n: 0 p: copy""foreach w split s" "[append/dup r: copy""append w
reverse copy/part next w back tail w n: n + 1 append p r/(n)]p]
```
[Try it online!](https://tio.run/##VZDBTsMwEETv/YppTiAOgWtufAESCuIQ5bDEm9hKul7ZDqFC/fbgFIpaaQ@reTPjlQOb9ZVN0@76au1n6ZrYNlLhEVqh83osit4Hps5iQdTJJcQCRUOqLKY0syJcjL8all3gTw6Rz3KpFBKEv1Iu@KBuRCI35T0/InjAE/5iuai8k/tW21WDk4Qe37V1EXkI@bQcjOP@tPunL9Ix3tQLnlG7A1@h2nJgLLRFDyRX5N36rBjOYOu7yVA6R4Qp7W/A5YrJy4CYMhiQPIzLP0JHWL8gWcbAwoGSD5s7zqo@stmMiw/jaf0B "Red – Try It Online")
## Readable:
```
f: func[s][
    n: 0
    p: copy ""
    foreach w split s "  "[
        r: copy ""
        append/dup r append w reverse copy/part next w back tail w n: n + 1
        append p r/(n)
    ]
    p
]
```
[Answer]
# [Perl 5](https://www.perl.org/), 76 bytes
```
print map{$l=length;substr$_.reverse,$i++%(2*$l-2||1)*(1+1/$l),1}split" ",<>
```
[Try it online!](https://tio.run/##FczLCsIwEIXhVxlKhN5UUnDl5SncS6RDExyTMJNaxPrsMcKBf/NxIjIdco7sfIKniR9FZ0I/JXuU@S6J1W3H@EIW7JXruk09tIq2w7rqpq11p/eKml5/JZJLFVT96ZLz1TqBMgMU/ATlxZWkAKMrzrzBhgWSRZjQI5sU@K9ljjEIjn@4BH78AA "Perl 5 – Try It Online")
[Answer]
# [k](https://en.wikipedia.org/wiki/K_(programming_language)), ~~31~~ ~~30~~ 28 bytes
```
{x{*|y#x,1_|1_x}'1+!#x}@" "\
```
[Try it online!](https://tio.run/##NYzLCoMwEEV/ZYwL@1y4bTftF3Rj6aYgQx0bUTMhiRhRv91GoTBwL4dzpz5zvSzlZfTjYRpif0rzKc39nKTHKPbzTYB4L2WyE5msLIRDKDsFDm0diat4qA/BU7OCO2RVSwFlkgxBj6vaogrkJTm0ggJYd5uDblMUoYs28P/esPqCdaYK4RiKyuoGB5Dcg5MEX1Jk0LFZbdtpzZaKVezZ1GK//AA "K (oK) – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~14~~ 11 bytes
```
SzS!ö!…¢ŀŀw
```
[Try it online!](https://tio.run/##RYyxDcIwFER7T/E9ChNQJIj6i3xiy4m/ZTuyoAqMQsEIGSAoi2QRY9MgnXQ63btTUzB53J@PdcnNvZGfRe7ze31t8zannHOrdIAihOtkIWIwUhztheDk2MIBWj2SaBV5goQVG9GKs@LiHZVYF6XH@KstYZTi/zmw7SFEr4tFhk4HN@ANFCeIiqAnSx4j@0qHyTkO1FUwsTdf "Husk – Try It Online") Inspiration was taken from [this program](https://codegolf.stackexchange.com/a/174140) by Zgarb for the forward-and-reverse stepping.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 12 bytes
```
s.e@+b_Ptbkc
```
[Try it online](https://pyth.herokuapp.com/?code=s.e%40%2Bb_Ptbkc&test_suite=1&test_suite_input=%22This%20is%20a%20fun%20task%21%22%0A%22Once%20Upon%20A%20Time%22%0A%22There%20was%20a%20man%22%0A%22Who%20made%20a%20task%22%0A%22That%20was%20neat%21%22%0A%22This%20is%20a%20long%20string%20to%20display%20how%20the%20generator%20is%20supposed%20to%20work%22&debug=0)
```
s.e@+b_PtbkcQ   Final Q (input) implicit
           cQ   Split on spaces
 .e             Map the above with b=element, k=index
       Ptb        Remove 1st and last character
      _           Reverse
    +b            Prepend the unaltered element ('abcd' -> 'abcdcb')
   @      k       Get the kth character (0 indexed, wrapping)
s               Join on empty string, implicit output
```
[Answer]
# Japt, `-P`, 11 bytes
```
¸Ëê ÅªD gEÉ
```
[Try it](https://ethproductions.github.io/japt/?v=2.0a0&code=uMvqIMWqRCBnRck=&input=IlRoaXMgaXMgYSBsb25nIHN0cmluZyB0byBkaXNwbGF5IGhvdyB0aGUgZ2VuZXJhdG9yIGlzIHN1cHBvc2VkIHRvIHdvcmsiCi1Q)
```
¸Ë+s1J w)gE
```
[Try it](https://ethproductions.github.io/japt/?v=2.0a0&code=uMsrczFKIHcpZ0U=&input=IlRoaXMgaXMgYSBsb25nIHN0cmluZyB0byBkaXNwbGF5IGhvdyB0aGUgZ2VuZXJhdG9yIGlzIHN1cHBvc2VkIHRvIHdvcmsiCi1Q)
---
## Explanations
```
¸Ëê ÅªD gEÉ
¸               :Split on spaces
 Ë              :Map over each element D at index E
  ê             :  Palindromise
    Å           :  Slice off the first character
     ªD         :  Logical OR with the original element (the above will return an empty string for single character words)
        g       :  Get the character at index
         EÉ     :  E-1
```
```
¸Ë+s1J w)gE
¸               :Split on spaces
 Ë              :Map over each element D at index E
   s1J          :  Slice off the first and last characters
       w        :  Reverse
  +     )       :  Append to D
         gE     :  Get the character at index E
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 148 bytes (string version), 114 bytes (print version)
If I must return a string (long version):
```
char c[99]={0};char*f(s,t,u,i,j,k)char*s,*t,*u;{for(u=c,i=0;t=strtok(s," ");s=0,i++)*u++=t[j=strlen(t),k=2*j-(j>1)-1,(i%k<j?i%k:k-i%k)%j];return c;}
```
[Try it online!](https://tio.run/##TU/LboMwELzzFatUkWxjqtBb4jj9id4QB2QcMFAb2etEFeLbqUkvlVajnYdGu6rolNrejFVTbDVcA7bGvfe37L/kje2Stqm@8aCq87mWy2kVO2V3EjjyyA0f@EhfUuAMOYtiuTtPolTcyJNAmXrQjSl@gAMVQZ64yXPKYp5LrIbdnrQlSPkoP9hQkOFW0qLkxBzH6/CZ8DIWCelxqIXXGL0FJdbNWITvxliyL43vFH@dyVjaHxSWDMDcyW6kPpgjBvKij6qsKRXZum1fvQmQpoHJ2Q7@HgZ00JowT80P9O4J2GvotNW@Qef3dIjz7IJu9@DT@fEX "C (gcc) – Try It Online")
Otherwise, I just print and don't worry about a buffer (short version):
```
f(s,t,i,j,k)char*s,*t;{for(i=0;t=strtok(s," ");s=0,i++)putchar(t[j=strlen(t),k=2*j-(j>1)-1,(i%k<j?i%k:k-i%k)%j]);}
```
[Try it online!](https://tio.run/##TY/BasMwEETv/oolJSApcol7jOP0J3oLPQhZtldyJSOtE0rIt7tSeykswzD7dmB1PWq9vaDX89obOCfqMbxOl@p/FNGPOdsGliRJlFY6ricVRZKC2scQIsPu2FKXUQouUzvY8TZ1R4mHA19WKjSjqy3EbDwjLl33JmzN7KXhdSMZ7t3Zvmc9uTor39tP3j439ARfCj0rRsVRy1IFQmR/4/CoAHBgZZF74Nfdrk0@rZ7b9jFhgjwK5uBH@HsEKECPaZnVN0zhDjQZGI03UVGIhU7rsoRk@gLeQ3Q/ "C (gcc) – Try It Online")
[Answer]
# AWK, 79 bytes
Mostly because I'm curious to see any better awk or bash solutions!
```
{for(i=1;i<=NF;i++){l=length($i);k=int(i/l)%2?l-i%l:k%l;printf substr($i,k,1)}}
```
[Try it online!](https://tio.run/##FcrBCsMgEATQX9lDA5GklPRYK7n12FN/wBITFxdX1BBKyLdbAwMDM09vrpR95tiiGiQ@1fslsevEToqMX7JtLyikU@hzizcSzX2kKzb0cA3JEOs8Q1q/KccKe9cP4jhK@VhMUKOB2C9QX6yVGSZMgfQPLG@QrYHFeBN15njqtIbAyUwn3Di6Pw "AWK – Try It Online")
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 111 bytes
```
s=>{int i=-1,j;return String.Concat(s.Split(' ').Select(a=>a[++i>(j=a.Length-1)?j>0?i/j%2<1?i%j:j-i%j:0:i]));};
```
[Try it online!](https://tio.run/##fdFBa8IwFAfws/0UT0Fs0Xa6o7WVMdjJsYEOD@Lh0T7bdG3SJa8TET9711oGO0whJCT88k9eEhk3UprqygiZwPpkmArf@jvzVkJ@@VaUozHwrlWisYCz1TOMLCL4ViKGVxTSNqybXbs9oE6M05KXSkaLbnkC3RjCAQLo1SYIz0IyiMCdTTJfE1dawvpqvGclI2TbeOsyF2yPYOR4a8opYhuDEHfjsQjtLEBvRTLh1J05yyycLsVDNnxczJZimM0zt@2nc7F3HP/i102kUTl5Wy2YmorIPtiDTSoMNA3hUElgNJ/9QcOtf/GbjAg@SiXhCTaioNtyk5ImOGIbXKC8DbepakBMjWsPv5eIfA2UhNy/534LylXzgd2TAyuIhSlzPEGqjsApQUKSNLLSrTZVWSpDcQuPSnf3sHoX61L/AA "C# (.NET Core) – Try It Online")
[Answer]
## Haskell, ~~65~~ ~~62~~ 61 bytes
```
zipWith(\i->(!!i).cycle.(id<>reverse.drop 1.init))[0..].words
```
[Try it online!](https://tio.run/##FYyxTsNADEB3vsKtGJKhJ9hpJ0a2VmKgDKecc7F6OVu2QxU@niOVnvSWpzdFu2EpjWZhdXiPHsMZZ8rKizyNcLy2X5JP8qm70uHU7XbUh2EdCoaO0ttJ8QfVMCRlgddAlbzvv15C@A531mRtjlThCLL42fWjwjOMsL9MZLARoXDNYK60yRkSmZS4wsR38AkhY0WNzvqobRFhw/QIt/lt39rFYq68sjOJ898wlpitHQaRfw "Haskell – Try It Online")
It requires the latest version of `Prelude` which features the `<>` function.
```
                   words    -- split the input string into a list of words
zipWith(\i->     )[0..]     -- zip the elements i of [0..] and the words pairwise
                            -- with the function      
      ... <> ...            --   call the functions with a word and concatenate
                            --   the results. The functions are
        id                  --     id: do nothing
        reverse.drop 1.init --     drop last and first element and reverse
    cycle                   --   repeat infinitely
(!!i)                       -- take the ith elemnt of  
```
Edit: -3 bytes thanks to @user28667, -1 byte thanks to @B. Mehta
[Answer]
# [PHP](https://php.net/), 77 bytes
```
while(ord($w=$argv[++$i]))echo($w.=strrev(substr($w,1,-1)))[~-$i%strlen($w)];
```
[Try it online!](https://tio.run/##FYrBCsMgEER/xkIkSSHnNs1P9BZysHVRqbiymkgv/fXtBoaZ4c1kn/m@ZPHmQ4QOyXaqzcqQO9a@V2HTGt4eBV7nUong6Mr@kiZkmIZx0lqvv1GFi7AISbDebrw8mJ8@FBYZjpgcyx4kKrINJUfzZY@Nqwd2kIBMRTrfZc8ZC9jz2JA@fw "PHP – Try It Online")
* -3 bytes thanks to Kevin
* -10 bytes thanks to Titus
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 11 bytes
```
⌈₅(ʁ):ẏ¨£i∑
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLijIjigoUoyoEpOuG6j8KowqNp4oiRIiwiIiwiVGhpcyBpcyBhIGZ1biB0YXNrISJd)
```
⌈           # Input split on spaces
 ₅( )       # repeat len(that) times...
   ʁ        # Palindromise each word
       ¨£   # Zipping...
     :      # Words
      ẏ     # range(0, len(words))
         i  # Index the numbers into the words
          ∑ # Stringify
```
[Answer]
# Powershell ~~208~~ ~~186~~ 170 bytes
```
$args|%{$i=0;-join($_.Split()|%{$l=($b=($a=$_)).Length;if($l-gt2){$b=($a|%{-join$a[($l-2)..1]})}for($j=0;$a.Length-le$i;$j++){$a+=($b,$_)[$j%2]}$a.Substring($i,1);$i++})}
```
Ungolfed: 
```
$args|%{
   $i=0;
    -join($_.Split()|%{
        $l=($b=($a=$_)).Length;
        if($l-gt2){
            $b=($a|%{-join$a[($l-2)..1]})
        }
        for($j=0;$a.Length-le$i;$j++){
            $a+=($b,$_)[$j%2]
        }
        $a.Substring($i,1);
        $i++
    })
}
```
Test cases below or [try it online](https://tio.run/##TY7BasMwDIZfRQsqxKQJa66hh94HO7Rjh1KKuqiJU9cOtkMYXZ49s9MdBjKIX9//4d6MbF3LSs0zkm3cz@qBcvta5Z2ROsVzse@V9KmIudqmeAmPtngWonhj3fi2ktcUVd74Ujye14AubaRjvJSiKDanSUxXY1Psghvpr5srRllhl2WhS1nUr4P6iN2qPE0B2w8X563UTYpyvREVyiwLpnmek0MrHYQhuA4aPLnbSzIn7/qL4aM3GnZwkHdOIsiWYaSI3kmH5LM1Yas5BLG3MOQXRDP55L9cGd3A8w/gDdTS9Yq@oTUj@JahYc2WvLGRdkPfG8d1BEdjb8kv)
```
@(
    "This is a fun task!",
    "Once Upon A Time",
    "There was a man",
    "Who made a task",
    "That was neat",
    "This is a long string to display how the generator is supposed to work"
)|%{$i=0;-join($_.Split()|%{$l=($b=($a=$_)).Length;if($l-gt2){$b=($a|%{-join$a[($l-2)..1]})}for($j=0;$a.Length-le$i;$j++){$a+=($b,$_)[$j%2]}$a.Substring($i,1);$i++})}
```
[Answer]
# J, 43 bytes
```
[:(>{~"_1#@>|i.@#)[:(,}.@}:)&.>[:<;._1' '&,
```
## ungolfed
```
[: (> {~"_1 #@> | i.@#) [: (, }.@}:)&.> [: <;._1 ' '&,
```
* `<;._1 ' '&,` split on spaces
* `(, }.@}:)&.>` for each word, kill the first and last elm and append to word
* `#@> | i.@#` take the remainder of each word's length divided into its index
* `> {~"_1` take that result and pluck it from each word.
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/o6007KrrlOINlR3sajL1HJQ1gSI6tXoOtVaaanp20VY21nrxhuoK6mo6/zW5uFKTM/IV0hTUQzIyixWAKFEhrTRPoSSxOFtRHS7pn5ecqhBakJ@n4KgQkpmbqo6kLbUoVaE8EaQxNzFP/T8A "J – Try It Online")
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 22 bytes
```
qS/{_);1>W%+T_):T@*=}%
```
[Try it online!](https://tio.run/##FcqxCsIwEIDhVzmHDtWCuCqKo7uFjiVNr3j1cqdJahDx2aNZ/@@3s3E5P6/bT18fdqeu2rR9vW/P6@O3yvmiqQGPhvndQCJmUB4hoJB6mJTvoeR4Ax1mtJFUzMAIViV6faEPhP9jWpBBTOFEIwK5R1GHElc/ "CJam – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/) `-pl`, 60 bytes
```
gsub(/(\S+) ?/){w=$1+$1.reverse[1..-2]
w[(-2+$.+=1)%w.size]}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72kqDSpcnm0km5BjlLsgqWlJWm6Fjdt0otLkzT0NWKCtTUV7PU1q8ttVQy1VQz1ilLLUouKU6MN9fR0jWK5yqM1dI20VfS0bQ01Vcv1ijOrUmNrIWZAjVpw0y0kI7NYAYgSFXLy89IVikuKMoFUSb5CSmZxQU5ipUJGfrlCSUaqQnpqXmpRYkl-EUh1cWlBQX5xagpIYXl-UTbEOAA)
]