[Question]
  [
## Challenge
Robin likes having his variables declaration in the shape of an arrow. Here's how he does it:
* Input any number of strings
* Order them by ascending length
* Output them ordered by the middle to roughly form a negative arrowhead, like this (whichever order golfs the best):
```
5  or  4
3      2
1      1
2      3
4      5
```
## Test Cases
Input:
```
bow
arrows
sheriffOfNottingham
kingRichard
maidMarian
princeJohn
sherwoodForest
```
Output:
```
sheriffOfNottingham
kingRichard
maidMarian
bow
arrows
princeJohn
sherwoodForest
```
Input:
```
a
bb
cc
```
Output (both are valid):
```
bb
a
cc
cc
a
bb
```
Input:
```
one
four
seven
fifteen
```
Possible output (the only other valid output is its vertical mirror):
```
seven
one
four
fifteen
```
## Notes
* The strings are in camelCase and have no numbers or special characters, only lowercase and uppercase letters.
* The input can be anything you like: comma-separated as one string, array, ... Any I/O format is allowed.
* Between strings with the same length, any order is accepted.
  
[Answer]
# [Python 2](https://docs.python.org/2/), 47 bytes
```
lambda l:l.sort(key=len)or l[1::2][::-1]+l[::2]
```
[Try it online!](https://tio.run/##NU6xjsIwDN35CisLoJaTYIzUGxlOujvp1pAhbZNLRBqjJFLF1xcb6PLs5/ee7du9ekynxXWXJZqpHw1EGT8K5rq72nsXbdpjhqiOUp60kvJw1E1UTJZqSy3QgVKieJuDc7/uB2sN6d@bSbTiSt1fGLzJI7HJhPHb5GASkR5nQpMzzoWaWw5psF/oWeNlM@J4xkwXhG5BCcOZnmAYXoNGtCCaN66lEVpvHP3Lr0FIz1rkBoAP1CdtYXv43NKIfTEkyz63Y2nPztXL0hpcHg "Python 2 – Try It Online")
[Answer]
# [R](https://www.r-project.org/), ~~63~~ 48 bytes
```
function(L)c(rev(o<-L[order(nchar(L))]),o)[!0:1]
```
[Try it online!](https://tio.run/##HYw9C8IwFAD3/IqaKYEWdJW6OkhVcK0dnvkwQfpeeYnm58fqdMNxx9U3fddU/0aTI6EatFHsPor6bhiJrWOFJgCvQk@6JT1utvvdVA1k5VUygKqVUus2ueUg7yi1eFARwEwliRQcR@@v/kI5R3wGmMVr5S3@nlbMEO0ZOAKKhSMad6KA/6oQ2SOxS1nULw "R – Try It Online")
Sort by string lengths, then combine the reversed list with the sorted list, finally, take every 2nd element, starting at 1-based index 1.
[Answer]
# Javascript 77 bytes
Takes input as an array of strings, outputs an arrow-sorted array of strings.
```
s=>s.sort((a,b)=>a.length-b.length).reduce((m,x,i)=>i%2?[...m,x]:[x,...m],[])
```
## Explanation
```
s =>                                 // take input as an array of strings s
  s.sort((a,b)=>a.length-b.length)   // sort input by string length
  .reduce(                           // reduce
    (m,x,i)=>i%2?[...m,x]:[x,...m],  // if index is even, stick string x at the end of the memo
                                     // array, else at the beginning
    []                               // memo initialized to empty array
  )
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 51 bytes
```
->l{r=1;l.sort_by!(&:size).map{l[r-=2]||(l*2)[~r]}}
```
[Try it online!](https://tio.run/##VY3NDoIwEITvPgX2YEB@Ejlq8OjBRE28ksa00EojULItIQj46rUkauLl25ndnV1oaW94YsJ9OUCy2ZWRkqBvtF@6q60ST@ZFFWmGMoUwifE4uuU69tIX4GkyTauVw9MUqYKB4PzCz1JrUd8LUqEAPay6iqwgkFtXEZGfCAhSW0NlZ0kAZKesaEDUGTvKYp7Nxzop84MEpjTCePH7Q@Yotciyv76PAgf5H36Lb1fMGw "Ruby – Try It Online")
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 89 bytes
```
n=>(n=n.OrderBy(x=>x.Length)).Where((a,b)=>b%2>0).Reverse().Concat(n.Where((a,b)=>b%2<1))
```
[Try it online!](https://tio.run/##bY1BSwMxFITv@zMCQh6soXrtJoeKBYta6KUH9ZDNvjSh7ou8pG5F/O3rLuJJbzPDzDcuX7ocx/WJXHN3S6ce2bav2OTCkQ6m/iczXo@kjSRNassd8upDnrU5q3ukQwkAah@QUUpbt6BNe3FtFqB2@I6cUYK6SeRskfSn1lwBjMtqz7Gg/DlTmxRJimcStZeEw9PLZyXaNIi6EpY5DXlWeQJF77f@MZUyrYLt5/g4yV10wXI3297G7sFytDS7twnvcJMC/RKGlLp1YsxFVF8AsKzGbw "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 24 bytes
**Solution:**
```
x(<#:'x)(|&~w),&w:2!!#x:
```
[Try it online!](https://tio.run/##y9bNz/7/v0LDRtlKvUJTo0atrlxTR63cykhRUbnCSkMpKb9cyVopsagov7wYyCjOSC3KTEvzT/PLLynJzEvPSMwFimYDWUGZyRmJRSlAXm5iZopvYlFmYh6QU1CUmZec6pWfkQfVXZ6fn@KWX5RaXKKk@f8/jS0AAA "K (oK) – Try It Online")
**Explanation:**
Generate the `6 4 2 0 1 3 5` sequence, use that to index into the ascending lengths of input, and use that to index into the original array:
```
x(<#:'x)(|&~w),&w:2!!#x: / the solution
                      x: / save input as x
                     #   / count (#) of x
                    !    / range 0 to ...
                  2!     / modulo 2
                w:       / save as w
               &         / indices where true
              ,          / join with
        (    )           / do this together
           ~w            / not (~) w
          &              / indices where true
         |               / reverse
 (     )                 / do this together
   #:'x                  / count (#:) of each (') x
  <                      / indices to sort ascending
x                        / index into x
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~9~~ 8 bytes
```
LÞŒœm"-Ẏ
```
[Try it online!](https://tio.run/##y0rNyan8/9/n8Lyjk45OzlXSfbir7//D3VsOt0f@/5@UX86VWFSUX17MVZyRWpSZluaf5pdfUpKZl56RmMuVDaSDMpMzEotSuHITM1N8E4syE/O4Cooy85JTvfIz8sC6yvPzU9zyi1KLSwA "Jelly – Try It Online")
```
LÞŒœṚ;¥/
```
is also 8 bytes. 
Thanks to @EriktheOutgolfer and @JonathanAllan for both offering golfs to save a byte. 
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~6~~ 5 bytes
Saved 1 byte thanks to *Kevin Cruijssen*
I/O is a list of strings.  
Link is modified for newline separated I/O for easier testing.
```
éι`Rì
```
[Try it online!](https://tio.run/##Hcu7CYAwEADQ/gazEFRwAs98zCHm5BJI40KCC4id6V0pitWrHgccyZSt5P05hz4f5b7KyAlQhFOA4IyQtZ1tOUbyk8MF5s@elEPRsCDpBoXQwyrklanZ@X8lZl2xmBBf "05AB1E – Try It Online")
**Explanation**
```
é       # sort by length ascending
 ι      # uninterleave into 2 parts, both sorted ascending
   `    # push the 2 parts separately to the stack
    R   # reverse the second part
     ì  # and append it to the first
```
[Answer]
# [J](http://jsoftware.com/), 11 bytes
```
,~`,/@\:#&>
```
[Try it online!](https://tio.run/##HYu9CsIwFEb3PsWHgkWIUddqiyB0EH@gs6CxTUyU5spNIZuvHovD4SznvNJE5gZlgRwCKxQjC4l9c6yT@N7FcnctprMqzbNQSmw38rYeywdFKGaKAcFqdsZczJmGwfmnVT3eoxvXWsUdeuW6k2KnPD7sfKsPZP3/ikRdTazDkGeZbi2hgkFIPw "J – Try It Online")
We sort it down first.
Then we reduce the list form right to left, but alternating which side we put the new element on. Done.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 66 bytes
```
1..($a=$args|sort l*).count|?{$_%2}|%{$a[-$_];$x=,$a[-++$_]+$x};$x
```
[Try it online!](https://tio.run/##FYhLCoMwEECv0sVItNFA3Yr0ICISZNRCyEgSq2A8@xhX77PSjs4vaAzzR6kcdAvazT56cuFl3oUaabMhfk8YsvqK2Qm6q2DoGzja8nEpU0k4rnSYWZBFwWKizT34TQHRJvP4T7wB "PowerShell – Try It Online")
Takes input via splatting, which manifests on TIO as separate command-line arguments. `sort`s on the `l`ength, stores that into `$a`, and constructs a range from `1` up to the `count` of input strings. We then pull out only the odd ones `?{$_%2}` and feed those into a loop `|%{...}`. Each iteration, we put the "last", then the "third from last", and so on onto the pipeline with `$a[-$_]`. Separately, we also accumulate into `$x` the "second from last", "fourth from last", etc. Out of the loop and the pipeline is flushed (so those elements are output) and then we output `$x`. In both instances, the default output gives us newlines between items automatically.
[Answer]
# [PHP](https://php.net/), ~~144~~ 141 bytes
```
function($a){usort($a,function($b,$c){return strlen($b)-strlen($c);});$e=[];foreach($a as$d)(array_.[unshift,push][++$i%2])($e,$d);return$e;}
```
[Try it online!](https://tio.run/##RZBBTwMhEIXP7q/ggNklRWO8YuNJY4zaxutm07DsIMQWyMDamKa/fQXbTS/wvcfkzQzBhOnhMZhAANHjBiF4TNZ9NXdMEKqXkx6dSta7hkp2GGN@zcQvbs@pYgeENKIjMeEWisluZlRMHJmgsGw7oT2CVCYHEBnpwBqJKH83t@3oorE68TBG07WLBbXX9x1rKPBcJU7hFMRxEhVNEFMkS9JWhLR17/c1J3UO8vtYKBpAq/VKf/hUFjFyV@zvjJ9WGYlDkTtph3eJVrqiAlqn4NUbNyfsvR@e87Qx1R3/byRrXvd9PpSaLe8ga@1HzFeEH3BF5j0gU67pRFXNK5Pz3DJmIowcqitQxhO7C1s/QEPWL@vN0@qN509vTiWMX8wziOo4/QE "PHP – Try It Online")
-3 bytes thanks to [@Ismael Miguel](https://codegolf.stackexchange.com/users/14732/ismael-miguel)!
[Answer]
# MATLAB, 87 bytes
```
function f(y);[B,I]=sort(cellfun(@(x)length(x),y));{y{flip(I(1:2:end))},y{I(2:2:end)}}'
```
Takes input as cell array of strings, outputs column of strings (not sure if that's legal)
```
> s = {'qweq qwe qw','qweqw','12132132131231231','asdasdasda','qwe','w'};
> f(s)
> >> 
> ans =
> 
>   6×1 cell array
> 
>     {'qweq qwe qw'      }
>     {'qweqw'            }
>     {'qwe'              }
>     {'1234'             }
>     {'asdasdasda'       }
>     {'12132132131231231'}
```
PS: Thanks Sanchises for pointing to a bug with odd-length inputs
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 18 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
```
{⍵[⍋-@(2∘|)⍋⍋≢¨⍵]}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///v/pR79boR73dug4aRo86ZtRoAtkg1Lno0AqgVGzt/7RHbRMe9fY96pvq6f@oq/nQeuNHbROBvOAgZyAZ4uEZ/B8okKYANsn@Ue8KoF6wTp1DK3RigEoSAQ "APL (Dyalog Unicode) – Try It Online")
Fixed the bug thanks to @ngn.
Explanation:
```
{⍵[⍋-@(2∘|)⍋⍋≢¨⍵]}
{                } ⍝ Function. Takes a single argument: ⍵, list of strings
             ≢¨⍵   ⍝ The length of each element in the list
           ⍋⍋      ⍝ Sort the lengths
    -@(2∘|)        ⍝ At (@) elements divisible by 2 (|), negate (-)
                   ⍝     gives -1 2 -3 4 -5
   ⍋               ⍝ Sort this list again, gives the indices of that list ^ sorted
 ⍵[             ]  ⍝ Use these indices to index into the argument
```
---
[¹](https://github.com/vendethiel/trying.apl/blob/master/ex/arrow-strings.dyalog)
[Answer]
# APL+WIN, ~~31~~ 38 bytes
See Adams comment
```
⊃n[(⍳⍴n)~a],⌽n[a←2×⍳⌊.5×⍴n←n[⍒∊⍴¨n←⎕]]
```
[Try it online Courtesy of Dyalog Classic!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob6qvz6O2CcZcjzra0/4/6mrOi9Z41Lv5Ue@WPM26xFidRz1786ITgSqMDk8Hifd06ZmCWFvygGJ50Y96Jz3q6AJyD60ACQCNi439DzTqfxqXuqGRugKQMDbBR5mamVsQZgIA "APL (Dyalog Classic) – Try It Online")
Prompts for a nested vector of strings
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 26 bytes
```
N$`
$.&
*\,2,^A`.+
,2,G`.+
```
[Try it online!](https://tio.run/##HctBCoMwEEDR/ZwjuKgi2Bt0Y0FQwbWIU5M0g5iRSSDHT0NX72@@mEgeu5wntYNqK3iszbPZXntbQ4l3MecPJ0ARTgGCM0LWznbiWM6vwwvO4kKHQ9FwIekRhdDDLeQPM7Dz/ysx657FhPgD "Retina – Try It Online") Explanation:
```
N$`
$.&
```
Sort the lines in ascending order of length (`$.&` returns the length of the line).
```
*\,2,^A`.+
```
Temporarily delete alternate lines and output the remaining lines in reverse order.
```
,2,G`.+
```
Keep the only lines that were temporarily deleted and output them.
[Answer]
# [Gaia](https://github.com/splcurran/Gaia), 10 bytes
```
el∫v:v+2%ụ
```
[Try it online!](https://tio.run/##S0/MTPz/PzXnUcfqMqsybSPVh7uX/v8f/ahhTlJ@@aOGuQpAVmJRUX55MZRTnJFalJmW5p/ml19SkpmXnpGYC5XJBvKCMpMzEotSoCK5iZkpvolFmYl5UIGCosy85FSv/Iw8JNPK8/NT3PKLUotLgIKxAA "Gaia – Try It Online")
```
e		| eval as Gaia code (list of strings)
 l∫		| ∫ort by lengths (ascending)
   v:v		| reverse, dup, reverse
      +		| concatenate lists
       2%	| take every other element
         ụ	| join by newlines and output
```
[Answer]
# Japt, 8 bytes
```
ñÊó g0_w
```
-3 bytes thanks to Shaggy!
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=8crzIGcwX3c=&input=WyJib3ciLAoiYXJyb3dzIiwKInNoZXJpZmZPZk5vdHRpbmdoYW0iLAoia2luZ1JpY2hhcmQiLAoibWFpZE1hcmlhbiIsCiJwcmluY2VKb2huIiwKInNoZXJ3b29kRm9yZXN0Il0KLVE)
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 49 bytes
```
$args|sort l*|sort{$_.Length*($global:x=-$x*2+1)}
```
[Try it online!](https://tio.run/##RY3NCsJADITvfYoeFlcrCnoUvHoQf8AXkLTNdhe3G8muVlCfvcYf8JLMTPgmZ@qQo0Xve2XyZX7vFXATH5E45b747Ls6TjcYmmSLoWo8leAXt@VE3Yr5eDZ69s8sGwisS@p0roGZuihCWtkZszc7SsmFxkIr6UnUwVUWuBbXgqu3wA6CmDO7UOGabPjRHVG9IsaYdKb19wnIrSxlVNU/pICSGLrwm8QrvhuMMwlF9S8 "PowerShell – Try It Online")
The double [distillation](https://en.wikipedia.org/wiki/Distillation).
[Answer]
# T-SQL, 84 bytes
Input is a table variable
```
SELECT a FROM(SELECT*,row_number()over(order by len(a))r
FROM @)x order by(r%2-.5)*r
```
**[Try it online](https://data.stackexchange.com/stackoverflow/query/1023281/arrow-those-variables)**
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 31 bytes
```
*.sort(&chars).sort:{$++%2*$--}
```
[Try it online!](https://tio.run/##HY09C8JAEET7/IpFoiTGWFhY@JHSQlDBWpBLsuedml3ZOw1B/O2nsXozxZt5oNznoelgpGEdxlPH4pNRZZS49F8W7zjLhrNxnOefsIyc6kAn8TmdXtlSMjjRIJ1AD9As0arkFpQItw6cQbFaH/Sevbd0MaqB249H28/X0Chb75RYRfAQSxVu2dDfapnrDQs6X0yilYKyhKrqIxP@bp4CDl9IoK32iFSELw "Perl 6 – Try It Online")
Sort by string length, then by static sequence 0, -1, 0, -3, 0, -5, ...
[Answer]
# Javascript 95 Bytes
```
s=>s.sort((x,y)=>x.length-y.length).reduce((a,e,i)=>{i%2?a.push(e):a.unshift(e);return a;},[]);
```
[Answer]
# [Red](http://www.red-lang.org), ~~116~~ 101 bytes
```
func[b][sort/compare b func[x y][(length? x)> length? y]collect[forall b[keep take b]keep reverse b]]
```
[Try it online!](https://tio.run/##jY09TwMxDIb3/gorU5nYGcrGgARIXaMMTuI00d3FJ1/Ktb/@6hSQYGNJntd6P4TidqRo3S49belcg/XOLiztMfA0oxB4uJ8vcHV2P1I9tfwMl4cD/PDVBR5HCs0mFhxH8HYgmqHhoGl3Z6FPkqVLt6mLMGRYIYE1aMB4r08IxoGdpdQGq4MvMGb3186V1Jv4LPot2lq7LKmR0j/ynlcNoAivS2/IJCWlj/TOrZV6yjjpdVA6lpBRoqoJS3xDKdinem2gV871O70yxxedWNrv@e0G "Red – Try It Online")
[Answer]
# perl 5 (`-p0777F/\n/ -M5.01`), 59 bytes
```
for$x(sort{$b=~y///c-length$a}@F){--$|?$\="$x
".$\:say$x}}{
```
[TIO](https://tio.run/##HcvBCoIwGADg@x5DdqjDmh1ECKROHgILOnuZurmR7h//Bipmj96KTt/pcxKHLEYFSOedBwwrbYr3wjlv2SBtHzQV26Xcr4zR15nWRUJnkhxoffJiofO2rTE2MBGBCJMnXks0St3VDUIwttdiJM@fD9NqgR0ZhekqgUZY4tDYVl5B2/@aALoSUPpAPuCCAesjc2me5yWvLY@syg7p8Qs)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~136~~ 128 bytes
```
S(a,b)int**a,**b;{a=strlen(*b)-strlen(*a);}f(l,s,o,i,b,e)int**s,**o;{qsort(s,l,8,S);e=l-1;for(i=b=0;i-l;)o[i++%2?b++:e--]=s[i];}
```
[Try it online!](https://tio.run/##NY89b8MgEIb3/goUKRIfh5R0qkpQ50rd0s31AMh2kCikQDLU8m@nENe38KKH5@4wfDKmlDNWoIn1mVIFlGoxK5lydIPHVBO@RUXEMmIHCQJY0DCsSqpKEPNPCjHjBA5e4EzEIB0/ijFEbKWWB2G5EyR0lrH985tm7HXgvJeps71YSu2DvpX1uAUVJwPIXFREtOZ71xM0P6FajVrxiCum4Zavt4xktZ0LBif7O4QRN0oJxa0VPxKyOuP/HdqIO6vnqm84RFSXPQhkT@tDgRiz5AFbXWNdYMS7ffryu02uH6j@UspH8NMQCy@fF@XLe/4D "C (gcc) – Try It Online")
-8 bytes thanks to ceilingcat.
The function `f` is the solution. It takes the number of strings, the strings themselves, and the output buffer as arguments (plus four more used internally).
[Answer]
# [Husk](https://github.com/barbuz/Husk), 11 bytes
```
m!ÖL¹Ċ2§+ṡŀ
```
[Try it online!](https://tio.run/##yygtzv7/qKnx0Lb/uYqHp/kc2nmky@jQcu2HOxcebfj//39SfjlXYlFRfnkxV3FGalFmWpp/ml9@SUlmXnpGYi5XNpAOykzOSCxK4cpNzEzxTSzKTMzjKijKzEtO9crPyAPrKs/PT3HLL0otLgEA "Husk – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `a`, 7 bytes
```
µL;yṘ$"
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=a&code=%C2%B5L%3By%E1%B9%98%24%22&inputs=abcd%0Aabc%0Aab%0Aa&header=&footer=f%E2%81%8B)
Outputs as a list of two lists of lines.
The header and footer allow for multiline IO.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~8~~ 6 bytes
Input as an array of lines, output as an array of 2 arrays of lines, one for each half of the list.
```
ñÊó vw
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&header=tw&code=8crzIHZ3&footer=VmO3tw&input=Im9uZQpmb3VyCnNldmVuCmZpZnRlZW4i) (Header & footer allow for I/O as newline separated string)
```
ñÊó vw     :Implicit input of array
ñ          :Sort by
 Ê         :  Length
  ó        :Uninterleave
    v      :Modify first element
     w     :  Reverse
```
[Answer]
# [Julia 1.0](http://julialang.org/), 41 bytes
```
!s=sort(s,by=length)[∪(end:-2:1,1:end)]
```
[Try it online!](https://tio.run/##JYwxbsMwDEV33iKaJCAd3NGB1w4FmgBd2w60RUVsHDKQlLpZMvcsOVYv4srp9D4@@d/neWRsvud5lbusqdi87i/dSLIv0b39/twsiW8fHttm3bQ1uo/5mjvrOZ9GvNhVBdeRc5tTYimjWPMuxjmAqzEGep0AU9IpQ46UOIRd2GopLPuIRzhUvvIQMXk4IvsXTIwCi2qgZ41yX02q/kkT5QKL8y5WIQh6TpDpiwQCh0KVy@n/AaHvYRiWZv4D "Julia 1.0 – Try It Online")
* input and output are vectors of strings
* `end:-2:1` takes every second index, starting from the end
* `1:end` is all indices
* `∪` (=`union`) removes duplicates
]