Défi

Robin aime avoir sa déclaration de variables sous la forme d'une flèche. Voici comment il le fait:

• Saisissez un nombre quelconque de chaînes
• Commandez-les par longueur croissante

• Sortez-les classés par le milieu pour former à peu près une pointe de flèche négative, comme ceci (selon l'ordre de golf le meilleur):

  5  or  4
  3      2
  1      1
  2      3
  4      5
  

Cas de test

Contribution:

bow
arrows
sheriffOfNottingham
kingRichard
maidMarian
princeJohn
sherwoodForest

Sortie:

sheriffOfNottingham
kingRichard
maidMarian
bow
arrows
princeJohn
sherwoodForest

Contribution:

a
bb
cc

Sortie (les deux sont valides):

bb
a
cc

cc
a
bb

Contribution:

one
four
seven
fifteen

Sortie possible (la seule autre sortie valide est son miroir vertical):

seven
one
four
fifteen

Remarques

• Les chaînes sont en camelCase et n'ont pas de chiffres ou de caractères spéciaux, seulement des lettres minuscules et majuscules.

• L'entrée peut être ce que vous voulez: séparée par des virgules comme une chaîne, un tableau, ... Tout format d'E / S est autorisé.

• Entre les chaînes de même longueur, toute commande est acceptée.

Python 2 , 47 octets

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

Essayez-le en ligne!

R , 63 48 octets

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

Essayez-le en ligne!

Trier par longueur de chaîne, puis combiner la liste inversée avec la liste triée, enfin, prendre tous les 2 éléments, en commençant à l'index 1 basé sur 1.

Javascript 77 octets

Prend l'entrée comme un tableau de chaînes, génère un tableau de chaînes triées par flèche.

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

Explication

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 octets

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

Essayez-le en ligne!

K (oK) , 24 octets

Solution:

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

Essayez-le en ligne!

Explication:

Générez la 6 4 2 0 1 3 5séquence, utilisez-la pour indexer les longueurs d'entrée croissantes et utilisez-la pour indexer dans le tableau d'origine:

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

Gelée , 9 8 octets

LÞŒœm"-Ẏ

Essayez-le en ligne!

LÞŒœṚ;¥/

est également de 8 octets.

Merci à @EriktheOutgolfer et @JonathanAllan d'avoir tous deux proposé des golfs pour économiser un octet.

Rubis , 51 octets

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

Essayez-le en ligne!

05AB1E , 6 5 octets

1 octet enregistré grâce à Kevin Cruijssen

I / O est une liste de chaînes.
Le lien est modifié pour les E / S séparées par des sauts de ligne pour un test plus facile.

éι`Rì

Essayez-le en ligne!

Explication

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

,~`,/@\:#&>

Essayez-le en ligne!

Nous trions d'abord.

Ensuite, nous réduisons le formulaire de liste de droite à gauche, mais en alternant de quel côté nous mettons le nouvel élément. Terminé.

PowerShell , 66 octets

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

Essayez-le en ligne!

Prend l'entrée via l'éclaboussement, qui se manifeste sur TIO en tant qu'arguments de ligne de commande distincts. sortS sur la longueur, les magasins qui en $a, et construit une gamme allant 1jusqu'à la countdes chaînes d'entrée. Nous retirons ensuite uniquement les impairs ?{$_%2}et les alimentons en boucle |%{...}. A chaque itération, nous mettons le "dernier", puis le "troisième du dernier", et ainsi de suite sur le pipeline avec $a[-$_]. Par ailleurs, nous accumulons également dans $xla « deuxième de la dernière », « quatrième de la dernière », etc. Sur la boucle et la canalisation est rincée ( de sorte que ces éléments sont émis) puis nous affichons $x. Dans les deux cas, la sortie par défaut nous donne automatiquement des sauts de ligne entre les éléments.

PHP ,144 141 octets

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

Essayez-le en ligne!

-3 octets grâce à @Ismael Miguel !

MATLAB, 87 octets

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

Prend l'entrée comme tableau de cellules de chaînes, affiche la colonne de chaînes (je ne sais pas si c'est légal)

> 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: Merci Sanchises pour avoir signalé un bug avec des entrées de longueur impaire

APL (Dyalog Unicode) , 18 octets ^SBCS

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

Essayez-le en ligne!

Correction du bug grâce à @ngn.

Explication:

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

Voir le commentaire d'Adams

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

Essayez-le en ligne avec l'aimable autorisation de Dyalog Classic!

Demande un vecteur de chaînes imbriqué

Rétine , 26 octets

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

Essayez-le en ligne! Explication:

N$`
$.&

Triez les lignes par ordre croissant de longueur ( $.&renvoie la longueur de la ligne).

*\,2,^A`.+

Supprimez temporairement les lignes alternatives et sortez les lignes restantes dans l'ordre inverse.

,2,G`.+

Conservez les seules lignes qui ont été temporairement supprimées et sortez-les.

Gaia , 10 octets

el∫v:v+2%ụ

Essayez-le en ligne!

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 octets

ñÊó g0_w

-3 octets grâce à Shaggy!

Essayez-le

PowerShell , 49 octets

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

Essayez-le en ligne!

La double distillation .

T-SQL, 84 octets

L'entrée est une variable de table

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

Essayez-le en ligne

Perl 6 , 31 octets

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

Essayez-le en ligne!

Trier par longueur de chaîne, puis par séquence statique 0, -1, 0, -3, 0, -5, ...

Javascript 95 octets

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

Rouge , 116 101 octets

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

Essayez-le en ligne!

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

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

TIO

C (gcc) , 136 128 octets

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

Essayez-le en ligne!

-8 octets grâce au plafond.

La fonction fest la solution. Il prend le nombre de chaînes, les chaînes elles-mêmes et le tampon de sortie comme arguments (plus quatre autres utilisés en interne).

Japt , 8 octets

Entrée sous forme de tableau de lignes, sortie sous forme de tableau de 2 tableaux de lignes, un pour chaque moitié de la liste.

ñÊó
hUÎÔ

Essayez-le (code supplémentaire pour autoriser les E / S en tant que chaîne séparée par la nouvelle ligne)

ñÊó      :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 octets

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

Essayez-le en ligne!