Socorro! Minhas luzes completamente automatizadas do Darks Separator V3001.01 quebraram! :(

Diretrizes

Tarefa

Escreva um programa que receba uma entrada de uma matriz (ou uma lista em alguns idiomas) de qualquer quantidade de cadeias que sejam a letra L ou a letra D (representando luzes ou trevas) e produza uma matriz que contenha duas matrizes, uma com todos os L's e um com todos os D's.

Regras

• É código de golfe, então a resposta mais curta em bytes vence
• A entrada sempre conterá maiúsculas
• Deve haver o mesmo número de L's na saída que existe na entrada, o mesmo vale para os D's
• A entrada pode ter apenas um elemento (ou talvez até zero elementos)
• Se uma ou ambas as matrizes de saída não contiverem elementos, produza uma lista vazia (em alguns idiomas, isso pode significar que você precisa gerar uma string)
• Sempre tenha a primeira matriz a matriz de L's

Exemplo de saída:

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

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

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

[] -> [[],[]]

APL, 8 bytes

'DL'~⍨¨⊂

Explicação:

• ⊂: entrada fechada
• ~⍨¨: sem cada
• 'DL': 'D' e 'L'

Exemplos:

      ('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"]

Experimente online!

Haskell , 28 bytes

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

Experimente online!

Se a entrada puder ser uma lista de caracteres, a área []ao redor cpode ser removida.

PHP, 46 bytes

Supõe-se que a lista fornecida seja: $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~#]&

Pura função de tomar uma lista de Ls e Ds (símbolos, e não caracteres / strings) como entrada e retornar uma lista de duas listas. Por exemplo,

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

retorna {{L, L, L}, {D, D}}. Experimente online!

Gatherpor si só, está próximo do que queremos, mas falha em atender às especificações de duas maneiras: não produz listas vazias se a entrada estiver faltando Ls ou Ds, e nem sempre classifica Ls à esquerda. Substituir a entrada #por {L,D}~Join~#resolve dois problemas de uma vez: significa que haverá pelo menos um Le pelo menos um D, e os Ls serão retornados primeiro desde que um Lfoi encontrado primeiro. Rest/@depois remove o inicial Le D.

(Tentei uma solução usando Count, mas devido a problemas de currying, ela não parecia ser mais curta: ±q_:=#~Table~Count[q,#]&/@{L,D}tem 31 bytes.)

Haskell, 32 bytes

import Data.List
partition(>"K")

Apenas uma função de biblioteca chata.

Experimente online!

Ruby , 26 bytes

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

Experimente online!

PHP7, 52 45 bytes

-7 bytes graças a @ Jörg Hülsermann

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

Use com CLI como php -r a.php L L L D D L D

O script percorre os argumentos fornecidos e os anexa a uma matriz com base em seu valor.

Lisp comum, 66 65 bytes

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

Experimente online!

Se, em vez de cadeias, usarmos símbolos, será muito mais curto:

Lisp comum, 42 41 40 bytes

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

Experimente online!

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

Raquete , 48 bytes

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

Basta aplicar essa função anônima a, por exemplo, '(L D L D D L)

Mathematica, 22 18 bytes

4 bytes salvos pelo gênio da CalculatorFeline!

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

Experimente online ou na caixa de areia Wolfram !

Input é uma lista dos símbolos Le D- não das strings, apenas as letras por si só, como na resposta de Greg Martin . A sintaxe #|Lé uma abreviação de Alternatives[#,L], mas a @@@sintaxe substitui o cabeçalho Alternativespor Cases, portanto esse código é 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();

Dicas bem-vindas.

Novo no PPCG, preciso incluir import java.util.*;import java.util.stream.*;na contagem de bytes?

Não concorrente, ele não cria listas vazias com uma entrada vazia. Agradecemos a Nevay por salvar alguns bytes.

Prolog (SWI) , 42 , 37 bytes

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

Experimente online!

Dado que Wé uma lista de lavagem, w/3unificará Le formará Dlistas de Luzes e Darks, respectivamente, particionando a lavagem contra um predicado que terá êxito se um item for uma Luz.

[Editado: -5 em golfe graças a Fatalize ]

Japonês , 13 12 10 bytes

2Æf¥"LD"gX

Teste (-Q sinalize apenas para fins de visualização)

Explicação

Entrada implícita da matriz U.

2Æ

Gere a matriz [0,1]e passe cada elemento por uma função, Xsendo o elemento atual.

f¥

Filtre Umarcando a igualdade ...

"LD"gX

... com o caractere em string LDno índice X.

Pitão , 10 9 bytes

mc@dQ1"LD

Conjunto de teste .

05AB1E , 8 bytes

'Lù'DÃ)

Experimente online!

Javascript (ES6), 37 bytes

Isso se baseia em uma resposta Javascript (ES6) (agora excluída).

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

Versão não destruída:

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

Exemplo de trecho de código:

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

Versão completa / formatada:

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

Experimente online!

Recebe a entrada como uma lista de seqüências de caracteres e retorna duas listas, a primeira com elementos onde fun a -> a="L"é verdadeiro e a outra com elementos que resultam em falso.

Gelatina , 10 bytes

ẎfЀ⁾LDW€€

Experimente online!

No Jelly, uma string é uma lista de strings de 1 caractere Python, por exemplo ['a', 'b', 'c']. É por isso que você obtém resultados como [[['L'], ['L']], [['D'], ['D'], ['D']]], uma vez que as cordas Jelly de 1 caractere se comportam da mesma maneira.

Não funciona como um programa completo, portanto, ÇŒṘna parte inferior.

Perse , 21 bytes

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

Eu posso ou não ter implementado a função de partição de lista especificamente para esse desafio. Toma a entrada como uma matriz de seqüências de caracteres.

Casca , 7 bytes

Mof-"DL

Experimente online!

Explicação

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 graças a @Nevay .

Explicação:

Experimente aqui.

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

Oitava, 21 bytes

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

Entrada é uma matriz de caracteres, saída é uma matriz de células. Reciclado da minha resposta aqui .

Execução de amostra em 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!