¡Ayuda! ¡Mis luces completamente automatizadas de Darks Separator V3001.01 se rompieron! :(

Pautas

Tarea

Escriba un programa que tome una entrada de una matriz (o una lista en algunos idiomas) de cualquier cantidad de cadenas que sean la letra L o la letra D (que representan luces u oscuras) y generará una matriz que contiene dos matrices, una con todas las L y una con todas las D.

Reglas

• Es el código de golf, por lo que gana la respuesta más corta en bytes
• La entrada solo contendrá mayúsculas
• Debe haber la misma cantidad de L en la salida que en la entrada, lo mismo ocurre con las D
• La entrada puede tener solo un elemento (o tal vez incluso cero elementos)
• Si una o ambas matrices de salida no contienen elementos, genere una lista vacía (en algunos idiomas esto puede significar que necesita generar una cadena)
• Siempre tenga la primera matriz sea la matriz de L

Salida de ejemplo:

["L","D","L","D","D"] -> [["L","L"],["D","D","D"]]

["L","L","L"] -> [["L","L","L"],[]]

["D","D"] -> [[],["D","D"]]

[] -> [[],[]]

APL, 8 bytes

'DL'~⍨¨⊂

Explicación:

• ⊂: entrada cerrada
• ~⍨¨: sin cada
• 'DL': 'D' y 'L'

Ejemplos:

      ('DL'~⍨¨⊂) 'LDLDD'
┌──┬───┐
│LL│DDD│
└──┴───┘
      ('DL'~⍨¨⊂) 'LLL'
┌───┬┐
│LLL││
└───┴┘
      ('DL'~⍨¨⊂) 'DD'
┌┬──┐
││DD│
└┴──┘
      ('DL'~⍨¨⊂) ''
┌┬┐
│││
└┴┘

Python 3 , 37 bytes

lambda a:[[c]*a.count(c)for c in"LD"]

Pruébalo en línea!

Haskell , 28 bytes

f l=[filter(==[c])l|c<-"LD"]

Pruébalo en línea!

Si la entrada puede ser una lista de caracteres, se puede eliminar el []alrededor c.

PHP, 46 bytes

Se supone que la lista dada es: $arr = ['L','L','D','D','L','D','D','D','D','L'];

foreach($arr as $b){$a[$b][]=$b;};print_r($a);

Mathematica, 27 bytes

Rest/@Gather[{L,D}~Join~#]&

Función pura que toma una lista de Lsys D(símbolos, no caracteres / cadenas) como entrada y devuelve una lista de dos listas. Por ejemplo,

Rest/@Gather[{L,D}~Join~#]& @ {D, L, L, D, L}

vuelve {{L, L, L}, {D, D}}. Pruébalo en línea!

Gatherpor sí mismo es cerca de lo que queremos, pero no cumple con la especificación de dos maneras: no produce listas vacías si la entrada no se encuentra Ls o Ds, y no siempre especie Les a la izquierda. Reemplazar la entrada #con {L,D}~Join~#resuelve ambos problemas a la vez: significa que habrá al menos uno Ly al menos uno D, y los Ls se devolverán primero desde que Lse encontró uno primero. Rest/@luego elimina la inicial Ly D.

(Intenté usar una solución Count, pero debido a problemas de curry, no parecía ser más corta: ±q_:=#~Table~Count[q,#]&/@{L,D}son 31 bytes).

Haskell, 32 bytes

import Data.List
partition(>"K")

Solo una función de biblioteca aburrida.

Pruébalo en línea!

Rubí , 26 bytes

->x{x.partition{|e|e==?L}}

Pruébalo en línea!

PHP7, 52 45 bytes

-7 bytes gracias a @ Jörg Hülsermann

foreach($argv as$a)$$a[]=$a;print_r([$L,$D]);

Usar con CLI como php -r a.php L L L D D L D

El script revisa los argumentos proporcionados y los agrega a una matriz en función de su valor.

Lisp común, 66 65 bytes

(defun f(x)`(,(remove"D"x :test'equal),(remove"L"x :test'equal)))

Pruébalo en línea!

Si, en lugar de cadenas, usamos símbolos, entonces es mucho más corto:

Lisp común, 42 41 40 bytes

(defun f(x)(mapcar'remove'(D L)`(,x,x)))

Pruébalo en línea!

(f '(D D L L D L D)) ; => ((L L L) (D D D D)) 

Raqueta , 48 bytes

(compose list((curry partition)(λ(x)(eq? x'L))))

Simplemente aplique esta función anónima a, por ejemplo, '(L D L D D L)

Mathematica, 22 18 bytes

¡4 bytes guardados por el genio de CalculatorFeline!

Cases@@@{#|L,#|D}&

¡Pruébelo en línea o en el sandbox de Wolfram !

La entrada es una lista de los símbolos Ly D, no cadenas, solo las letras en sí mismas, como en la respuesta de Greg Martin . La sintaxis #|Les la abreviatura de Alternatives[#,L], pero la @@@sintaxis reemplaza la cabeza Alternativescon Cases, por lo que este código es equivalente a {Cases[#,L],Cases[#,D]}&.

Java 8, 105 bytes

import java.util.stream.*;a->Stream.of(a).collect(Collectors.groupingBy("D"::equals)).values().toArray();

Consejos bienvenidos.

Nuevo en PPCG, ¿debo incluirlo import java.util.*;import java.util.stream.*;en el recuento de bytes?

No compite, no crea listas vacías con una entrada vacía. Gracias a Nevay por guardar algunos bytes.

Prólogo (SWI) , 42 , 37 bytes

l('L').
w(L,D,W):-partition(l,W,L,D).

Pruébalo en línea!

Dado que Wes una lista de lavado, w/3se unificará LyD en listas de Luces y Oscuros respectivamente, al dividir el lavado contra un predicado que tenga éxito si un artículo es una Luz.

[Editar: golfed -5 gracias a Fatalize ]

Japt , 13 12 10 bytes

2Æf¥"LD"gX

Pruébalo ( -Qmarca solo con fines de visualización)

Explicación

Entrada implícita de la matriz U.

2Æ

Genere la matriz [0,1]y pase cada elemento a través de una función, Xsiendo el elemento actual.

f¥

Filtre Ucomprobando la igualdad ...

"LD"gX

... con el carácter en cadena LDen el índice X.

Pyth , 10 9 bytes

mc@dQ1"LD

Banco de pruebas .

05AB1E , 8 bytes

'Lù'DÃ)

Pruébalo en línea!

Javascript (ES6), 37 bytes

Esto se basa en una respuesta Javascript (ES6) (ahora eliminada).

a=>[(b=c=>a.filter(d=>c==d))`L`,b`D`]

Versión sin golf:

function(array) {
  function filter(character){
    return array.filter(function(d) {
      return character == d;
    });
  }
  return [filter("L"), filter("D")];
}

Fragmento de código de ejemplo:

f=

a=>[(b=c=>a.filter(d=>c==d))`L`,b`D`]

console.log(f(["L", "D", "L", "D", "D"]))

C #, 61 bytes

using System.Linq;a=>new[]{a.Where(c=>c<69),a.Where(c=>c>68)}

Versión completa / formateada:

using System;
using System.Linq;

class P
{
    static void Main()
    {
        Func<char[], System.Collections.Generic.IEnumerable<char>[]> f =
            a => new[] { a.Where(c => c < 69), a.Where(c => c > 68) };

        Console.WriteLine(string.Join(", ", f(new[]{ 'L', 'D', 'L', 'D', 'D' }).SelectMany(a => a.Select(c => c))));

        Console.ReadLine();
    }
}

F # , 37 bytes

let f s=List.partition(fun a->a="L")s

Pruébalo en línea!

Toma la entrada como una lista de cadenas y devuelve dos listas, la primera con elementos donde fun a -> a="L"es verdadero y la otra con elementos que resultan en falso.

Jalea , 10 bytes

ẎfЀ⁾LDW€€

Pruébalo en línea!

En Jelly, una cadena es una lista de cadenas Python de 1 carácter, por ejemplo ['a', 'b', 'c']. Es por eso que obtienes resultados como[[['L'], ['L']], [['D'], ['D'], ['D']]] , ya que las cadenas Jelly 1-char se comportan igual.

No funciona como un programa completo, de ahí ÇŒṘla parte inferior.

Perse , 21 bytes

part(i,fn(x){x=="L"})

Puedo o no haber implementado la función de partición de lista específicamente para este desafío. Toma la entrada como una matriz de cadenas.

Casco , 7 bytes

Mof-"DL

Pruébalo en línea!

Explicación

Mof-"DL
M   "DL    For each character in ['D','L']:
 of-         keep only those strings that are not empty if that character is removed

Java 8, 110 106 bytes

a->{String[]r={"",""};for(char c:a)r[c/69]+=c;return new char[][]{r[1].toCharArray(),r[0].toCharArray()};}

-4 bytes gracias a @Nevay .

Explicación:

Pruébalo aquí

a->{                      // Method with char-array parameter and 2D char-array return-type
  String[]r={"",""};      //  Two Strings in an array
  for(char c:a)           //  Loop over the characters of the input
    r[c/69]+=c;           //   Append either of the two String with the character
                          //   c/69 will result in 0 for 'D' and 1 for 'L'
                          //  End of loop (implicit / single-line body)
  return new char[][]{    //  Return a 2D character-array
    r[1].toCharArray(),   //   With the String for L's converted to a char-array
    r[0].toCharArray()};  //   and String D's converted to a char-array
}                         // End of method

Octava, 21 bytes

@(A){A(a=A>72),A(~a)}

La entrada es una matriz de caracteres, la salida es una matriz de celdas. Reciclado de mi respuesta aquí .

Sample execution on ideone.

R, 35 bytes

x=scan(,'');list(x[i<-x>'D'],x[!i])

Try it online!

Reads from stdin.

Julia, 26 bytes

g(s)=s[s.=="L"],s[s.=="D"]

Haskell (Lambdabot), 41 bytes

reverse.map tail.group.sort.("LD"++).join

Try it online!

PowerShell, 27 bytes

($args-eq'L'),($args-eq'D')

Try it online!

Edit: previously $args.where({$_-eq'L'},'sp') for 28 bytes. Could be $args.where({+"0x$_"},'sp') for 27 if not for the rule that L's must come first.

CJam, 14 bytes

"LD"qf{1$e=*}`

Input is a list of characters (string), output is a list of lists of characters (list of strings).

Try it online!

Explanation:

"LD"  e# Push the string "LD"                  | "LD"
q     e# Push the input                        | "LD" "LDLLDLDDL"
f{    e# Foreach char in "LD", push input and: | ['L "LDLLDLDDL"
  1$  e#   Copy from 1 back                    | ['L "LDLLDLDDL" 'L
  e=  e#   Count occurences                    | ['L 5
  *   e#   Repeat character                    | ["LLLLL"
}     e# End                                   | ["LLLLL" "DDDD"]
`     e# Stringify:                            | "[\"LLLLL\" \"DDDD\"]"
e# Implicit output: ["LLLLL" "DDDD"]

Perl 5, 70 bytes

$"='","';@L=(L)x y/L//;@D=(D)x y/D//;$_="[[\"@L\"],[\"@D\"]]";s/""//g

Try it online!