Aiuto! Il mio separatore completamente automatizzato Lights from Darks V3001.01 si è rotto! :(

Linee guida

Compito

Scrivi un programma che prenderà un input di un array (o un elenco in alcune lingue) di qualsiasi quantità di stringhe che sono la lettera L o la lettera D (che rappresenta luci o ombre) e genera un array che contiene due array, uno con tutte le L e una con tutte le D.

Regole

• È il golf del codice, quindi vince la risposta più breve in byte
• L'input conterrà solo maiuscole
• Ci deve essere lo stesso numero di L nell'output presente nell'input, lo stesso vale per i D
• L'input può avere solo un elemento (o forse anche zero elementi)
• Se uno o entrambi gli array di output non contengono elementi, genera un elenco vuoto (in alcune lingue questo potrebbe significare che devi emettere una stringa)
• Il primo array deve sempre essere l'array di L

Esempio di output:

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

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

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

[] -> [[],[]]

APL, 8 byte

'DL'~⍨¨⊂

Spiegazione:

• ⊂: ingresso chiuso
• ~⍨¨: senza ciascuno
• 'DL': 'D' e 'L'

Esempi:

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

Python 3 , 37 byte

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

Provalo online!

Haskell , 28 byte

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

Provalo online!

Se l'input può essere un elenco di caratteri, è possibile rimuovere il []around c.

PHP, 46 byte

Si presume che l'elenco fornito sia: $arr = ['L','L','D','D','L','D','D','D','D','L'];

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

Mathematica, 27 byte

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

Funzione pura che prende un elenco di Ls D(simboli, non caratteri / stringhe) come input e restituisce un elenco di due elenchi. Per esempio,

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

ritorna {{L, L, L}, {D, D}}. Provalo online!

Gatherdi per sé è vicino a ciò che vogliamo, ma non riesce a soddisfare le specifiche in due modi: non produce elenchi vuoti se l'input è mancante Lo meno D, e non sempre ordina Ls a sinistra. Sostituire l'input #con {L,D}~Join~#risolve entrambi i problemi contemporaneamente: significa che ci sarà almeno uno Le almeno uno D, e la Ls verrà restituita per prima da quando si Lè verificato per primo. Rest/@quindi rimuove l'iniziale Le D.

(Ho provato una soluzione utilizzando Count, ma a causa di problemi di curry, non sembrava essere più breve: ±q_:=#~Table~Count[q,#]&/@{L,D}è di 31 byte.)

Haskell, 32 byte

import Data.List
partition(>"K")

Solo una noiosa funzione di libreria.

Provalo online!

Rubino , 26 byte

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

Provalo online!

PHP7, 52 45 byte

-7 byte grazie a @ Jörg Hülsermann

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

Utilizzare con CLI come php -r a.php L L L D D L D

Lo script passa attraverso gli argomenti forniti e li aggiunge a un array in base al suo valore.

Lisp comune, 66 65 byte

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

Provalo online!

Se, invece delle stringhe, utilizziamo i simboli, allora è molto più breve:

Lisp comune, 42 41 40 byte

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

Provalo online!

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

Racchetta , 48 byte

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

Basta applicare questa funzione anonima, ad esempio, '(L D L D D L)

Mathematica, 22 18 byte

4 byte salvati dal genio di CalculatorFeline!

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

Provalo online o nella sandbox Wolfram !

L'input è un elenco dei simboli Le D- non delle stringhe, ma solo delle lettere, come nella risposta di Greg Martin . La sintassi #|Lè una scorciatoia per Alternatives[#,L], ma la @@@sintassi sostituisce la testa Alternativescon Cases, quindi questo codice è equivalente a {Cases[#,L],Cases[#,D]}&.

Java 8, 105 byte

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

Suggerimenti benvenuti.

Nuovo in PPCG, devo includere import java.util.*;import java.util.stream.*;nel conteggio byte?

Non competitiva, non crea liste vuote con un input vuoto. Grazie a Nevay per aver salvato alcuni byte.

Prolog (SWI) , 42 , 37 byte

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

Provalo online!

Dato che Wè un elenco di lavaggio, w/3si unificheràL e rispettivamente Din elenchi di luci e ombre, partizionando il lavaggio contro un predicato che ha successo se un oggetto è una luce.

[Modifica: golf -5 grazie a Fatalize ]

Japt , 13 12 10 byte

2Æf¥"LD"gX

Test ( -Qflag solo a scopo di visualizzazione)

Spiegazione

Input implicito di array U.

2Æ

Generare l'array [0,1]e passare ciascun elemento attraverso una funzione, con Xl'elemento corrente.

f¥

Filtra Ucontrollando l'uguaglianza ...

"LD"gX

... con il carattere in stringa LDnell'indice X.

Pyth , 10 9 byte

mc@dQ1"LD

Suite di test .

05AB1E , 8 byte

'Lù'DÃ)

Provalo online!

Javascript (ES6), 37 byte

Questo si basa su una risposta Javascript (ES6) (ora eliminata).

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

Versione non golfata:

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

Esempio di frammento di codice:

f=

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

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

C #, 61 byte

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

Versione completa / formattata:

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 byte

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

Provalo online!

Prende l'input come un elenco di stringhe e restituisce due elenchi, il primo con elementi dove fun a -> a="L"è vero e l'altro con elementi che risultano falsi.

Gelatina , 10 byte

ẎfЀ⁾LDW€€

Provalo online!

In Jelly una stringa è un elenco di stringhe Python a 1 carattere, ad es ['a', 'b', 'c']. Ecco perché ottieni un output come[[['L'], ['L']], [['D'], ['D'], ['D']]] , poiché le stringhe Jelly a 1 carattere si comportano allo stesso modo.

Non funziona come un programma completo, quindi ÇŒṘin fondo.

Perse , 21 byte

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

Potrei o meno aver implementato la funzione di partizione elenco specificatamente per questa sfida. Prende l'input come una matrice di stringhe.

Buccia , 7 byte

Mof-"DL

Provalo online!

Spiegazione

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 byte

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

-4 byte grazie a @Nevay .

Spiegazione:

Provalo qui.

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

Octave, 21 bytes

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

Input is an array of characters, output is a cell array. Recycled from my answer here.

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!