Arrow those variables!

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 1

Python 2, 47 bytes

lambda l:l.sort(key=len)or l[1::2][::-1]+l[::2]

Try it online!

Answer 2

R, 63 48 bytes

function(L)c(rev(o<-L[order(nchar(L))]),o)[!0:1]

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 3

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 4

Ruby, 51 bytes

->l{r=1;l.sort_by!(&:size).map{l[r-=2]||(l*2)[~r]}}

Try it online!

Answer 5

C# (Visual C# Interactive Compiler), 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!

Answer 6

K (oK), 24 bytes

Solution:

x(<#:'x)(|&~w),&w:2!!#x:

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 7

Jelly, 9 8 bytes

LÞŒœm"-Ẏ

Try it online!

LÞŒœṚ;¥/

is also 8 bytes.

Thanks to @EriktheOutgolfer and @JonathanAllan for both offering golfs to save a byte.

Answer 8

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!

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 9

J, 11 bytes

,~`,/@\:#&>

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 10

PowerShell, 66 bytes

1..($a=$args|sort l*).count|?{$_%2}|%{$a[-$_];$x=,$a[-++$_]+$x};$x

Try it online!

Takes input via splatting, which manifests on TIO as separate command-line arguments. sorts on the length, 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 11

PHP, 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!

-3 bytes thanks to @Ismael Miguel!

Answer 12

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 13

APL (Dyalog Unicode), 18 bytes^SBCS

{⍵[⍋-@(2∘|)⍋⍋≢¨⍵]}

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

---

¹

Answer 14

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!

Prompts for a nested vector of strings

Answer 15

Retina, 26 bytes

N$`
$.&
*\,2,^A`.+
,2,G`.+

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 16

Gaia, 10 bytes

el∫v:v+2%ụ

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 17

Japt, 8 bytes

ñÊó g0_w

-3 bytes thanks to Shaggy!

Try it

Answer 18

PowerShell, 49 bytes

$args|sort l*|sort{$_.Length*($global:x=-$x*2+1)}

Try it online!

The double distillation.

Answer 19

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

Answer 20

Perl 6, 31 bytes

*.sort(&chars).sort:{$++%2*$--}

Try it online!

Sort by string length, then by static sequence 0, -1, 0, -3, 0, -5, ...

Answer 21

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 22

Red, 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!

Answer 23

perl 5 (-p0777F/\n/ -M5.01), 59 bytes

for$x(sort{$b=~y///c-length$a}@F){--$|?$\="$x
".$\:say$x}}{

TIO

Answer 24

C (gcc), 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!

-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 25

Husk, 11 bytes

m!ÖL¹Ċ2§+ṡŀ

Try it online!

Answer 26

Vyxal a, 7 bytes

µL;yṘ$"

Try it Online!

Outputs as a list of two lists of lines.

The header and footer allow for multiline IO.

Answer 27

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 (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 28

Julia 1.0, 41 bytes

!s=sort(s,by=length)[∪(end:-2:1,1:end)]

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