Meydan okuma

Robin değişken bildirimini ok şeklinde yapmaktan hoşlanıyor. İşte nasıl yapıyor:

• Herhangi bir sayı dizesini girin
• Artan uzunlukta onları sipariş

• Kabaca olumsuz bir ok ucu oluşturmak için ortasından sipariş ettikleri gibi çıkın, bu şekilde (hangisi en iyi golf oynarsa):

  5  or  4
  3      2
  1      1
  2      3
  4      5
  

Test Kılıfları

Giriş:

bow
arrows
sheriffOfNottingham
kingRichard
maidMarian
princeJohn
sherwoodForest

Çıktı:

sheriffOfNottingham
kingRichard
maidMarian
bow
arrows
princeJohn
sherwoodForest

Giriş:

a
bb
cc

Çıktı (her ikisi de geçerlidir):

bb
a
cc

cc
a
bb

Giriş:

one
four
seven
fifteen

Muhtemel çıkış (sadece diğer geçerli çıkış dikey aynasıdır):

seven
one
four
fifteen

notlar

• Dizeler camelCase içindedir ve sayı veya özel karakter içermez, yalnızca küçük ve büyük harflerden oluşur.

• Girdi, istediğiniz herhangi bir şey olabilir: tek bir dize, dizi, virgülle ayrılmış ... Herhangi bir G / Ç formatına izin verilir.

• Aynı uzunlukta dizeler arasında herhangi bir sipariş kabul edilir.

Python 2 , 47 bayt

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

Çevrimiçi deneyin!

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.

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
  )

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!

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

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.

Ruby, 51 bytes

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

Try it online!

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

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.

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.

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!

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

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

¹

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

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.

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

Japt, 8 bytes

ñÊó g0_w

-3 bytes thanks to Shaggy!

Try it

PowerShell, 49 bytes

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

Try it online!

The double distillation.

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

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, ...

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;},[]);

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!

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

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

TIO

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).

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!