[Question]
  [
*Disclaimer:* This challenge inspired by me spending the morning debugging recursive functions, which have been frying my brain a little.
Here's an example of recursion, from a letter, we keep going to the previous letter of the alphabet, printing out each one as we go, until we hit the letter a, then we print that and stop. We do this for each letter in a string and there's a pretty pattern at the end of it.
# The task
* Start with a string of characters
	+ The input string may only contain the lower-case letters a-z and the space character.
* For each letter, produce a line of text (terminal output or variable or whatever)
	+ Print out the letter
	+ Print out the previous letter (on the same line)
	+ Print out the previous letter (on the same line)
	+ Print out the previous letter (on the same line)
	+ ...
	+ If the letter is 'a', print it out and move to the next line.
	+ If it's a space, print out an empty line (or one just containing the space character.
# The rules
* It's golf, try and make your code short.
* Any language you like.
* Please include a link to an online interpreter.
* The output should be human-readable (e.g. I can't work it out from a list of bytes.
* Follow the rules of the standard loopholes `¯\_(ツ)_/¯`
* Recursion is not mandated by the rules, but it's probably necessary.
# Test Cases
Input: 'abcdefghijklmnopqrstuvwxyz'
Output:
```
a
ba
cba
dcba
edcba
fedcba
gfedcba
hgfedcba
ihgfedcba
jihgfedcba
kjihgfedcba
lkjihgfedcba
mlkjihgfedcba
nmlkjihgfedcba
onmlkjihgfedcba
ponmlkjihgfedcba
qponmlkjihgfedcba
rqponmlkjihgfedcba
srqponmlkjihgfedcba
tsrqponmlkjihgfedcba
utsrqponmlkjihgfedcba
vutsrqponmlkjihgfedcba
wvutsrqponmlkjihgfedcba
xwvutsrqponmlkjihgfedcba
yxwvutsrqponmlkjihgfedcba
zyxwvutsrqponmlkjihgfedcba
```
Input: 'zyxwvutsrqponmlkjihgfedcba'
```
zyxwvutsrqponmlkjihgfedcba
yxwvutsrqponmlkjihgfedcba
xwvutsrqponmlkjihgfedcba
wvutsrqponmlkjihgfedcba
vutsrqponmlkjihgfedcba
utsrqponmlkjihgfedcba
tsrqponmlkjihgfedcba
srqponmlkjihgfedcba
rqponmlkjihgfedcba
qponmlkjihgfedcba
ponmlkjihgfedcba
onmlkjihgfedcba
nmlkjihgfedcba
mlkjihgfedcba
lkjihgfedcba
kjihgfedcba
jihgfedcba
ihgfedcba
hgfedcba
gfedcba
fedcba
edcba
dcba
cba
ba
a
```
Input: 'hello world'
Output:
```
hgfedcba
edcba
lkjihgfedcba
lkjihgfedcba
onmlkjihgfedcba
wvutsrqponmlkjihgfedcba
onmlkjihgfedcba
rqponmlkjihgfedcba
lkjihgfedcba
dcba
```
  
[Answer]
# [Dyalog APL Extended](https://github.com/abrudz/dyalog-apl-extended), 4 bytes
```
⌽∘⍳¨
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/P@1R24RHPXsfdcx41Lv50AqggIJ6RmpOTr5CeX5RToo6AA "APL (Dyalog Extended) – Try It Online")
```
 ∘    the function composition of
  ⍳     iota - 'a'..input for alphabet chars, empty array for space
⌽       and after, reverse
   ¨  applied to each
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~26~~ 24 bytes
*-2 bytes thanks to [FrownyFrog](https://codegolf.stackexchange.com/users/74681).*
```
map(\i->reverse['a'..i])
```
[Try it online!](https://tio.run/##Fc3LEYMgFADAVt5wUWeiHZgOUoF6QP6CgIDf4kPIeQ8rcdTMmMz7Ma/Y16Nq34EdLEQ2VLjqOjU1BZSFHop/oPZB2QQd8AYGhGdCGRdSLdqs1vktxLQf53U/6AXoua9jTzFs3tnV6EVJwRklM/6jLK2D0wVD0ZS/hBssYm6J9z8 "Haskell – Try It Online")
Pointless (or pointfree :P) for you.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~58~~ 56 bytes
*Saved 2 bytes thanks to @KritixiLithos*
```
c;f(char*s){while(c=c&&putchar(c>96?c:10)^10?c-1:*s++);}
```
[Try it online!](https://tio.run/##FchBCoMwEAXQvacILmRGCZhNoYbWmwjha0wgbYppm4V4dVP6lg9yBUqBtgRntjbxnp0PC@GGpnl93v8l3K@XEYPqeVL9CKmGNnUd66N8o5/Fw/gnsdgrISzVbgkhihy3MNesq6OcsMGsqcj8Aw "C (gcc) – Try It Online")
[Answer]
# [Malbolge20](https://esolangs.org/wiki/Malbolge20) and [Malbolge Unshackled](https://esolangs.org/wiki/Malbolge_Unshackled) polyglot, around 2MB, 107KB compressed.
Alright. I spent around 30 minutes on this answer (current record). It's really optimal answer. Albeit not so fast and not so memory-exhausting (only ~512 megabytes), it's still a Malbolge answer so please keep that noted. 
The program is packed using 7zip and PPMd compression algorithm. You can download it [here](https://github.com/KrzysztofSzewczyk/codegolf-submissions/raw/master/196192.7z).
## Interpreter that works the best with the program.
```
#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
const char* translation = "5z]&gqtyfr$(we4{WP)H-Zn,[%\\3dL+Q;>U!pJS72Fh"
        "OA1CB6v^=I_0/8|jsb9m<.TVac`uY*MK'X~xDl}REokN:#?G\"i@";
typedef struct Word {
    unsigned int area;
    unsigned int high;
    unsigned int low;
} Word;
void word2string(Word w, char* s, int min_length) {
    if (!s) return;
    if (min_length < 1) min_length = 1;
    if (min_length > 20) min_length = 20;
    s[0] = (w.area%3) + '0';
    s[1] = 't';
    char tmp[20];
    int i;
    for (i=0;i<10;i++) {
        tmp[19-i] = (w.low % 3) + '0';
        w.low /= 3;
    }
    for (i=0;i<10;i++) {
        tmp[9-i] = (w.high % 3) + '0';
        w.high /= 3;
    }
    i = 0;
    while (tmp[i] == s[0] && i < 20 - min_length) i++;
    int j = 2;
    while (i < 20) {
        s[j] = tmp[i];
        i++;
        j++;
    }
    s[j] = 0;
}
unsigned int crazy_low(unsigned int a, unsigned int d){
    unsigned int crz[] = {1,0,0,1,0,2,2,2,1};
    int position = 0;
    unsigned int output = 0;
    while (position < 10){
        unsigned int i = a%3;
        unsigned int j = d%3;
        unsigned int out = crz[i+3*j];
        unsigned int multiple = 1;
        int k;
        for (k=0;k<position;k++)
            multiple *= 3;
        output += multiple*out;
        a /= 3;
        d /= 3;
        position++;
    }
    return output;
}
Word zero() {
    Word result = {0, 0, 0};
    return result;
}
Word increment(Word d) {
    d.low++;
    if (d.low >= 59049) {
        d.low = 0;
        d.high++;
        if (d.high >= 59049) {
            fprintf(stderr,"error: overflow\n");
            exit(1);
        }
    }
    return d;
}
Word decrement(Word d) {
    if (d.low == 0) {
        d.low = 59048;
        d.high--;
    }else{
        d.low--;
    }
    return d;
}
Word crazy(Word a, Word d){
    Word output;
    unsigned int crz[] = {1,0,0,1,0,2,2,2,1};
    output.area = crz[a.area+3*d.area];
    output.high = crazy_low(a.high, d.high);
    output.low = crazy_low(a.low, d.low);
    return output;
}
Word rotate_r(Word d){
    unsigned int carry_h = d.high%3;
    unsigned int carry_l = d.low%3;
    d.high = 19683 * carry_l + d.high / 3;
    d.low = 19683 * carry_h + d.low / 3;
    return d;
}
// last_initialized: if set, use to fill newly generated memory with preinitial values...
Word* ptr_to(Word** mem[], Word d, unsigned int last_initialized) {
    if ((mem[d.area])[d.high]) {
        return &(((mem[d.area])[d.high])[d.low]);
    }
    (mem[d.area])[d.high] = (Word*)malloc(59049 * sizeof(Word));
    if (!(mem[d.area])[d.high]) {
        fprintf(stderr,"error: out of memory.\n");
        exit(1);
    }
    if (last_initialized) {
        Word repitition[6];
        repitition[(last_initialized-1) % 6] =
                ((mem[0])[(last_initialized-1) / 59049])
                    [(last_initialized-1) % 59049];
        repitition[(last_initialized) % 6] =
                ((mem[0])[last_initialized / 59049])
                    [last_initialized % 59049];
        unsigned int i;
        for (i=0;i<6;i++) {
            repitition[(last_initialized+1+i) % 6] =
                    crazy(repitition[(last_initialized+i) % 6],
                        repitition[(last_initialized-1+i) % 6]);
        }
        unsigned int offset = (59049*d.high) % 6;
        i = 0;
        while (1){
            ((mem[d.area])[d.high])[i] = repitition[(i+offset)%6];
            if (i == 59048) {
                break;
            }
            i++;
        }
    }
    return &(((mem[d.area])[d.high])[d.low]);
}
unsigned int get_instruction(Word** mem[], Word c,
        unsigned int last_initialized,
        int ignore_invalid) {
    Word* instr = ptr_to(mem, c, last_initialized);
    unsigned int instruction = instr->low;
    instruction = (instruction+c.low + 59049 * c.high
            + (c.area==1?52:(c.area==2?10:0)))%94;
    return instruction;
}
int main(int argc, char* argv[]) {
    Word** memory[3];
    int i,j;
    for (i=0; i<3; i++) {
        memory[i] = (Word**)malloc(59049 * sizeof(Word*));
        if (!memory) {
            fprintf(stderr,"not enough memory.\n");
            return 1;
        }
        for (j=0; j<59049; j++) {
            (memory[i])[j] = 0;
        }
    }
    Word a, c, d;
    unsigned int result;
    FILE* file;
    if (argc < 2) {
        // read program code from STDIN
        file = stdin;
    }else{
        file = fopen(argv[1],"rb");
    }
    if (file == NULL) {
        fprintf(stderr, "File not found: %s\n",argv[1]);
        return 1;
    }
    a = zero();
    c = zero();
    d = zero();
    result = 0;
    while (!feof(file)){
        unsigned int instr;
        Word* cell = ptr_to(memory, d, 0);
        (*cell) = zero();
        result = fread(&cell->low,1,1,file);
        if (result > 1)
            return 1;
        if (result == 0 || cell->low == 0x1a || cell->low == 0x04)
            break;
        instr = (cell->low + d.low + 59049*d.high)%94;
        if (cell->low == ' ' || cell->low == '\t' || cell->low == '\r'
                || cell->low == '\n');
        else if (cell->low >= 33 && cell->low < 127 &&
                (instr == 4 || instr == 5 || instr == 23 || instr == 39
                    || instr == 40 || instr == 62 || instr == 68
                    || instr == 81)) {
            d = increment(d);
        }
    }
    if (file != stdin) {
        fclose(file);
    }
    unsigned int last_initialized = 0;
    while (1){
        *ptr_to(memory, d, 0) = crazy(*ptr_to(memory, decrement(d), 0),
                *ptr_to(memory, decrement(decrement(d)), 0));
        last_initialized = d.low + 59049*d.high;
        if (d.low == 59048) {
            break;
        }
        d = increment(d);
    }
    d = zero();
    unsigned int step = 0;
    while (1) {
        unsigned int instruction = get_instruction(memory, c,
                last_initialized, 0);
        step++;
        switch (instruction){
            case 4:
                c = *ptr_to(memory,d,last_initialized);
                break;
            case 5:
                if (!a.area) {
                    printf("%c",(char)(a.low + 59049*a.high));
                }else if (a.area == 2 && a.low == 59047
                        && a.high == 59048) {
                    printf("\n");
                }
                break;
            case 23:
                a = zero();
                a.low = getchar();
                if (a.low == EOF) {
                    a.low = 59048;
                    a.high = 59048;
                    a.area = 2;
                }else if (a.low == '\n'){
                    a.low = 59047;
                    a.high = 59048;
                    a.area = 2;
                }
                break;
            case 39:
                a = (*ptr_to(memory,d,last_initialized)
                        = rotate_r(*ptr_to(memory,d,last_initialized)));
                break;
            case 40:
                d = *ptr_to(memory,d,last_initialized);
                break;
            case 62:
                a = (*ptr_to(memory,d,last_initialized)
                        = crazy(a, *ptr_to(memory,d,last_initialized)));
                break;
            case 81:
                return 0;
            case 68:
            default:
                break;
        }
        Word* mem_c = ptr_to(memory, c, last_initialized);
        mem_c->low = translation[mem_c->low - 33];
        c = increment(c);
        d = increment(d);
    }
    return 0;
}
```
## It works!
[![It works!](https://i.stack.imgur.com/TdDi4.png)](https://i.stack.imgur.com/TdDi4.png)
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~37~~ 28 bytes
-9 bytes thanks to mazzy
```
$args|%{-join($_..'a'-le$_)}
```
[Try it online!](https://tio.run/##NcrLDYMgAADQO1MQQ0t70A1MuolB@YugoIJaZ6dpjOf3RheZD5IZkxGvj4yIF@H7OErtlH2hpqowwaVhqHmf@QQAJVjD4v8djM4bWoAn4vCTAMYX4n1LcV3m4KfR2cH0WknBGe1agu97RdJ2lHEhle7NYN04@TAva0zbfsf8Aw "PowerShell – Try It Online")
Takes input via splatting and uses char ranges introduced in PS v6. The range is then filtered out by only taking elements that are less than the current character. This in turns means decreasing ranges are unaffected (e.g. 'z'..'a') whereas increasing ranges (e.g. ' '..'a') will filter out everything except the space.
[Answer]
# [Python 3](https://docs.python.org/3/), 65 bytes
```
lambda s:print([''.join(map(chr,range(ord(c),96,-1)))for c in s])
```
Outputs a list of strings as clarified in @Arnauld's comment.
If we could assume that a string `s` existed with the content it would be 56 bytes.
[Try it online!](https://tio.run/##BcFRCsMgDADQq@TPBGxhDAYd9CSlH07rtNhEojB6evdevXsSfo4R1@KuT3DQ3lUzd9yMmU/JjJer6JNadfw9UDSgJ7u87PQgoigKHjJD22lENOkoReAnWoKh8Qc "Python 3 – Try It Online")
[Answer]
# Sed (with `-r` switch), ~~65~~ ~~61~~ ~~60~~ 59 characters
```
s/./&zyxwvutsrqponmlkjihgfedcba \n/g
s/(.).*\1/\1/gm
s/ //g
```
Thanks to:
* [Kritixi Lithos](https://codegolf.stackexchange.com/users/41805/kritixi-lithos) for finding an unnecessary capturing (-3 characters)
* [Kritixi Lithos](https://codegolf.stackexchange.com/users/41805/kritixi-lithos) for ~~anchoring to line start~~ not anchoring instead of word start (~~-1~~ 2 characters)
* [Kritixi Lithos](https://codegolf.stackexchange.com/users/41805/kritixi-lithos) for combining the 2 solutions advantages (2 characters)
Sample run:
```
bash-5.0$ sed -r 's/./&zyxwvutsrqponmlkjihgfedcba \n/g;s/(.).*\1/\1/gm;s/ //g' <<< 'cg cc'
cba
gfedcba
cba
cba
```
[Try it online!](https://tio.run/##DcdLDkAwEADQvVN0JUh04j42aLVoO9XxP7wheZtHWjETSMif@zqPfaO0RgzeLfNkzajV0HeiDWAygkKWsmob@Bn/XwAYZqudE2jFicmpF@M2YSCu0wc "sed 4.2.2 – Try It Online")
### Sed (with `-r` switch), ~~53~~ 52 characters
```
s/./&zyxwvutsrqponmlkjihgfedcba \n/g
s/(.).*\1/\1/gm
```
In case trailing spaces are acceptable.
[Try it online!](https://tio.run/##DcJJDoAgDADAu6/gZNREGv/DRQVxAYrU/fFWJ0NGMxNIyJ/7Oo99o7RGDN4t8zTawei@a4UKYDOCQpayUg38rWcejXMoTkxOvxi3CQNxnT4 "sed 4.2.2 – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 56 bytes
Takes input as a list of characters. Returns a list of strings.
```
s=>s.map(g=c=>(c|=(B=Buffer)(c)[0])>96?B([c--])+g(c):'')
```
[Try it online!](https://tio.run/##DcjBCgIhEADQX4m9OEMonYKCMfA3zIO4aruYs@hWl/7dese3@rfvoS3bLivPcSQanXRXT79BpkAawpfAkHmlFBtCQHtyqC/nmwEbpHR4zP@8CoEjcO1coiqcIYFVSk2PWAofPtzKPDlUKy8VxL0KxPED "JavaScript (Node.js) – Try It Online")
### Commented
```
s =>                 // s[] = input characters
  s.map(g = c =>     // for each character c in s[], using the recursive function g:
    ( c |=           //   update c:
        (B = Buffer) //     on the first iteration, c is a character and Buffer(c)[0]
        (c)[0]       //     returns its ASCII code; on later iterations, c is an
                     //     integer and Buffer(c) creates a buffer filled with NUL bytes
    ) > 96 ?         //     if c is greater than 96:
      B([c--])       //       append the character of ASCII code c and decrement c
      + g(c)         //       append the result of a recursive call
    :                //     else:
      ''             //       stop recursion
  )                  // end of map()
```
[Answer]
# [R](https://www.r-project.org/), ~~63~~ ~~62~~ 61 bytes
-16 bytes thanks to Giuseppe
-7 more bytes, again, thanks to Giuseppe
-1 byte adding a line break in place of `\n`
-1 byte thanks to Robin Ryder
```
for(l in utf8ToInt(scan(,""))-96)cat(letters[l:0],'
',sep="")
```
[Try it online!](https://tio.run/##DcoxCsMwDADAva8QXmKDA5lCW8gDumcLHYSjOAZFKrb6frc3X@390OoZisDXjvuqLzHfEoqPzoUwPuaQ0DyTGdW28XN6x@E2xEaf5R@6O6kSFMALku5FMiBk1R3SicwkmVz/AQ "R – Try It Online")
# [R](https://www.r-project.org/), 86 bytes (my original answer)
```
x=utf8ToInt(scan(,''));s=sapply;cat(gsub(" .+"," ",s(s(x,`:`,97),intToUtf8)),sep="\n")
```
Ungolfed:
```
x=utf8ToInt(scan(,''))                                 #Takes input, converts to ASCII
s=sapply;                                              #Alias sapply function to save a byte
                     s(x,`:`,97)                       #Create vector from 97 to respective ASCII value
                   s(           ,intToUtf8)            #Convert to character
    gsub(" .+"," ",                        )           #Removes everything after space
cat(                                        ,sep="\n") #Outputs to console
```
[Try it online!](https://tio.run/##Dcw7DsMgDADQq1heYqtW136iHKB7snUIJZQgUUAxkdLT074DvK21Y9jr@zrmR6qk1iSSrmPudVBTSvz21lTyur8I4XxCQUBRUjpkvs9yu7CEVMc8/Q9mUVcGfCbkhqvbHAQwH7B5CcmDAZ/zAnY1MbrkHbYf "R – Try It Online")
Could likely be golfed.
NOTE: It does not use recursion. I do not know whether that would be shorter or not. I'll experiment later.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~56~~, 53 bytes
```
c;f(char*s){for(c=*s;c;)putchar(c<97?c=*++s,10:c--);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z/ZOk0jOSOxSKtYszotv0gj2Var2DrZWrOgtAQkrJFsY2luDxTU1i7WMTSwStbV1bSu/Z@ZV6KQm5iZp6HJVc3FmaahlJGak5OvUJ5flJOipGnNVfsfAA "C (gcc) – Try It Online")
Now down to 53 bytes! It can probably be golfed more though...
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 24 bytes
```
*.comb>>.&{[R~] 'a'..$_}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPtfSy85PzfJzk5PrTo6qC5WQT1RXU9PJb72vzVXcWKlQpqGekZqTk6@Qnl@UU6KuqZeVn5mnoZSTJ6SpvV/AA "Perl 6 – Try It Online")
Returns a list of strings.
### Explanation
```
*.comb  # Split into characters
      >>.&{            }  # Map to
                'a'..$_   # Range 'a' to current character
           [R~]           # Reverse concat
```
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), ~~17~~ 14 bytes
-3 bytes thanks to streetster
-3 bytes thanks to ngn
```
`c$96-!:'0&96-
```
[Try it online!](https://tio.run/##DclJDkAwFADQq9CIYSGxkuAy6Eg/X2uo9vJl9RZP16hjFP1Is66t075o8t8oipJMM2VcSLWsGrYdD2PP637c6wMZSPCve@7rtObAfQO9LkoKzug8/ak4ACYOLTBSxQ8 "K (oK) – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~8~~ 7 bytes
A monadic link returning a list of strings.
```
ḲOr97ỌK
```
[Try it online!](https://tio.run/##y0rNyan8///hjk3@RZbmD3f3eP8/3B75/38GUDxfoTy/KCcFAA "Jelly – Try It Online")
```
ḲOr97ỌK   - a monadic link taking a string, e.g. "ab c"
Ḳ         - split at spaces                 --> ["ab", "c"]
 O        - get ASCII codes                 --> [[97, 98], [99]]
  r97     - build descending range to 97    --> [[[97], [98, 97]], [[99, 98, 97]]]
     Ọ    - turn back into ASCII            --> [["a", "ba"], ["cba"]]
      K   - join with spaces                --> ["a", "ba", " ", "cba"]
```
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 12 bytes
```
{),97>-1%n}%
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/v1pTx9LcTtdQNa9W9f//jNScnHyF8vyinBQA "GolfScript – Try It Online")
## Explanation
```
{         }% # Map over the implicit input
 ),          # Generate range to 0x00
   97>       # Remove all that is less than 97
      -1%    # Reverse the string
         n   # Add a newline
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~14~~ ~~12~~ 5 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
AAηí‡
```
-2 bytes by outputting as a list of strings.  
-7 bytes (byte-count more than halved) thanks to *@Grimy*.
Input as a list of characters.
[Try it online](https://tio.run/##yy9OTMpM/f/f0fHc9sNrHzUs/P8/WilDSUcpFYhzoDgfiBWAuBzKLoKKpyjFAgA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9TpuSZV1BaYqWgZF8Z7KLDpeRfWgLh6/x3dDy3/fDaRw0L/@sc2mb/PzEpOSU1LT0jMys7Jzcvv6CwqLiktKy8orKKq6qyorystKS4qLAgPy83JzsrMyM9LTUlOSmRKyM1JydfoTy/KCcFAA).
Or alternatively:
```
AÂ.s‡
```
[Try it online](https://tio.run/##yy9OTMpM/f/f8XCTXvGjhoX//0crZSjpKKUCcQ4U5wOxAhCXQ9lFUPEUpVgA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9TpuSZV1BaYqWgZF8Z7KLDpeRfWgLh6/x3PNykV/yoYeF/nUPb7P8nJiWnpKalZ2RmZefk5uUXFBYVl5SWlVdUVnFVVVaUl5WWFBcVFuTn5eZkZ2VmpKelpiQnJXJlpObk5CuU5xflpAAA).
**Explanation:**
```
A      # Push the lowercase alphabet
 Aη    # Push a list of prefixes of the lowercase alphabet
   í   # Reverse each prefix
    ‡  # Transliterate all characters of the alphabet to these reversed prefixes in
       # the (implicit) input-list
       # (after which the resulting string-list is output implicitly)
A      # Push the lowercase alphabet
 Â     # Bifurcate it; short for Duplicate & Reverse copy
  .s   # Get the suffixes of that reversed alphabet
    ‡  # Transliterate all characters of the alphabet to these reversed suffixes in
       # the (implicit) input-list
       # (after which the resulting string-list is output implicitly)
```
[Answer]
# Ruby, 41 characters
```
->s{s.chars{|c|puts [*?a..c].reverse*''}}
```
or
```
->s{s.gsub(/./){[*?a..$&].reverse*''+$/}}
```
No recursion here.
Sample run:
```
irb(main):001:0> ->s{s.chars{|c|puts [*?a..c].reverse*''}}['cgcc']
cba
gfedcba
cba
cba
```
[Try it online!](https://tio.run/##KypNqvyfpmD7X9euuLpYLzkjsai4uia5pqC0pFghWss@UU8vOVavKLUstag4VUtdvbb2f1q0ekZqTk6@Qnl@UU6Keux/AA "Ruby – Try It Online")
[Answer]
# PostgreSQL, 119 characters
```
\prompt s
select(select string_agg(chr(s),'')from generate_series(ascii(c),97,-1)s)from regexp_split_to_table(:'s','')c
```
(Those verbose function names are killing me…)
Sample run:
```
bash-5.0$ psql -Atf pointlessly-recurse.sql <<< 'hello world'
hgfedcba
edcba
lkjihgfedcba
lkjihgfedcba
onmlkjihgfedcba
wvutsrqponmlkjihgfedcba
onmlkjihgfedcba
rqponmlkjihgfedcba
lkjihgfedcba
dcba
```
[Answer]
# [V (vim)](https://github.com/DJMcMayhem/V), 15 bytes
```
\Óçá/A¬za
Íˆ…±
```
[Try it online!](https://tio.run/##ASgA1/92//9cw5PDp8OhL0HCrHphCsONwojCgcKFwrH//2hlbGxvIHdvcmxk "V (vim) – Try It Online")
Hexdump:
```
00000000: 5cd3 e7e1 2f41 ac7a 610d cd88 8185 b1    \.../A.za......
```
Fun fact: Recursion is the only form of looping that V has, yet this submission doesn't use any.
[Answer]
# [Befunge-98 (PyFunge)](https://pythonhosted.org/PyFunge/), 18 bytes
```
#@~#;:'``j;:,1-;a,
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tNAtqAQz//9XdqhTtrZST0jIsrbSMdS1TtT5/z8jNScnX6E8vygnBQA "Befunge-98 (PyFunge) – Try It Online")
[Answer]
# [PHP](https://php.net/), 88 bytes
```
<?php
for(;$i<strlen($s=$argv[1]);){for($j=ord($s[$i++]);$j>96;)echo chr($j--);echo"
";}
```
[Try it online!](https://tio.run/##FcpNDoMgGEXRuaswhgSJcdBJkwbbLsR0oIACoh@C/03XTnX47nlW2hCKt5U2asClFKnCT86IIUX@iSrXLuXtQyj5Xor0Exw/pUQqy86M9Otxp0QwCTGT1yHPCb1mEiX0F0LAVc24aFqpdGf6Aezo/DQv67YfOMLHvq3LPHk3Whh602kl20ZwVlcnSmEMxCs4w/Ef "PHP – Try It Online")
Thanks to Shaggy for -21 bytes! :)
[Answer]
# [Wren](https://github.com/munificent/wren), 103 bytes
Hopefully this beats the Lua answer.
```
Fn.new{|x|
for(i in x)System.print(i==" "?"":(i.bytes[0]..97).map{|j|String.fromCodePoint(j)}.join())
}
```
[Try it online!](https://tio.run/##FY29CsIwGAD3PsVHpmT5cBOF4CA4Cx3FIbaJJuSnpNG0NH322G433HE5Sl9/IoL6@g441JtHL/NSptKoEKkG7WFi7Twm6XCI2ieqOSdALoScqcbXnOT4ODwRT0eGTgxLMaVNm/hGFYO7hl7ew54ZtqLZiDLWrHX/YSespeQjrQ2QQ7Q9YfUP "Wren – Try It Online")
# [Wren](https://github.com/munificent/wren), 159 bytes
I am not having enough fun.
```
Fn.new{|x|
for(i in 122..97)x=x.replace(String.fromCodePoint(i),String.fromCodePoint(i)+String.fromCodePoint(i-1))
return x.replace("`","
").replace(" ","
")
}
```
[Try it online!](https://tio.run/##dc6xCsIwEIDhPU9xZMqhBtpFHDoJzkJfwNJeNZBe5ExNxfrsEXHoous3/PxJiPO9EehHbqGCfGDLlJ7zNKs@iHHgGIqytHa3xamarNDVNy2ZOorjs@0lDPvQ0TE4jsbh@o@vfvumQFRCcRSGpa1Peq2VxgXgC@qV68ct0mCTuEjmM23bxnujL@R9gBTEdxoxvwE "Wren – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Øa>Ðḟ)U
```
A monadic link accepting a list of characters which yields a list of lists of characters.
**[Try it online!](https://tio.run/##y0rNyan8///wjES7wxMe7pivGfr/cHvk//8ZQPF8hfL8opwUAA "Jelly – Try It Online")** (adds newlines, since as a full program Jelly will print a smashed version of the lists)
### How?
```
Øa>Ðḟ)U - Link: list of characters, S
     )  - for each (character, c, in S):
Øa      -   yield the lowercase alphabet ['a', 'b', ..., 'z']
   Ðḟ   -   filter discard those for which:
  >     -     greater than (c)?
      U - reverse each resulting list (each line)
```
[Answer]
**Brainfuck, 240 chars**
`,[>,[>+>+<<-]>------------------------------------------------------------------------------------------------[>.-<-]++++++++++.---------->------------------------------------------------------------------------------------------------<<<-]`
[Try it online!](https://fatiherikli.github.io/brainfuck-visualizer/#LFs+LApbPis+Kzw8LV0KPi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQpbPi4tPC1dCisrKysrKysrKysuLS0tLS0tLS0tLQo+LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPDw8LV0=)
*Explanation:*
, takes an input for the length of the input for the loop
[>,[>+>+<<-]> takes an input and duplicates it
------------------------------------------------------------------------------------------------ takes 97 from the ascii value of the input to iterate over
[>.-<-] outputs the ascii character and then takes one away from the pointer, ready for the next loop
++++++++++.----------> outputs the newline
------------------------------------------------------------------------------------------------<<<-] resets everything ready for another iteration
[Answer]
# [Lua](https://www.lua.org), 94 bytes
```
function r(l)return l:find"[` ]"and"\n"or l..r(l.char(l:byte()-1))end
print((...):gsub(".",r))
```
[Try it online!](https://tio.run/##HYrLDsIgEEX3fgVhBYmSuO2vqIm8WminQ51CXz@P1bs5JzkXiq61LWhzTMhIgCSfCyGDpo3o@OPNXlyf8kSeiIFS50fZoE80Zs9eyNtdSo/uMlHELIRSSjbdXIzgil9JylrrsW/rUvJMnynhCEMfQ9d6Z41mv2ljnW@7EPsBRkzTh@ZclnXbj38OHiCxNRG4Lw "Lua – Try It Online")
Only works if we can have redundant output, else +1 byte.
## Explanation
Creates a recursive function `r` that returns what each letter should turn into.
When the input letter of this function is a space or the character before `a` (which is `) then this should not be printed, but a new line instead.
Replace each character in the input string (the first command-line argument) with the output of the function r called with this character.
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-mR`](https://codegolf.meta.stackexchange.com/a/14339/), 6 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Takes input as an array of characters.
```
;CÔk>U
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LW1S&code=O0PUaz5V&input=WyJhIiwiYiIsIiAiLCJ5IiwieiJd)
[Answer]
# [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/csnobol4/), 94 bytes
```
	I =INPUT
S	I LEN(1) . X REM . I	:F(END)
	Y =
	&LCASE ARB . Y X
	OUTPUT =X REVERSE(Y)	:(S)
END
```
[Try it online!](https://tio.run/##FcuxCsIwFIXhOXmKM0myCIJTIUPVKwRqlKaVdmw1tIWYQBV8/Bin88Phe4c4Rr9PiWkobW5tw23OiozYSWzRoaZLXs2KsyBzkpz1UJxtqmNpCWV9yGePjrNr22QN9Rd3qi2JXrJCWMkzS2l2q8OC4YXvunyWMGHAFOMTj3nw3oXJ/QA "SNOBOL4 (CSNOBOL4) – Try It Online")
[Answer]
# [Julia 1.0](http://julialang.org/), ~~36~~ 29 bytes
```
f(s)=[join(i:-1:'a') for i=s]
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/P02jWNM2Ois/M08j00rX0Eo9UV1TIS2/SCHTtjj2v0NxRn65QpqGUkZqTk6@Qnl@UU6KkuZ/AA "Julia 1.0 – Try It Online")
Note: Outputs as an array of strings.
To display in a nice output format, use, for example, `println.(f("hello world"))`
[Answer]
# [Poetic](https://mcaweb.matc.edu/winslojr/vicom128/final/index.html), 482 bytes
```
transmit a letter or two,a-z
enter in letters from a-z+space
i did a print,i say a letter&go down
i am moving in a cycle
i get to letter a,and maybe to space
i then create lines as i output the ten,a ASCII N/L char
i figure x>y,and i do admire a way i check it
if indeed x>y,then i rerun;if not,i finish it to output N/L char
i write it out&i follow it up until no char i input is here
o,et cetera as i run
i do admit,i do run relatively longish
o,i say,i do loads of BS deriving it
```
[Try it online!](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/index.html?TVBLTsQwDN33FG/FhiIOgIQErEZCbOYEnsZtLdJ4lLhTyuUHp/MRu8Tva1umVCYxECKbcYZm2KItPf02nOpA0hUq6LNOcOSxHKnjRhAkuPKYJVkrKLTefR4GRdAlOYkmTHqSNFQrQrd2sWoHNpjeYqmlFDDReuA6vQXYyAldZjJGlMQFVCDQ2Y6zVRTGqSW87T92O3w9f6IbKbuwl2HOjJ/XdTP2qgoKk/iMsHhRcSZ33xBrpPdmgTls9C1SkDnP6cWhpHW3XpKU0dm13TX@X9ySxRs66tCDszVGXep/PmJOJtFtNq47S6piKRg5c6Ot36FjvwFddvPY5l63RvvTZ14oksmJ44qoafA2rt2OfuFEpVCgPd73CJzlcnE706E7Hyj8AQ)
Not sure why no one's posted a pure brainfuck solution yet, the brainfuck program I made this poem from amounts to only 108 bytes.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 13 bytes
```
ẹ{;Ẓ↔⟨a₁h⟩|}ᵐ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6kUFCUn1KanFpsxaX0cFen/aO2DY@amoCsh1snPOpY/nDHNiC7Fsj5/3DXzmrrh7smPWqb8mj@isRHTY0Zj@avrAHL/Y9WSkxKTklNS8/IzMrOyc3LLygsKi4pLSuvqKxS0lGqqqwoLystKS4qLMjPy83JzsrMSE9LTUlOSgRKZqTm5OQrlOcX5aQoxQIA "Brachylog – Try It Online")
This feels... bad.
```
ẹ{         }ᵐ    For each element of the input,
      a₁         output the suffix of
   Ẓ             the lowercase alphabet reversed
  ; ↔⟨  h⟩       for which the first element is the input,
          |      or the input if there is no such suffix.
```
A 9-byte [generator](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/10753#10753) is possible if spaces are completely ignored: [`∋;Ẓ↔⟨a₁h⟩`](https://tio.run/##SypKTM6ozMlPN/pfXa6kUFCUn1KanFpsxaX0cFen/aO2DY@amh5uWwDkPNw64VHH8oc7tgHZtUDO/0cd3dYPd0161Dbl0fwViY@aGjMezV/5/3@0UmJSckpqWnpGZlZ2Tm5efkFhUXFJaVl5RWWVko5SVWVFeVlpSXFRYUF@Xm5OdlZmRnpaakpyUiJQMiM1JydfoTy/KCdFKRYA). Accounting for spaces brings it up to the same byte count:
# [Brachylog](https://github.com/JCumin/Brachylog), 13 bytes
```
∋{;Ẓ↔⟨a₁h⟩!|}
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6kUFCUn1KanFpsxaX0cFen/aO2DY@amh5uWwDkPNw64VHH8oc7tgHZtUDO/0cd3dXWD3dNetQ25dH8FYmPmhozHs1fqVhT@/9/tFJiUnJKalp6RmZWdk5uXn5BYVFxSWlZeUVllZKOUlVlRXlZaUlxUWFBfl5uTnZWZkZ6WmpKclIiUDIjNScnX6E8vygnRSkWAA "Brachylog – Try It Online")
[Answer]
# [Scala](http://www.scala-lang.org/), 53 bytes
```
def f(s:String)=s.map(c=>('a'to c).reverse.mkString) 
```
[Try it online!](https://tio.run/##LctBCsIwEEDRvacYummyyQGEFjxAV55gTCa2dpqEzKBC6dmjiOv/vnhkbPn2IK8w4ZKA3kopCFxKgb0FihCNnK9al3S3g7gNi/HDaHrsNYO3rtKTqpDb1j@CFk03E3OGV64cOvubyjcqJ3s62gc "Scala – Try It Online")
Note: return the list of strings. To do the actual output, use `.map(println)` or so
]