[Question]
  [
Let's start by defining a **reflection** of a character in a string:
> 
> Given a string with distinct lowercase alphabetical letters with no spaces such
>  as `abcdefg`, define a reflection of a letter in the string `c` as
>  moving it (without changing the order of any other letter) to a new
>  place in the string such that the number of letters originally to the
>  right of it is now the number of letters to the left of it.
> 
> 
> 
Thus, a reflection of the letter `c` in `abcdefg` would be `abdecfg`. *Explanation: there were 4 letters to the right of `c` and now, there are 4 letters to the left of `c`.*
Some more examples:
> 
> Reflecting the character `e` in `myfriend` would form the string `myefrind`
> 
> 
> Reflecting the character `a` in `axyz` would form the string `xyza`.
> 
> 
> Reflecting the character `b` in `abc` would form the string `abc`.
> 
> 
> Reflecting the character `d` in `d` would form the string `d`.
> 
> 
> Reflecting the character `e` in `ef` would form the string `fe`.
> 
> 
> 
For more information or to try out some test cases, [here](http://cpp.sh/7b7bx) is a (somewhat long) program I wrote in C++.
## The Challenge
Given a string with distinct lowercase letters, go through each character alphabetically and "reflect" it in the string.
*Clarifications: The letters in the string are from `a-z`, there are no spaces, the letters are unique, and the string is at least 1 letter long and at most 26 letters long.*
## Examples
> 
> Input: `dcba`. Output: `dcba`.
> 
> 
> 
*Reason: First, reflect the `a` as it is the character in the string that comes earliest in the alphabet. You will get `adcb`. Then, reflect the `b` as it comes next in the alphabet, to get `badc`. Then, reflect the `c` to get `cbad`, and then the `d` to get `dcba`.* 
---
> 
> Input: `myface`. Output: `fyecma`.
> 
> 
> 
*Hint: Go through the letters in the order `a, c, e, f, m, y`.*
---
> 
> Input: `a`. Output: `a`.
> 
> 
> 
---
> 
> Input: `acb`. Output: `bac`.
> 
> 
> 
---
> 
> Input: `cwmfjordbankglyphsvextquiz`. Output: `ieabhqzugdltkfnvpjxsormycw`.
> 
> 
> 
## Scoring
* The input and output can be given by [any convenient method](http://meta.codegolf.stackexchange.com/q/2447/42963).
* Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
* [Standard loopholes](http://meta.codegolf.stackexchange.com/q/1061/42963) are forbidden.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so all usual golfing rules apply, and the shortest code (in bytes) wins.
* Accepting ~100 hours after posting.
## Current Winner
```
<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 162891; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 12012; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>
```
  
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 188 bytes
```
<>((((()()()){}){}()){}){(({}[()])<({}[(((((()()()()()){}){}){})()){}{}])<>{<>(({})<({}<>({}<>))((){[()](<{}>)}{}){{}(<({}<([]<<>{({}<>)<>}<>>){({}[()]<({}<>)<>>)}{}>)>)}{}>)<>}<>{}<>>)}<>
```
[Try it online!](https://tio.run/##RY1LCgNBCESvYy3mBuJFhll0hgyEfBbZBfHspjQdplvKQl7p5T1ur@V4jHummtRDfXiwZhfxWAUbtM1JnWRVew9i5rWLowrQlgAMea0R9TBEhXiiEVk3ZeoHqlENPq/qf9oZw2xNeZOUzOfnGPs1l/0L "Brain-Flak – Try It Online")
In addition to the reflections described in the challenge specification, this code also reverses the string exactly 26 times. This has no effect on the final output.
```
# Push 26
<>((((()()()){}){}()){})
# Do 26 times:
{(({}[()])<
  # Subtract 122 from counter to get negative lowercase letter
  ({}[(((((()()()()()){}){}){})()){}{}])
  # For each character in string:
  <>{
    # Keep a copy of pivot letter on the third stack
    <>(({})<
    # Move next letter to other stack and compare to pivot
    ({}<>({}<>))
    # If letters are equal:
    ((){[()](<{}>)}{}){
      # Keep current letter separate from this transformation
      {}(<({}<
      # While keeping a copy of current stack height:
      ([]<
        # Move all letters to one stack
        <>{({}<>)<>}<>
      >)
      # Move a number of letters equal to old stack height back
      {({}[()]<({}<>)<>>)}{}
      >)>)
    }{}>)<>
  }
  # Destroy pivot letter
  <>{}<>
>)}
# Switch stack for output
<>
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~20~~ 17 bytes
```
{vð.øy¡€áÂ€gsJ£yý
```
[Try it online!](https://tio.run/##MzBNTDJM/f@/uuzwBr3DOyoPLXzUtObwwsNNQCq92OvQ4srDe///Ty7PTcvKL0pJSszLTs@pLMgoLkutKCkszawCAA "05AB1E – Try It Online")
**Explanation**
With example for the first iteration of `myface`
```
{v                  # for each char y in sorted input
  ð.ø               # surround current string with spaces
                    # STACK: ' myface '
     y¡             # split at current letter
                    # STACK: [' myf', 'ce ']
       €á           # remove non-letters
                    # STACK: ['myf','ce']
         Â€g        # get the length of each string in the pair, reversed
                    # STACK: ['myf','ce'], [2,3]
            sJ      # join the pair back to a string
              £     # split into 2 pieces of the calculated sizes
                    # STACK: ['my','fce']
               yý   # join on the current char y
                    # STACK: 'myafce'
```
The string is surrounded with spaces each iteration as splitting on the first or last letter of the string would result in a length-1 list otherwise and the merge wouldn't include that letter.
[Answer]
# Pyth, ~~18~~ ~~16~~ ~~19~~ 16 bytes
```
VSQ=QXx_QN-QNN)Q
```
[Try it here](https://pyth.herokuapp.com/?code=VSQ%3DQXx_QN-QNN%29Q&input=%22ofxckieuqht%22&debug=0)
### Explanation
```
VSQ=QXx_QN-QNN)Q
VSQ           )       For each character (N) in the sorted input (Q)...
          -QN         ... remove the character from Q...
      x_QN            ... get the reflected position...
     X       N        ... insert N...
   =Q                 ... and save the result into Q.
               Q      Output the final result.
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~80~~ 73 bytes
Thanks to Esolanging Fruit for reminding me that functions can return by modifying their argument. 
```
lambda x:[x.insert(len(x)+~x.index(i),x.remove(i)or i)for i in sorted(x)]
```
[Try it online!](https://tio.run/##NYwxDoMwDEV3TpHNiUpZuiHRiwCDIY6aCpwqWFVYevU0UdXl@/np679OeQS@ZTdMecN9sahSP6bO80FR9Eask7l8qrCUtDdt6iLt4U2FQ1TeuJrKszpCFLKlPufqpLgREFoFuC717KfDlSrZdUGY@0a9omfR0hLbASa53icB0ygZNn8Ub/4NVxjZAnTP4Lk8Jv/Wvg "Python 3 – Try It Online")
Takes input as a list of characters.
[Answer]
# [Python 2](https://docs.python.org/2/), 70 bytes
```
def f(t):
 for c in sorted(t):i=t.index(c);l=len(t)+~i;t[l:l]=t.pop(i)
```
[Try it online!](https://tio.run/##JY7NEoIwDITvPEVuhVE5eITBF3E8QH8kWNpaooIHX72mekky@81mN2w0endMSWkDpqSqKcD4CBLQweIjaZVF7KhGp/Rayqq1ndWO1d0HWzrbxl6YBh9KrFL2UvaKXux5yCGveTO91PlScmAg5Gs2k49q6N3tarcwLk@90v2Bb8EFQkRHQAVQZ3Ehjip@3do/EHA48Q9RTx5zj/QF "Python 2 – Try It Online")
Modifies the input list
[Answer]
# [Ruby](https://www.ruby-lang.org/), 51 bytes
```
->s{s.sort.map{|c|s.insert~s.index(c),s.delete(c)}}
```
[Try it online!](https://tio.run/##PZBbbsMgEEX/vQo@ItFWLhuo6EaqqoJhiF9gh0di8ujWXQhJv@6co6sZaVyUadtpvr1/@otnfnaBGbFcrnD1rLceXfgtg8L1BV5bzxROGDDPt9umUBMXLentEkNL5hhyNqQy4TUZdML5bEdeeZYDQvjpVXY7/XWX3x9kqfU3Sgnnz11oVdOUE1SBFLR9ZFUmaQFYpE4I5qnvtX8AWVAKeAg4GT3MTklhx/2Uls4fcQ2H2J9Lr0chu8M57tUURm2Py7Dml5gEJ7r9AQ "Ruby – Try It Online")
Takes an array of chars
Returns by modifying the input
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 61 bytes
```
$
a
{`(.)(.*)\1$
$2$.`$*_$1$1
+`(.)_(_*.)
$2$1
}T`_l`l!`.$
!
```
[Try it online!](https://tio.run/##FcxLCsIwEADQ/dyiMEISYSBewgu4FDKTNK3VtPbnp4pnj@36wRvj3HSSd@rIGUHgy4q0IqPPFgEPSIzGoUUL@02ccob0BhZ@J3aJU8GEUEDOZfAC7VJJiGskwUN4tdX1PpZeuludlv4yPeN7Hh7N5w8 "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
$
a
```
Start the loop at `a`.
```
{`(.)(.*)\1$
$2$.`$*_$1$1
```
If the input contains the current letter, move it to the end, with a string of `_`s representing its original position.
```
+`(.)_(_*.)
$2$1
```
For each `_` move the letter back one character.
```
}T`_l`l!`.$
```
Increment the letter. After `z` change it to a `!` so it doesn't match anything and the loop ends.
```
!
```
Delete the `!`.
[Answer]
# Java 8, ~~140~~ ~~96~~ ~~92~~ ~~88~~ ~~87~~ 85 bytes
```
s->{for(char c=9;++c>0;){int i=s.indexOf(c);if(i>=0)s.add(s.size()+~i,s.remove(i));}}
```
-44 bytes creating a port of [*@TFeld*'s Python 2 answer](https://codegolf.stackexchange.com/a/162907/52210).  
-6 bytes thanks to *@OlivierGrégoire*.
Modifies the input List instead of creating a new one.
**Explanation:**
[Try it online.](https://tio.run/##jZE9b4MwEIb3/gqLyRbBylpRkKqsbTKkW9XBHCYxAUx9hnwp/evUfERtqkqtBIOP13fPPeSiFUGe7jooBCJ5Fqo63xGiKitNJkCSZX8kpNUqJUBzF@eNVQV/NEYcnxTah8VWGAEuHxNkoUtf3OsetMIqIEtSkYh0GMTnTBsKLk0gug99H@J5yM5uFFERclWl8rDKKLBQZVTF0ZwhF2lKkaM6Scr8DzVDbmSpW0kVY@Hl0oXjqLpJCjdqmjiwlm4TurZGVZvXN8HGLaxES70UEuENpNdKeex3va39iAhIbguwL7NcmzQR1W5THOsttvJg3xt18iYLXw4GouHaSOREjUB/@OyvOHmV3P@WdGZ6m0gZL0X9oldJTiGIB8UMGAddFBLst5@G1khR8sX4QRvkVg@dGJt2qzjQfup0XB/RypLrxvLagdvi6pTn2vn1vNnAODUeQagMYul73v8A@j6uX08wabt0nw)
```
s->{                     // Method with ArrayList<Character> parameter and no return-type
  for(char c=9;++c>0;){  //  Loop over all characters known
                         //  (except for the first 9 unprintables)
    int i=s.indexOf(c);  //   Index of the character, or -1 of it isn't present
    if(i>=0)             //   If the current character is present in the List
      s.add(s.size()+~i,s.remove(i));}}
                         //    Change the position of this character to index `l-i-1`,
                         //    (where `l` is the size of the input-List)
```
[Answer]
# JavaScript, ~~85~~ ~~80~~ 79 bytes
-6 bytes thanks to @DanielIndie
```
a=>[...a].sort().map(i=>a.splice(s=a.indexOf(i),1)&&a.splice(a.length-s,0,i))&&a
```
[Try it online!](https://tio.run/##PY9dboMwEISfyzF4iGzVsdoDmCv0AFGkLPYalvgv2CGQqmenULV9GumbGY1mgAmyHimVY4gGV6tWUM1JSglnmeNYGJceEiPVgMzJkUaWFUgKBucPy4iLd/76b4F0GLrSH7N4E8T54QBrwVwUo5AEzomr5rN60THk6FC62DHL9rXNPnM5RAqXi1J7sPqq9iar/WJBYy1qu6D2UPNfbnQLG/2RP6Yf3g5xNC2Ea@eW1OcJ53K703NLEkLb3573zrhytWFKw7w99It@1Hz9Bg "JavaScript (Node.js) – Try It Online")
[Answer]
# [Red](http://www.red-lang.org), 96 94 bytes
2 bytes saved thanks to Kevin Cruijssen 
```
func[x][foreach c sort copy x[i:(length? x)+ 1 - index? find x c insert at replace x c""i c]x]
```
[Try it online!](https://tio.run/##TYuxEsIgEET7fMUNlY5jYZsm/2DLUJDjSNAEkJB48ecRGyfVztvdl8iUOxmpGtsWu3qUrKQNiTSOgLCElAFD3IGla08T@SGPHfD5Aje4gvOGuANbE7jenV@oCjpDojhppF8rhANUrEpMzmewIDT2ovmTwV4fcN5tFQ/FccT3bB8hmV775zDtcVw24vxa3UeULw "Red – Try It Online")
More readable:
```
f: func[x][
    foreach c sort copy x[                  ; for each symbol in the sorted input
       i: (length? x) + 1 - index? find x c ; find its index and reflect it 
       insert at replace x c "" i c         ; remove it by replacing it with an empty char 
                                            ; and insert the symbol at its new index   
    ]
    x                                       ; return the transformed string
]
```
[Answer]
# [R](https://www.r-project.org/), ~~73~~ ~~72~~ 69 bytes
```
function(s){for(x in sort(s))s=append(s[x!=s],x,match(x,rev(s))-1);s}
```
[Try it online!](https://tio.run/##FY7BDsIgEETP@hW1l7IJHjybfol62G7BohSQpZVq/PZKL5OZybxk4qrbVU@OkvFOMHy1jyJXxlXsYyoFcIshKNcLvuRDyzeZ5YiJBpFlVPO2OJ7gzL91I3kjSdRYyxqpK9pTt4Vx0UiqGHqP@uFj36F73u0SBp5VTq/JfGqAar8jTCIgJyW0mJw1XE6kyMGaYmTTAIAkby0GVm2Jsrm6BtY/ "R – Try It Online")
Inputs and outputs a vector of characters.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~12~~ 11 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
W;ṢḟṁUṣ¥jʋ/
```
A monadic link accepting a list of characters and returning a list of characters.
**[Try it online!](https://tio.run/##ATkAxv9qZWxsef//VzvhuaLhuJ/huYFV4bmjwqVqyosv////Y3dtZmpvcmRiYW5rZ2x5cGhzdmV4dHF1aXo "Jelly – Try It Online")**
### How?
```
W;ṢḟṁUṣ¥jʋ/ - Link: list of characters V  e.g. "myface"  ...i.e. ['m','y','f','a','c','e']
W           - wrap V in a list                 ["myface"]
  Ṣ         - sort V                           ['a','c','e','f','m','y']
 ;          - concatenate                      ["myface",'a','c','e','f','m','y']
          / - reduce with:
         ʋ  -   last four links as a dyad:
            -   (i.e. start with "myface" on the left and 'a' on the right 
            -         2nd iteration has that result on the left and 'c' on the right
            -         and so-forth)            e.g. left = myface, right = 'a'
   ḟ        -     filter out (right from left)      "myfce"
       ¥    -     last two links as a dyad:
     U      -       upend left                      "ecafym"
      ṣ     -       split at occurrences of right   ["ec","fym"]
    ṁ       -     mould (ḟ(x,y)) like (Uṣ¥(x,y))    ["my","fce"] 
         j  -   join with right                   "myafce"
```
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 37 bytes
```
#!/usr/bin/perl -p
for$a(a..z){s/$a//&&s/.{@{-}}$/$a$&/}
```
[Try it online!](https://tio.run/##Dcg5EoQgEADAnHdQ1BrIRJvvVwYEj1VB8EKKrzvaYXsTxi@RdYHjB6W8qhyBI4AQEWT@5boU/gYXUIgarZBNyaI2DLVi@pjs4EKjcP63Y/Jd3M25Llt/sdv5tXdzpNo/ "Perl 5 – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~23~~ 22 bytes
```
¬n rÈ+S kY iYJ-XbY)x}U
¬n                     // Split the input into chars and sort it.
   r                }U // Then reduce the result with initial value of the input.
    È+S                // Append a space for replacing edge cases and
        kY             // remove the current char from the string.
           iY          // Insert it back
             J-XbY     // at the calculated index,
                  )x   // and remove the unnecessary space once we're done.
```
Saved one byte thanks to [Oliver](https://codegolf.stackexchange.com/users/61613/oliver).  
[Try it online!](https://tio.run/##y0osKPn//9CaPIWiwx3awQrZkQqZkV66EUmRmhW1of//K@VWpiUmpyoBAA)
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), ~~15~~ ~~12~~ 10 bytes
```
s(n/₌ṅtLnṀ
```
Thanks to @AndrovT and @TheThonnu!
[Try it Online!](https://vyxal.pythonanywhere.com/?v=1#WyJ+IiwiIiwicyhuL+KCjOG5hXRMbuG5gCIsIiIsIiFJbnB1dDogKFteXFwuXSspXFwuIE91dHB1dDogKFteXFwuXSspXFwuXG5JbnB1dDogbXlmYWNlLiBPdXRwdXQ6IGZ5ZWNtYS5cbklucHV0OiBhLiBPdXRwdXQ6IGEuXG5JbnB1dDogYWNiLiBPdXRwdXQ6IGJhYy5cbklucHV0OiBjd21mam9yZGJhbmtnbHlwaHN2ZXh0cXVpei4gT3V0cHV0OiBpZWFiaHF6dWdkbHRrZm52cGp4c29ybXljdy4iXQ==)
[Answer]
## Haskell, 87 bytes
```
s#c|(h,_:t)<-span(/=c)s,(v,w)<-splitAt(length t)$h++t=v++c:w|1<2=s
f s=foldl(#)s['a'..]
```
[Try it online!](https://tio.run/##Hci7DoIwGEDh3adoigltQIyOhA7uOjkSQkqhFCkF6Q@I4d3rZTjfcBS3baW1c9YTG1FhHgNNDnbghhyZoDYkc7j8j27gAkRXpgaFgO5VEACbg0DEy3ZKzszuJLJM9rrUxKM29bkfRZnreGMQQx0fbjkiwwR3GK8GRZKiFHer5KLCIea/RPFVLJ189GNZcNPWeh2UnasXPKfmjTP3AQ "Haskell – Try It Online")
```
f s=foldl(#)s['a'..]         -- fold the function '#' into all characters from 'a'
                              -- with the starting value of the input string s
s#c=                          -- in each step (s: result so far, c: next char)
   (h,_:t)<-span(/=c)s        -- let 'h' be the substring before 'c' and
                              -- 't' the substring after 'c'. the pattern match
                              -- fails if there's no 'c' in 's'
   (v,w)<-splitAt(length t)$h++t
                              -- split the string 'h++t' at index length of t
   =v++c:w                    -- return 'v' followed by 'c' followed by 'w'
   |1<2=s                     -- if there's no 'c' in 's', return 's' unchanged             
```
[Answer]
# [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/csnobol4/), ~~132~~ 128 bytes
```
	DEFINE('I(I)')
I	U =&LCASE
N	U LEN(1) . K REM . U	:F(RETURN)
	I ARB @S K	:F(N)
	I K =
	I ARB . L RPOS(S) REM . R
	I =L K R	:(N)
```
[Try it online!](https://tio.run/##XU7JCsIwFDynX/FONrkUBE@FgNWkEBrTkjQf4L7VVq37z8cU9eJphtmYtm5mTTVwKMaMOMR4KhTHocCChCQQyALtyXFieKA8l1zhPoEIMtB84tGiOMWal1YrEiABiR7B0EDWyR8lA/ozIpCgi9xgQ7513VlUdnP@gCKO/T9AuS0LWwIVOJzfD6tdc17MpvV@XT2Pm/a2fFxO1@3LB7li7g0 "SNOBOL4 (CSNOBOL4) – Try It Online")
Straightforward implementation of the required algorithm. Saved a few bytes by switching to a function rather than a full program; the explanation remains the same, more or less.
```
	I =INPUT			;* read input
	U =&LCASE			;* alias for lowercase letters (it started out as uppercase)
N	U LEN(1) . K REM . U	:F(O)	;* set K to the next lowercase letter, and when empty, goto O
	I ARB @S K	:F(N)		;* set S to the number of letters before K, or goto N
	I K =				;* remove K
	I ARB . L RPOS(S) REM . R	;* set R to the last S characters of I and L to the others
	I =L K R	:(N)		;* recombine the string and goto N
O	OUTPUT =I			;* print new string
END
```
[Answer]
# [C (clang)](http://clang.llvm.org/), ~~164~~ 162 bytes
```
y,n,a,b,c,p,i;f(char*s,l){for(i=0;p=0,++i<123;p<l&&(y=s[p],n=l+~p,a=p+1,b=p,n<p&&(a=n,b=n+1),c=l+~(2*(n<p?n:p)),memmove(s+b,s+a,c),s[n]=y))while(s[p]^i&&p<l)p++;}
```
[Try it online!](https://tio.run/##dZBNktsgEIX3OgXlVFxCIjP2ZDeyknVWOYDjVAECCRsQBiRZnppc3UHWj2czu9ffe003Tb9RiXV5@yI0lU3BwM75QtRP1Y/oI7JCl4HdeqQRRgRRZJDIeEwrbBOHJHzjtY1FvslMvkFpKnbbl@@Z2cn1Ou5ztzcHpHOZ/jMI5ybdIpIbpHcmuDjXodLpFiI6JOKXJA7OT/1qIESKKVW3LHYpQS7FiELk9vqQ9xB2lZDBCE//Fet1GAVNmmbvN4qlHBcDiYPgLQImbO95vPqlTeNfwf6rO4Dfjb8XKwQczCLAYxeUt5Lp2MGBzF1D/I@ecu9RFChQWOh4ePs@Bu8PIAerghK8ykZERqR6jimbIR3hEiqmmpKZsJHQTvFjbQuC9amUvalcyy7@3IjrHORTK6EF42UljiepdG3O1vmm7S79EizH4LW/dG3jnT2bWit5Ooqq5GzaOBpPhsP/RkUWRRdVLIotii@qDCqyzDdWg81wpuckms49DHla7n2vZms8z8PkPaMKz@6Hrgej5EEJpjP//GKPuGCYVOdrUxbSn7huzfHiaqt62kXJ8@0/ "C (clang) – Try It Online")
`f()` takes char-array containing input string and length of this array as parameters and performs required reflections in place.
`callf()` does pretty-printing.
# Credits
-2 bytes. @Kevin. Thanks
[Answer]
# APL+WIN, 63 bytes
Prompts for input string
```
l←s[⍋⎕av⍳s←,⎕]⋄⍎∊(⍴s)⍴⊂'s←(n←⌽~s=↑l)\s~↑l⋄((~n)/s)←↑l⋄l←1↓l⋄'⋄s
```
Explanation:
```
l←s[⍋⎕av⍳s←,⎕] sort characters into alphabetical order
⍎∊(⍴s)⍴⊂'....' create an implicit loop for each character
s←(n←⌽~s=↑l)\s~↑l⋄((~n)/s)←↑l do the relection for first character in l
l←1↓l drop the first character in l
s display the result
⋄ statement separator
```
[Answer]
# [Perl](https://www.perl.org/), ~~74~~ 70 bytes
~~84~~ 80 bytes including invocation as unix filter
```
for$c(a..z){if($p=1+index$_,$c){substr$_,$p-1,1,"";substr$_,-$p,0,$c}}
```
```
$ echo -e 'dcba\nmyface\na\nacb\ncwmfjordbankglyphsvextquiz' |
> perl -pE'for$c(a..z){if($p=1+index$_,$c){substr$_,$p-1,1,"";substr$_,-$p,0,$c}}'
dcba
fyecma
a
bac
ieabhqzugdltkfnvpjxsormycw
```
]