ช่วยด้วย! ไฟอัตโนมัติสมบูรณ์ของฉันจากตัวแยกความมืด V3001.01หัก! :(

แนวทาง

งาน

เขียนโปรแกรมที่จะรับอินพุตของอาเรย์ (หรือรายการในบางภาษา) ของจำนวนสตริงใด ๆ ที่เป็นตัวอักษร L หรือตัวอักษร D (แทนไฟหรือความมืด) และส่งออกอาร์เรย์ที่มีสองอาร์เรย์หนึ่ง กับ L ทั้งหมดและอีกอันกับ D ทั้งหมด

กฎระเบียบ

• มันคือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในจำนวนไบต์ชนะ
• ข้อมูลที่ป้อนจะมีตัวพิมพ์ใหญ่เท่านั้น
• จะต้องมีจำนวน L เท่ากันในเอาต์พุตเนื่องจากมีอยู่ในอินพุตเหมือนกันกับ D's
• อินพุตอาจมีองค์ประกอบเดียวเท่านั้น (หรืออาจเป็นศูนย์ก็ได้ )
• หากหนึ่งหรือทั้งสองของอาร์เรย์เอาท์พุทไม่มีองค์ประกอบให้ส่งออกรายการที่ว่างเปล่า (ในบางภาษานี่อาจหมายความว่าคุณต้องเอาท์พุทสตริง)
• มีอาร์เรย์แรกเสมอเป็นอาร์เรย์ของ 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 และมันไม่ได้เรียงลำดับเสมอไปL s ไปทางซ้ายเสมอ การแทนที่อินพุต#ด้วยการ{L,D}~Join~#แก้ปัญหาทั้งสองในครั้งเดียว: หมายความว่าจะมีอย่างน้อยหนึ่งLและอย่างน้อยหนึ่งรายการDและLs จะถูกส่งกลับก่อนเนื่องจากLพบครั้งแรก Rest/@จากนั้นจะลบการเริ่มต้นLและDและ

(ฉันลองใช้วิธีแก้ปัญหาCountแต่เนื่องจากปัญหาการแก้ปัญหาดูเหมือนว่าจะไม่สั้นกว่า: ±q_:=#~Table~Count[q,#]&/@{L,D}31 ไบต์)

Haskell, 32 ไบต์

import Data.List
partition(>"K")

ฟังก์ชั่นห้องสมุดที่น่าเบื่อ

ลองออนไลน์!

ทับทิมขนาด 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

สคริปต์ต้องผ่านการขัดแย้งที่มีให้และผนวกเข้ากับอาร์เรย์ตามค่าของมัน

เสียงกระเพื่อมสามัญ66 65 ไบต์

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

ลองออนไลน์!

หากเราใช้สัญลักษณ์แทนสตริงดังนั้นมันจึงสั้นกว่ามาก:

เสียงกระเพื่อมสามัญ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)) 

Racket, 48 bytes

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

Just apply this anonymous function to, e.g., '(L D L D D L)

Mathematica, 22 18 bytes

4 bytes saved by the genius of CalculatorFeline!

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

Try it online, or at the Wolfram sandbox!

Input is a list of the symbols L and D — not strings, just the letters on their own, like in Greg Martin's answer. The syntax #|L is shorthand for Alternatives[#,L], but the @@@ syntax replaces the head Alternatives with Cases, so this code is equivalent to {Cases[#,L],Cases[#,D]}&.

Java 8, 105 bytes

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

Tips welcome.

New to PPCG, do I have to include import java.util.*;import java.util.stream.*; in the byte count?

Non-competing, it doesn't create empty lists with an empty input. Thanks to Nevay for saving some bytes.

Prolog (SWI), 42, 37 bytes

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

Try it online!

Given that W is a list of washing, w/3 will unify L and D into lists of Lights and Darks respectively, by partitioning the washing against a predicate which succeeds if an item is a Light.

[Edit: golfed -5 thanks to Fatalize]

Japt, 13 12 10 bytes

2Æf¥"LD"gX

Test it (-Q flag for visualisation purposes only)

Explanation

Implicit input of array U.

2Æ

Generate the array [0,1] and pass each element through a function, with X being the current element.

f¥

Filter U by checking for equality...

"LD"gX

...with the character in string LD at index X.

Pyth, 10 9 bytes

mc@dQ1"LD

Test suite.

05AB1E, 8 bytes

'Lù'DÃ)

Try it online!

Javascript (ES6), 37 bytes

This is based on a (now deleted) Javascript (ES6) answer.

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")];
}

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

Full/Formatted 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

Try it online!

Takes input as a list of strings, and returns two lists, the first with elements where fun a -> a="L" is true and the other with elements that result in false.

Jelly, 10 bytes

ẎfЀ⁾LDW€€

Try it online!

In Jelly a string is a list of 1-char Python strings, e.g. ['a', 'b', 'c']. That's why you get output such as [[['L'], ['L']], [['D'], ['D'], ['D']]], since 1-char Jelly strings behave the same.

Doesn't work as a full program, hence the ÇŒṘ at the bottom.

Perse, 21 bytes

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

I may or may not have implemented the list partition function specifically for this challenge. Takes the input as an array of strings.

Husk, 7 bytes

Mof-"DL

Try it online!

Explanation

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 thanks to @Nevay.

Explanation:

Try it here.

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!