Flecha esas variables!

29

Reto

A Robin le gusta tener su declaración de variables en forma de flecha. Así es como lo hace:

  • Ingrese cualquier número de cadenas
  • Ordénelos por longitud ascendente
  • Envíelos ordenados por el medio para formar aproximadamente una punta de flecha negativa, como esta (cualquiera que sea el orden de golf mejor):

    5  or  4
    3      2
    1      1
    2      3
    4      5
    

Casos de prueba

Entrada:

bow
arrows
sheriffOfNottingham
kingRichard
maidMarian
princeJohn
sherwoodForest

Salida:

sheriffOfNottingham
kingRichard
maidMarian
bow
arrows
princeJohn
sherwoodForest

Entrada:

a
bb
cc

Salida (ambas son válidas):

bb
a
cc

cc
a
bb

Entrada:

one
four
seven
fifteen

Salida posible (la única otra salida válida es su espejo vertical):

seven
one
four
fifteen

Notas

  • Las cadenas están en camelCase y no tienen números o caracteres especiales, solo letras minúsculas y mayúsculas.

  • La entrada puede ser lo que desee: separados por comas como una cadena, matriz, ... Se permite cualquier formato de E / S.

  • Entre cadenas con la misma longitud, se acepta cualquier orden.
Cabra Teletransportadora
fuente
Siento que hubo un desafío muy similar antes ... ¡pero bienvenido a PPCG!
Giuseppe
@Giuseppe Sí, eso es lo que pensé después de publicar, no hay forma de que no se haya hecho antes. ¿Estarías de acuerdo con que lo elimine ahora que lo has respondido?
Cabra teletransportadora
1
bueno, he estado buscando un engañado, pero no soy muy bueno en la búsqueda ... tenemos una caja de arena para publicar desafíos que a menudo pueden atrapar cosas así. Estoy perfectamente de acuerdo con que lo elimines si te preocupa que sea un engaño.
Giuseppe
1
Está bien, todos comenzamos desde el principio :-)
Giuseppe
1
¿Podría agregar un caso de prueba con un número par de cadenas?
Sherlock9

Respuestas:

15

Python 2 , 47 bytes

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

Pruébalo en línea!

ovs
fuente
Tendrá que reorganizar algunas cosas, pero puede usarlas [::-2]directamente para guardar 5 bytes.
Sherlock9
@ Sherlock9 Intenté eso, pero luego tuve que verificar la longitud, ya que las listas con longitudes pares / desiguales deben manejarse de manera diferente.
ovs
También funciona para Python 3. ¿Sería aceptable eliminar "lambda l:" y "o" y hacerlo en 2 líneas para guardar 11 bytes como "Se permite cualquier formato de E / S"?
papa
9

R , 63 48 bytes

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

Pruébalo en línea!

Ordene por longitudes de cadena, luego combine la lista invertida con la lista ordenada, finalmente, tome cada segundo elemento, comenzando en el índice 1 basado en 1.

Giuseppe
fuente
1
o<-L[...La otra forma de 'variables de flecha'. Un lado menos importante, pryr::f(...)funciona aquí para 46. ¡ Pruébalo en línea!
CriminallyVulgar
@CriminallyVulgar usando bibliotecas adicionales convierte esto en un idioma separado, R + pryrpor lo que generalmente evito hacerlo a menos que haya una buena razón para, como las preguntas de teoría de números, numberses indispensable.
Giuseppe
7

Javascript 77 bytes

Toma la entrada como un conjunto de cadenas, genera un conjunto de cadenas ordenadas por flechas.

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

Explicación

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
  )
asgallant
fuente
1
No creo que tengas que contar f=. 77
dana
Eso es inconsistente en las presentaciones de golf de código js de lo que he visto. Me complace excluirlo si no cuenta.
Asgallant
2
Creo que depende de si su función usa recursividad. es decir f=x=>x?f(x-1). Si es así, debe incluirlo fya que lo está llamando en su función. Sin embargo, dado que no está utilizando la recursividad, no debería tener que incluirla f. Hay varias publicaciones en Meta, esta parece explicarlo un poco mejor. codegolf.meta.stackexchange.com/a/9032/8340
dana
Eso explicaría las inconsistencias que he visto.
Asgallant
5

K (oK) , 24 bytes

Solución:

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

Pruébalo en línea!

Explicación:

Genere la 6 4 2 0 1 3 5secuencia, use eso para indexar en las longitudes ascendentes de entrada y use eso para indexar en la matriz original:

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
callejero
fuente
5

Jalea , 9 8 bytes

LÞŒœm"-Ẏ

Pruébalo en línea!

LÞŒœṚ;¥/

También es de 8 bytes.

Gracias a @EriktheOutgolfer y @JonathanAllan por ofrecer campos de golf para salvar un byte.

Nick Kennedy
fuente
¡Agradable! Golf inteligente: Ṛ€1¦puede convertirse m"-.
Erik el Outgolfer
O usted podría ir paraLÞŒœṚ;¥/
Jonathan Allan
5

05AB1E , 6 5 bytes

Guardado 1 byte gracias a Kevin Cruijssen

I / O es una lista de cadenas.
El enlace se modifica para E / S separadas por nueva línea para facilitar las pruebas.

éι`Rì

Pruébalo en línea!

Explicación

é       # 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
fuente
Puede eliminar el primero Ry reemplazar «con ipara guardar un byte, ya que la tercera regla de viñeta permite ambas versiones de desintercalado.
Kevin Cruijssen
@KevinCruijssen: ¡Oh sí, gracias!
Emigna
5

J , 11 bytes

,~`,/@\:#&>

Pruébalo en línea!

Lo clasificamos primero.

Luego reducimos el formulario de la lista de derecha a izquierda, pero alternando en qué lado colocamos el nuevo elemento. Hecho.

Jonás
fuente
¡Muy agradable! Sin embargo, tiene un espacio al final, elimínelo por 11 bytes :)
Galen Ivanov
1
Gracias Galen ¡Fijo!
Jonás
4

PowerShell , 66 bytes

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

Pruébalo en línea!

Toma información a través de salpicaduras, que se manifiesta en TIO como argumentos de línea de comandos separados. sorts en la lprofundidad, almacena eso $ay construye un rango desde 1hasta las countcadenas de entrada. Luego sacamos solo los impares ?{$_%2}y los alimentamos en un bucle |%{...}. Cada iteración, colocamos el "último", luego el "tercero del último", y así sucesivamente en la tubería con$a[-$_] . Por separado, también acumulamos en $xel "segundo desde el último", "cuarto desde el último", etc. Fuera del bucle y la tubería se vacía (por lo que esos elementos salen) y luego salimos $x. En ambos casos, la salida predeterminada nos da nuevas líneas entre los elementos automáticamente.

AdmBorkBork
fuente
4

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

Pruébalo en línea!

-3 bytes gracias a @Ismael Miguel !

640 KB
fuente
Buena esa. ¿Dónde puedo leer más [array_unshift,array_push][++$i%2]($e,$d)?
abhig10
2
@ abhig10 seguro. Es una matriz con los dos nombres de funciones ['array_push','array_unshift']con [++$i%2]el índice de la matriz que alterna entre más 0o 1menos se evaluará a la otra función cada vez. Las "funciones variables" de PHP le permiten asignar una variable a una función y ejecutarla llamando entre paréntesis (por ejemplo: $f='array_push'; $f($e,$d);== array_push($e,$d)) para ($e,$d)que luego llame al elemento evaluado de la matriz. Solo una forma más corta de hacerlo if (++$i%2) array_push($e,$d); else array_unshift($e,$e);. ¡Supongo que había algo de azúcar sintáctico PHP después de todo!
640 KB el
Está bien, me llevó algún tiempo entender esto. Increíble.
abhig10
1
Puede guardar 3 bytes reemplazando [array_unshift,array_push][++$i%2]($e,$d)con (array_.[unshift,push][++$i%2])($e,$d). Lo que hice fue eliminar lo repetido array_, concatenarlo y luego pasar el resultado a la llamada.
Ismael Miguel
1
@IsmaelMiguel eso es genial. ¡Gracias!
640 KB el
4

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)}}'

Toma la entrada como un conjunto de celdas de cadenas, emite una columna de cadenas (no estoy seguro si eso es 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'}

PD: Gracias Sanchises por señalar un error con entradas de longitud impar

aaaaa dice reinstalar a Monica
fuente
Esto falla en un número impar de cadenas de entrada, por ejemplof({'loooooooong','medium','short'})
Sanchises
También algunos consejos generales de golf: endes opcional para a function. El uso function x=f(y);x={...}'es más corto que function f(y);disp({...}').
Sanchises
Si estás atrapado, así es como lo haría.
Sanchises
@Sanchises gracias por señalar error. Lo arreglé exactamente como lo hiciste tú. Mi problema con dispes que no estoy seguro de cuáles son las reglas de salida. ¿Debería ser texto puro o no? o disp({...})está bien o incluso tal x={...}como lo sugieres
aaaaa dice que reinstalar a Mónica el
1
Esto puede ser 58 bytes en octava.
Giuseppe
3

APL (Dyalog Unicode) , SBCS de 18 bytes

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

Pruébalo en línea!

Se corrigió el error gracias a @ngn.

Explicación:

{⍵[⍋-@(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
fuente
1
≢¨×¯1*⍳∘⍴-> (⊢∘-\≢¨)y se vuelve aún más corto si lo conviertes en un dfn
ngn
1
Sin embargo, no estoy seguro de que este algoritmo sea correcto. deberíamos negar la longitud de cada otra cadena en su orden ordenado, no en el orden en que provienen de la entrada
ngn
2

APL + WIN, 31 38 bytes

Ver comentario de Adams

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

Pruébelo en línea ¡Cortesía de Dyalog Classic!

Solicita un vector anidado de cadenas

Graham
fuente
¿APL + no tiene "cuenta" Monadic para reemplazar ∊⍴?
Adám
1
Falla en '12' '1234' '1234' '1234' '1234' '12345678' '12345678' '12345678' '12345678'. Claramente, el resultado debería haber sido'12345678' '12345678' '1234' '1234' '12' '1234' '1234' '12345678' '12345678'
Adám
@ Adám Mi versión antigua de APL + no tiene ≢. De acuerdo con su segundo comentario, lo echaré un vistazo mañana.
Graham
2

Retina , 26 bytes

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

Pruébalo en línea! Explicación:

N$`
$.&

Ordenar las líneas en orden ascendente de longitud ( $.&devuelve la longitud de la línea).

*\,2,^A`.+

Elimine temporalmente líneas alternativas y envíe las líneas restantes en orden inverso.

,2,G`.+

Mantenga las únicas líneas que se eliminaron temporalmente y envíelas.

Neil
fuente
2

Gaia , 10 bytes

el∫v:v+2%ụ

Pruébalo en línea!

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
fuente
44
me gusta que tus comentarios en código sin envolver formen una flecha de cadenas
aaaaa dice reinstalar a Mónica el
2

Japt, 8 bytes

ñÊó g0_w

-3 bytes gracias a Shaggy!

Intentalo

Encarnación de la ignorancia
fuente
10 bytes con salida como una matriz 2D, que parece estar permitida.
Shaggy
¿O quizás 8 bytes ? En mi teléfono, así que no lo he probado correctamente.
Shaggy
@ Shaggy Estaba buscando una función para encontrar cada enésimo elemento, pero no pude encontrarlo. ¡Gracias!
Encarnación de la ignorancia
También hay, A.ë()pero no sé si eso conducirá a una solución más corta.
Shaggy
2

T-SQL, 84 bytes

La entrada es una variable de tabla

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

Pruébalo en línea

t-clausen.dk
fuente
2

Perl 6 , 31 bytes

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

Pruébalo en línea!

Ordenar por longitud de cadena, luego por secuencia estática 0, -1, 0, -3, 0, -5, ...

nwellnhof
fuente
1

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;},[]);
somsom
fuente
-1 s.sort()ordena las cadenas lexicográficamente, no por longitud de cadena.
Asgallant
Derecha, (x, y) => x.length-y.length, debería arreglar eso.
somsom
1

Rojo , 116 101 bytes

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

Pruébalo en línea!

Galen Ivanov
fuente
1

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

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

TIO

Nahuel Fouilleul
fuente
1

C (gcc) , 136128 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];}

Pruébalo en línea!

-8 bytes gracias a ceilingcat.

La función fes la solución. Toma el número de cadenas, las propias cadenas y el búfer de salida como argumentos (más cuatro más utilizados internamente).

LambdaBeta
fuente
¿Por qué está ./.bin.tioen la salida ?
Teletransportando cabra el
@TeleportingGoat Probablemente porque su pie de página está usando todo argv, que incluye el nombre de archivo
Jo King
Exactamente, fue solo una prueba rápida. Uno puede construir cualquier dato que tome el formato apropiado. Actualizaré el enlace TIO más tarde.
LambdaBeta
jaja, el problema con estos nombres cortos de variables: ten primer lugar, olvidas lo que te gusta y lo guardas incluso cuando no lo necesitas.
LambdaBeta
122 bytes
ceilingcat
0

Japt , 8 bytes

Ingrese como un conjunto de líneas, salga como un conjunto de 2 conjuntos de líneas, una para cada mitad de la lista.

ñÊó
hUÎÔ

Pruébelo (Código adicional para permitir E / S como cadena separada de nueva línea)

ñÊó      :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
Lanudo
fuente
0

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

Pruébalo en línea!

loco
fuente
No es válido, debe ordenar antes de cortar la lista a la mitad
solo ASCII el
90
Solo ASCII