挑战

罗宾喜欢用箭头来声明变量。他的做法如下：

• 输入任意数量的字符串
• 按长度顺序排列

• 将它们按中间顺序输出，大致形成一个负箭头，如下所示（以顺序最好的一个为佳）：

  5  or  4
  3      2
  1      1
  2      3
  4      5
  

测试用例

输入：

bow
arrows
sheriffOfNottingham
kingRichard
maidMarian
princeJohn
sherwoodForest

输出：

sheriffOfNottingham
kingRichard
maidMarian
bow
arrows
princeJohn
sherwoodForest

输入：

a
bb
cc

输出（均有效）：

bb
a
cc

cc
a
bb

输入：

one
four
seven
fifteen

可能的输出（唯一有效的输出是其垂直镜像）：

seven
one
four
fifteen

笔记

• 字符串在camelCase中，没有数字或特殊字符，只有小写和大写字母。

• 输入可以是您喜欢的任何内容：逗号分隔为一个字符串，数组等。允许任何I / O格式。

• 在相同长度的字符串之间，可以接受任何顺序。

Python 2，47个字节

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

在线尝试！

R，63 48字节

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

在线尝试！

按字符串长度排序，然后将反向列表与排序列表组合，最后，从基于1的索引1开始，获取每个第二个元素。

Javascript 77字节

将输入作为字符串数组，将箭头排序的字符串数组输出。

s=>s.sort((a,b)=>a.length-b.length).reduce((m,x,i)=>i%2?[...m,x]:[x,...m],[])

说明

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
  )

C＃（Visual C＃交互式编译器），89字节

n=>(n=n.OrderBy(x=>x.Length)).Where((a,b)=>b%2>0).Reverse().Concat(n.Where((a,b)=>b%2<1))

在线尝试！

K（ok），24个字节

解：

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

在线尝试！

说明：

产生 6 4 2 0 1 3 5序列，使用它来索引输入的递增长度，并使用它来索引原始数组：

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

果冻， 9 8字节

LÞŒœm"-Ẏ

在线尝试！

LÞŒœṚ;¥/

也是8个字节。

感谢@EriktheOutgolfer和@JonathanAllan都提供高尔夫运动来节省字节。

Ruby，51个字节

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

在线尝试！

05AB1E，6 5字节

由于节省了1个字节 Kevin Cruijssen

I / O是字符串列表。
修改了链接，以换行符分隔的I / O，以便于测试。

éι`Rì

在线尝试！

说明

é       # 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

J，11个字节

,~`,/@\:#&>

在线尝试！

我们先将其分类。

然后，我们从右到左缩小列表形式，但交替放置新元素在哪一侧。做完了

PowerShell，66字节

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

在线尝试！

通过splatting获取输入，该显示在TIO上为单独的命令行参数。 sort上的s l，将其存储到中$a，并构造从输入字符串1到的最大范围count。然后，我们仅取出奇数个，?{$_%2}并将它们送入循环|%{...}。每次迭代时，我们将“ last”放进去，然后将“ last from第三位”放进去，以此类推$a[-$_]。另外，我们还将累积到$x“倒数第二个”，“倒数第四个”等。从循环中取出并冲洗管道（以便输出这些元素），然后输出$x。在这两种情况下，默认输出都会自动为我们提供项目之间的换行符。

的PHP，144 141字节

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;}

在线尝试！

-3个字节，感谢@Ismael Miguel！

MATLAB，87字节

function f(y);[B,I]=sort(cellfun(@(x)length(x),y));{y{flip(I(1:2:end))},y{I(2:2:end)}}'

将输入作为字符串的单元格数组，输出字符串列（不确定这是否合法）

> 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：感谢Sanchises指出带有奇数长度输入的错误

APL（Dyalog Unicode），18 字节^SBCS

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

在线尝试！

修复了由于@ngn而导致的错误。

说明：

{⍵[⍋-@(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

¹

APL + WIN，31岁 38字节

见亚当斯评论

⊃n[(⍳⍴n)~a],⌽n[a←2×⍳⌊.5×⍴n←n[⍒∊⍴¨n←⎕]]

在线试用Dyalog Classic！

提示输入字符串的嵌套向量

视网膜，26字节

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

在线尝试！说明：

N$`
$.&

以长度的升序对行进行排序（$.&返回行的长度）。

*\,2,^A`.+

临时删除备用行并以相反顺序输出其余行。

,2,G`.+

保留仅被临时删除的行并输出。

盖亚 10字节

el∫v:v+2%ụ

在线尝试！

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

Japt，8个字节

ñÊó g0_w

-3个字节，感谢Shaggy！

试试吧

PowerShell，49字节

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

在线尝试！

二次蒸馏。

T-SQL，84个字节

输入是一个表变量

SELECT a FROM(SELECT*,row_number()over(order by len(a))r
FROM @)x order by(r%2-.5)*r

在线尝试

Perl 6，31个字节

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

在线尝试！

按字符串长度排序，然后按静态序列0，-1、0，-3、0，-5，...排序

Javascript 95字节

s=>s.sort((x,y)=>x.length-y.length).reduce((a,e,i)=>{i%2?a.push(e):a.unshift(e);return a;},[]);

红色，116101字节

func[b][sort/compare b func[x y][(length? x)> length? y]collect[forall b[keep take b]keep reverse b]]

在线尝试！

perl 5（-p0777F/\n/ -M5.01），59字节

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

蒂奥

C（gcc），136128字节

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];}

在线尝试！

-8字节，感谢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).

Japt, 8 bytes

Input as an array of lines, output as an array of 2 arrays of lines, one for each half of the list.

ñÊó
hUÎÔ

Try it (Additional code to allow for I/O as newline separated string)

ñÊó      :Implicit input of array U
ñ        :Sort by
 Ê       :  Length
  ó      :Uninterleave

hUÎÔ     :Newline reassigns to U
h        :Set the first element in U to
 UÎ      :  The first element in U
   Ô     :  Reversed

Haskell, 104 96 bytes

import Data.List
f s=splitAt((length s+1)`div`2)s
g=sortOn length
h(x,y)=reverse(g x)++g y
z=h.f

Try it online!