Flèche ces variables!

29

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.
Téléportation de chèvre
la source
J'ai l'impression qu'il y avait un défi très similaire avant ... mais bienvenue chez PPCG!
Giuseppe
@ Giuseppe Oui, c'est ce que je pensais après avoir posté, il n'y a aucun moyen que cela n'ait pas été fait auparavant. Seriez-vous d'accord pour que je le supprime maintenant que vous y avez répondu?
Téléportation de chèvre le
1
eh bien je cherchais un dupe mais je ne suis pas très bon dans la recherche ... nous avons un bac à sable pour publier des défis qui peuvent souvent attraper des choses comme ça. Je suis parfaitement d'accord avec votre suppression si vous craignez que ce soit un dupe.
Giuseppe
1
C'est bon, on part tous du début :-)
Giuseppe
1
Pourriez-vous ajouter un cas de test avec un nombre pair de chaînes?
Sherlock9

Réponses:

15

Python 2 , 47 octets

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

Essayez-le en ligne!

ovs
la source
Vous devrez réorganiser certaines choses, mais vous pouvez utiliser [::-2]directement pour économiser 5 octets.
Sherlock9
@ Sherlock9 J'ai essayé cela, mais j'ai ensuite dû vérifier la longueur, car les listes avec des longueurs égales / inégales doivent être traitées différemment.
OVS
Fonctionne également pour Python 3. La suppression de "lambda l:" et "ou" et le rendre sur 2 lignes pour économiser 11 octets serait-elle toujours acceptable car "Tout format d'E / S est autorisé"?
pomme de terre
9

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.

Giuseppe
la source
1
o<-L[...L'autre façon de «variables fléchées». Un côté moins important, pryr::f(...)fonctionne ici pour 46. Essayez-le en ligne!
CriminallyVulgar
@CriminallyVulgar utilisant des bibliothèques supplémentaires transforme cela en un langage séparé, R + pryrc'est pourquoi j'évite généralement de le faire à moins qu'il n'y ait une bonne raison - comme pour les questions de théorie des nombres, numbersest indispensable.
Giuseppe
7

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
  )
impitoyable
la source
1
Je ne pense pas que tu dois compter f=. 77
dana
Ce n'est pas cohérent dans les soumissions de golf js code de ce que j'ai vu. Je suis heureux de l'exclure si cela ne compte pas.
asgallant
2
Je pense que cela dépend si votre fonction utilise la récursivité. ie f=x=>x?f(x-1). Si c'est le cas, vous devez l'inclure fpuisque vous l'appelez dans votre fonction. Cependant, puisque vous n'utilisez pas la récursivité, vous ne devriez pas avoir à l'inclure f. Il y a plusieurs postes dans Meta, celui-ci semble l'expliquer un peu mieux. codegolf.meta.stackexchange.com/a/9032/8340
dana
Cela expliquerait les incohérences que j'ai vues.
asgallant
5

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
streetster
la source
5

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.

Nick Kennedy
la source
Agréable! Golf intelligent: Ṛ€1¦peut devenir m"-.
Erik the Outgolfer
Ou vous pouvez opter pourLÞŒœṚ;¥/
Jonathan Allan
5

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
Emigna
la source
Vous pouvez supprimer le premier Ret remplacer «par ipour enregistrer un octet, car la troisième règle à puces autorise les deux versions de l'imbrication.
Kevin Cruijssen
@KevinCruijssen: Oh oui, merci!
Emigna
5

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

Jonas
la source
Très agréable! Vous avez cependant un espace à la fin, supprimez-le pour 11 octets :)
Galen Ivanov
1
Merci Galen. Fixé!
Jonah
4

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.

AdmBorkBork
la source
4

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 !

640 Ko
la source
joli. Où puis-je en savoir plus [array_unshift,array_push][++$i%2]($e,$d)?
abhig10
2
@ abhig10 bien sûr. C'est un tableau avec les deux noms de fonction ['array_push','array_unshift']avec [++$i%2]comme index du tableau alternant entre une 0ou 1deux évaluations à l'autre fonction à chaque fois. Les "fonctions variables" de PHP vous permettent d'affecter une variable à une fonction et de l'exécuter en appelant entre parenthèses (ex: $f='array_push'; $f($e,$d);== array_push($e,$d)) de sorte que l' ($e,$d)appelle ensuite l'élément évalué du tableau. Juste un moyen plus court de le faire if (++$i%2) array_push($e,$d); else array_unshift($e,$e);. Je suppose qu'il y avait du sucre syntaxique PHP après tout!
640 Ko le
D'accord, il m'a fallu un certain temps pour comprendre cela. Impressionnant.
abhig10
1
Vous pouvez économiser 3 octets en remplaçant [array_unshift,array_push][++$i%2]($e,$d)par (array_.[unshift,push][++$i%2])($e,$d). Ce que j'ai fait a été de supprimer les répétitions array_, de les concaténer, puis le résultat est transmis à l'appel.
Ismael Miguel
1
@IsmaelMiguel c'est génial. Merci!
640 Ko le
4

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

aaaaa dit réintégrer Monica
la source
Cela échoue sur un nombre impair de chaînes d'entrée, par exemplef({'loooooooong','medium','short'})
Sanchises
Aussi quelques conseils généraux sur le golf: le endest facultatif pour a function. L'utilisation function x=f(y);x={...}'est plus courte que function f(y);disp({...}').
Sanchises
Si vous êtes coincé, voici comment je le ferais.
Sanchises
@Sanchises merci d'avoir signalé un bug. Je l'ai réparé exactement comme vous. Mon problème dispest que je ne suis pas sûr des règles de sortie. Doit-il s'agir de texte pur ou non? ou disp({...})va bien ou même x={...}comme vous le suggérez
aaaaa dit de réintégrer Monica le
1
Cela peut être de 58 octets en octave.
Giuseppe
3

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

¹

Ven
la source
1
≢¨×¯1*⍳∘⍴-> (⊢∘-\≢¨)et il devient encore plus court si vous le transformez en dfn
ngn
1
cependant, je ne suis pas sûr que cet algorithme soit correct. nous devons annuler la longueur de chaque autre chaîne dans leur ordre trié, pas dans l'ordre dans
lequel
2

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é

Graham
la source
APL + n'a-t-il pas de "décompte" monadique à remplacer ∊⍴?
Adám
1
Échoue '12' '1234' '1234' '1234' '1234' '12345678' '12345678' '12345678' '12345678'. De toute évidence, le résultat aurait dû être'12345678' '12345678' '1234' '1234' '12' '1234' '1234' '12345678' '12345678'
Adám
@ Adám Mon ancienne version d'APL + n'a pas ≢. D'accord sur votre deuxième commentaire, je vais l'examiner demain.
Graham
2

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.

Neil
la source
2

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
Giuseppe
la source
4
j'aime que vos commentaires en code déballé forment une flèche de chaînes
aaaaa dit réintégrer Monica
2

Japt, 8 octets

ñÊó g0_w

-3 octets grâce à Shaggy!

Essayez-le

Incarnation de l'ignorance
la source
10 octets avec sortie sous forme de tableau 2D, ce qui semble être autorisé.
Shaggy
Ou, peut-être, 8 octets ? Sur mon téléphone, je ne l'ai donc pas testé correctement.
Shaggy
@Shaggy Je cherchais une fonction pour trouver chaque nième élément, mais je ne l'ai pas trouvé. Merci!
Incarnation de l'ignorance
il y en a aussi A.ë()mais je ne sais pas si cela mènera à une solution plus courte.
Shaggy
2

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

t-clausen.dk
la source
2

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

nwellnhof
la source
1

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;},[]);
somsom
la source
-1 s.sort()trie les chaînes lexicographiquement, pas par longueur de chaîne.
asgallant
À droite, (x, y) => x.length-y.length, devrait résoudre ce problème.
somsom
1

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!

Galen Ivanov
la source
1

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

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

TIO

Nahuel Fouilleul
la source
1

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

LambdaBeta
la source
Pourquoi est ./.bin.tiodans la sortie ?
Teleporting Goat
@TeleportingGoat Probablement parce que leur pied de page utilise tout argv, ce qui inclut le nom de fichier
Jo King
Exactement, ce n'était qu'un test rapide. On peut construire toutes les données qui prennent le format approprié. Je mettrai à jour le lien TIO plus tard.
LambdaBeta
haha, le problème avec ces noms de variables courts: vous oubliez d'abord ce que vous détestez tet le conservez même lorsque vous n'en avez pas besoin!
LambdaBeta
122 octets
Plafond
0

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
Hirsute
la source
0

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!

bogues
la source
Non valide, vous devez trier avant de couper la liste en deux
ASCII uniquement
90
ASCII uniquement le