救命！我的全自动黑暗照明分离器V3001.01坏了！:(

指导方针

任务

编写一个程序，该程序将以任意数量的字符串（字母L或字母D（代表亮或暗））输入一个数组（或某些语言的列表），并输出包含两个数组的数组，一个与所有的L和一个与所有的D。

规则

• 这是代码高尔夫，所以最短的答案以字节为单位
• 输入只会包含大写字母
• 输出中的L必须与输入中的L数量相同，D的数量相同
• 输入只能有一个元素（甚至可能有零个元素）
• 如果一个或两个输出数组不包含任何元素，则输出一个空列表（在某些语言中，这可能意味着您需要输出一个字符串）
• 始终将第一个数组作为L的数组

输出示例：

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

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

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

[] -> [[],[]]

APL，8个字节

'DL'~⍨¨⊂

说明：

• ⊂：封闭的输入
• ~⍨¨：没有每个
• 'DL'：'D'和'L'

例子：

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

Python 3，37个字节

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

在线尝试！

Haskell，28个字节

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

在线尝试！

如果输入内容可以是字符列表，则可以删除[]周围的字符c。

PHP，46字节

假定给定的列表是： $arr = ['L','L','D','D','L','D','D','D','D','L'];

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

Mathematica，27个字节

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

纯函数，将Ls和Ds 的列表（符号，而不是字符/字符串）作为输入并返回两个列表的列表。例如，

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

返回{{L, L, L}, {D, D}}。在线尝试！

Gather本身就很接近我们想要的东西，但是不能通过两种方式满足规范：如果输入缺少Ls或Ds，它不会产生空列表；并且它并不总是将Ls排在左边。将输入替换为#可以立即{L,D}~Join~#解决两个问题：这意味着将至少有一个L和至少一个D，并且Ls将首先返回，因为L首先遇到an 。Rest/@然后删除首字母L和D。

（我尝试了使用的解决方案Count，但由于遇到问题，它似乎并不短：±q_:=#~Table~Count[q,#]&/@{L,D}是31个字节。）

Haskell，32个字节

import Data.List
partition(>"K")

只是一个无聊的库函数。

在线尝试！

Ruby，26个字节

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

在线尝试！

PHP7，52个 45字节

-7个字节，感谢@JörgHülsermann

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

与CLI一起使用 php -r a.php L L L D D L D

该脚本将遍历提供的参数，然后根据其值将其附加到数组中。

Common Lisp，66 65字节

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

在线尝试！

如果我们使用符号而不是字符串，那么它会短很多：

Common Lisp，42 41 40字节

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

在线尝试！

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

拍子，48字节

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

只需将此匿名函数应用于例如 '(L D L D D L)

Mathematica，22个 18字节

4个字节由CalculatorFeline的天才保存！

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

在网上或在Wolfram沙箱上尝试！

输入是符号列表，L而D不是字符串，而是字母本身，就像格雷格·马丁的答案一样。语法#|L是简写Alternatives[#,L]，但@@@语法替换头Alternatives用Cases，所以这段代码等同于{Cases[#,L],Cases[#,D]}&。

Java 8，105字节

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

提示欢迎。

PPCG的新手，我必须import java.util.*;import java.util.stream.*;将字节数包括在内吗？

不竞争，它不会使用空输入创建空列表。感谢Nevay节省了一些字节。

序言（SWI） ，42，37个字节

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

在线尝试！

由于W是清洗名单，w/3将统一L和D成分别亮暗的名单，通过分割针对其成功如果一个项目是光谓词洗涤。

[编辑：打高尔夫球-5感谢Fatalize ]

Japt，13 12 10字节

2Æf¥"LD"gX

测试它（-Q仅用于可视化的标志）

说明

数组的隐式输入U。

2Æ

生成数组[0,1]并将每个元素X作为当前元素传递给函数。

f¥

U通过检查是否相等进行过滤...

"LD"gX

...字符串中的字符LD在index处X。

Pyth，10 9字节

mc@dQ1"LD

测试套件。

05AB1E，8个字节

'Lù'DÃ)

在线尝试！

Javascript（ES6），37个字节

这基于一个（现在已删除）JavaScript（ES6）答案。

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

非高尔夫版本：

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

示例代码段：

f=

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

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

C＃，61个字节

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

完整/格式化版本：

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个字节

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

在线尝试！

将输入作为字符串列表，并返回两个列表，第一个包含元素fun a -> a="L"为true的列表，另一个包含结果为false的元素。

果冻，10字节

ẎfЀ⁾LDW€€

在线尝试！

在Jelly中，字符串是1个字符的Python字符串的列表，例如['a', 'b', 'c']。这就是为什么要获取诸如之类的输出的原因[[['L'], ['L']], [['D'], ['D'], ['D']]]，因为1字符Jelly字符串的行为相同。

不能作为完整程序运行，因此ÇŒṘ位于底部。

英仙座，21字节

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

我可能已经或尚未实现专门针对此挑战的列表分区功能。将输入作为字符串数组。

外壳，7个字节

Mof-"DL

在线尝试！

说明

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

爪哇8，110个 106字节

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

-4个字节，感谢@Nevay。

说明：

在这里尝试。

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

八度，21字节

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

输入是字符数组，输出是单元格数组。从这里我的答案中回收。

在ideone上执行样本。

R，35个字节

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

在线尝试！

从stdin读取。

朱莉娅，26个字节

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

Haskell（Lambdabot），41个字节

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

在线尝试！

PowerShell，27个字节

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

在线尝试！

编辑：以前$args.where({$_-eq'L'},'sp')为28个字节。$args.where({+"0x$_"},'sp')如果不是L必须排在第一位的规则，则可能为27。

CJam，14个字节

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

输入是字符列表（字符串），输出是字符列表（字符串列表）。

在线尝试！

说明：

"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个字节

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

在线尝试！