Hilfe! Mein komplett automatisierter Lights From Darks Separator V3001.01 ist kaputt! :(

Richtlinien

Aufgabe

Schreiben Sie ein Programm, das eine Eingabe eines Arrays (oder einer Liste in einigen Sprachen) mit einer beliebigen Anzahl von Zeichenfolgen vornimmt, die entweder den Buchstaben L oder den Buchstaben D (für Hell oder Dunkel) enthalten, und geben Sie ein Array aus, das zwei Arrays enthält, eines mit allen L's und einem mit allen D's.

Regeln

• Es ist Codegolf, also gewinnt die kürzeste Antwort in Bytes
• Die Eingabe enthält immer nur Großbuchstaben
• Es muss die gleiche Anzahl von Ls in der Ausgabe wie in der Eingabe geben, dasselbe gilt für die Ds
• Die Eingabe kann nur ein Element (oder sogar null Elemente) enthalten.
• Wenn eines oder beide der Ausgabearrays keine Elemente enthalten, geben Sie eine leere Liste aus (in einigen Sprachen bedeutet dies möglicherweise, dass Sie eine Zeichenfolge ausgeben müssen).
• Das erste Array muss immer das Array von L sein

Beispielausgabe:

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

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

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

[] -> [[],[]]

APL, 8 Bytes

'DL'~⍨¨⊂

Erläuterung:

• ⊂: beiliegende Eingabe
• ~⍨¨: ohne jeden
• 'DL': 'D' und 'L'

Beispiele:

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

Probieren Sie es online!

Haskell , 28 Bytes

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

Probieren Sie es online!

Wenn die Eingabe eine Liste von Zeichen sein kann, kann die []Umgebung centfernt werden.

PHP, 46 Bytes

Vorausgesetzt, gegebene Liste ist: $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~#]&

Reine Funktion, die eine Liste von Ls und Ds (Symbole, keine Zeichen / Strings) als Eingabe verwendet und eine Liste von zwei Listen zurückgibt. Beispielsweise,

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

kehrt zurück {{L, L, L}, {D, D}}. Probieren Sie es online!

Gatheran sich ist nah an dem, was wir wollen, erfüllt die Spezifikation jedoch in zweierlei Hinsicht nicht: Es werden keine leeren Listen erstellt, wenn die Eingabe Ls oder Ds fehlt , und es wird nicht immer Ls nach links sortiert . Das Ersetzen der Eingabe #durch {L,D}~Join~#löst beide Probleme gleichzeitig: Es gibt mindestens ein Lund mindestens ein Problem D, und das Ls wird zuerst zurückgegeben, seit ein Problem zuerst Laufgetreten ist. Rest/@entfernt dann das anfängliche Lund D.

(Ich habe versucht, eine Lösung mit zu finden Count, aber aufgrund von aktuellen Problemen schien sie nicht kürzer zu sein: sie ±q_:=#~Table~Count[q,#]&/@{L,D}beträgt 31 Byte.)

Haskell, 32 Bytes

import Data.List
partition(>"K")

Nur eine langweilige Bibliotheksfunktion.

Probieren Sie es online!

Ruby , 26 Bytes

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

Probieren Sie es online!

PHP7, 52 45 Bytes

-7 Bytes dank @ Jörg Hülsermann

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

Verwenden Sie mit CLI als php -r a.php L L L D D L D

Das Skript durchläuft die angegebenen Argumente und hängt sie basierend auf ihrem Wert an ein Array an.

Common Lisp, 66 65 Bytes

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

Probieren Sie es online!

Wenn wir anstelle von Zeichenketten Symbole verwenden, ist dies viel kürzer:

Common Lisp, 42 41 40 Bytes

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

Probieren Sie es online!

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

Schläger , 48 Bytes

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

Wenden Sie diese anonyme Funktion beispielsweise auf '(L D L D D L)

Mathematica, 22 18 Bytes

4 Bytes gespart vom Genie von CalculatorFeline!

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

Probieren Sie es online oder in der Wolfram Sandbox aus !

Die Eingabe ist eine Liste der Symbole Lund D- nicht Zeichenfolgen, sondern nur die Buchstaben für sich, wie in Greg Martins Antwort . Die Syntax #|List eine Abkürzung für Alternatives[#,L], aber die @@@Syntax ersetzt den Kopf Alternativesdurch Cases, sodass dieser Code äquivalent zu ist {Cases[#,L],Cases[#,D]}&.

Java 8, 105 Bytes

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

Trinkgelder willkommen.

Neu bei PPCG, muss ich die Byteanzahl berücksichtigen import java.util.*;import java.util.stream.*;?

Nicht konkurrierend, erstellt es keine leeren Listen mit einer leeren Eingabe. Vielen Dank an Nevay für das Speichern einiger Bytes.

Prolog (SWI) , 42 , 37 Bytes

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

Probieren Sie es online!

Vorausgesetzt, das Wist eine Liste der Wäsche, w/3wird vereinheitlichenL und Din Listen von Licht und Schatten jeweils durch Unterteile den Wasch gegen ein Prädikat , das , wenn ein Element gelingt , ist ein Licht.

[Edit: Golf -5 dank Fatalize ]

Japt , 13 12 10 Bytes

2Æf¥"LD"gX

Test it ( -QFlag nur zu Visualisierungszwecken)

Erläuterung

Implizite Eingabe eines Arrays U.

2Æ

Generieren Sie das Array [0,1]und übergeben Sie jedes Element Xals aktuelles Element einer Funktion .

f¥

Filtern, Uindem auf Gleichheit geprüft wird ...

"LD"gX

... mit dem Zeichen in String LDam Index X.

Pyth , 10 9 Bytes

mc@dQ1"LD

Testsuite .

05AB1E , 8 Bytes

'Lù'DÃ)

Probieren Sie es online!

Javascript (ES6), 37 Byte

Dies basiert auf einer (jetzt gelöschten) Javascript (ES6) Antwort.

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

Ungolfed-Version:

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

Beispielcode-Snippet:

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

Voll / Formatierte Version:

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

Probieren Sie es online!

Nimmt Eingaben als eine Liste von Zeichenfolgen und gibt zwei Listen zurück, die eine mit Elementen, bei denen fun a -> a="L"true angegeben ist, und die andere mit Elementen, bei denen false angegeben ist.

Gelee , 10 Bytes

ẎfЀ⁾LDW€€

Probieren Sie es online!

In Jelly ist eine Zeichenfolge eine Liste von 1-Zeichen-Python-Zeichenfolgen, z ['a', 'b', 'c']. Das ist der Grund, warum Sie beispielsweise eine Ausgabe erhalten [[['L'], ['L']], [['D'], ['D'], ['D']]], da sich 1-Zeichen-Jelly-Strings gleich verhalten.

Funktioniert nicht als volles Programm, daher ÇŒṘdas unten stehende.

Perse , 21 Bytes

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

Möglicherweise habe ich die Listenpartitionsfunktion speziell für diese Herausforderung implementiert. Nimmt die Eingabe als ein Array von Zeichenfolgen.

Schale , 7 Bytes

Mof-"DL

Probieren Sie es online!

Erläuterung

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 dank @Nevay .

Erläuterung:

Probieren Sie es hier aus.

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

Oktave, 21 Bytes

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

Die Eingabe ist ein Array von Zeichen, die Ausgabe ist ein Zellenarray. Recycelt von meiner Antwort hier .

Beispielausführung auf ideone .

R , 35 Bytes

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

Probieren Sie es online!

Liest von stdin.

Julia, 26 Bytes

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

Haskell (Lambdabot), 41 Bytes

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

Probieren Sie es online!

PowerShell , 27 Byte

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

Probieren Sie es online!

Bearbeiten: zuvor $args.where({$_-eq'L'},'sp')für 28 Bytes. Könnte $args.where({+"0x$_"},'sp')für 27 sein, wenn nicht für die Regel, dass L zuerst kommen muss.

CJam , 14 Bytes

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

Eingabe ist eine Liste von Zeichen (String), Ausgabe ist eine Liste von Listen von Zeichen (Liste von Strings).

Probieren Sie es online!

Erläuterung:

"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

Probieren Sie es online!