Cứu giúp! Đèn tự động hoàn toàn của tôi từ Máy phân tách bóng tối V3001.01 đã bị hỏng ! :

Hướng dẫn

Bài tập

Viết chương trình sẽ lấy đầu vào của một mảng (hoặc danh sách bằng một số ngôn ngữ) của bất kỳ số lượng chuỗi nào là chữ L hoặc chữ D (đại diện cho ánh sáng hoặc bóng tối) và xuất ra một mảng có hai mảng, một mảng với tất cả các L và một với tất cả các D.

Quy tắc

• Đó là mã golf nên câu trả lời ngắn nhất tính bằng byte sẽ thắng
• Đầu vào sẽ chỉ bao gồm thủ đô
• Phải có cùng số L trong đầu ra như ở đầu vào, tương tự với D
• Đầu vào có thể chỉ có một yếu tố (hoặc thậm chí có thể bằng 0 )
• Nếu một hoặc cả hai mảng đầu ra không chứa phần tử, hãy đưa ra một danh sách trống (trong một số ngôn ngữ, điều này có thể có nghĩa là bạn cần xuất một chuỗi)
• Luôn có mảng đầu tiên là mảng của L

Ví dụ đầu ra:

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

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

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

[] -> [[],[]]

APL, 8 byte

'DL'~⍨¨⊂

Giải trình:

• ⊂: đầu vào kèm theo
• ~⍨¨: không có mỗi
• 'DL': 'D' và 'L'

Ví dụ:

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

Hãy thử trực tuyến!

Haskell , 28 byte

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

Hãy thử trực tuyến!

Nếu đầu vào có thể là một danh sách các ký tự, []xung quanh ccó thể được loại bỏ.

PHP, 46 byte

Danh sách giả định là: $arr = ['L','L','D','D','L','D','D','D','D','L'];

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

Toán học, 27 byte

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

Hàm thuần túy lấy danh sách Ls và Ds (ký hiệu, không phải ký tự / chuỗi) làm đầu vào và trả về danh sách hai danh sách. Ví dụ,

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

trả lại {{L, L, L}, {D, D}}. Hãy thử trực tuyến!

Gatherbởi chính nó gần với những gì chúng ta muốn, nhưng không đáp ứng được thông số theo hai cách: nó không tạo ra danh sách trống nếu đầu vào bị thiếu Ls hoặc Ds, và nó không luôn luôn sắp xếp Lsang trái. Thay thế đầu vào #bằng cách {L,D}~Join~#giải quyết cả hai vấn đề cùng một lúc: điều đó có nghĩa là sẽ có ít nhất một Lvà ít nhất một Dvà Ls sẽ được trả về trước kể từ Llần đầu tiên gặp phải. Rest/@sau đó loại bỏ ban đầu Lvà D.

(Tôi đã thử một giải pháp bằng cách sử dụng Count, nhưng do các vấn đề về cà ri, nó dường như không ngắn hơn: ±q_:=#~Table~Count[q,#]&/@{L,D}là 31 byte.)

Haskell, 32 byte

import Data.List
partition(>"K")

Chỉ là một chức năng thư viện nhàm chán.

Hãy thử trực tuyến!

Ruby , 26 byte

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

Hãy thử trực tuyến!

PHP7, 52 45 byte

-7 byte nhờ @ Jörg Hülsermann

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

Sử dụng với CLI như php -r a.php L L L D D L D

Kịch bản đi qua các đối số được cung cấp và nối chúng vào một mảng dựa trên giá trị của nó.

Lisp thường gặp, 66 65 byte

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

Hãy thử trực tuyến!

Nếu, thay vì các chuỗi, chúng tôi sử dụng các ký hiệu, thì nó ngắn hơn nhiều:

Lisp thường gặp, 42 41 40 byte

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

Hãy thử trực tuyến!

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

Vợt , 48 byte

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

Chỉ cần áp dụng chức năng ẩn danh này, vd '(L D L D D L)

Toán học, 22 18 byte

4 byte được lưu bởi thiên tài của CalculatorFeline!

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

Hãy thử trực tuyến hoặc tại hộp cát Wolfram !

Đầu vào là một danh sách các ký hiệu Lvà D- không phải các chuỗi, chỉ các chữ cái riêng, giống như trong câu trả lời của Greg Martin . Cú pháp #|Llà tốc ký Alternatives[#,L], nhưng @@@cú pháp thay thế phần đầu Alternativesbằng Cases, vì vậy mã này tương đương với {Cases[#,L],Cases[#,D]}&.

Java 8, 105 byte

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

Lời khuyên chào mừng.

Mới sử dụng PPCG, tôi có phải đưa import java.util.*;import java.util.stream.*;vào số byte không?

Không cạnh tranh, nó không tạo danh sách trống với đầu vào trống. Cảm ơn Nevay vì đã lưu một số byte.

Prolog (SWI) , 42 , 37 byte

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

Hãy thử trực tuyến!

Cho rằng đó Wlà danh sách giặt, w/3sẽ thống nhất Lvà Dđưa vào danh sách Ánh sáng và Bóng tối tương ứng, bằng cách phân vùng giặt theo một vị từ thành công nếu vật phẩm là Ánh sáng.

[Chỉnh sửa: đánh gôn -5 nhờ Fatalize ]

Japt , 13 12 10 byte

2Æf¥"LD"gX

Kiểm tra nó ( -Qcờ cho mục đích trực quan hóa)

Giải trình

Đầu vào ngầm định của mảng U.

2Æ

Tạo mảng [0,1]và truyền từng phần tử thông qua một hàm, với Xphần tử hiện tại.

f¥

Lọc Ubằng cách kiểm tra sự bằng nhau ...

"LD"gX

... với ký tự trong chuỗi LDtại chỉ mục X.

Bình thường , 10 9 byte

mc@dQ1"LD

Bộ thử nghiệm .

05AB1E , 8 byte

'Lù'DÃ)

Hãy thử trực tuyến!

Javascript (ES6), 37 byte

Điều này dựa trên câu trả lời (hiện đã bị xóa) Javascript (ES6).

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

Phiên bản bị đánh cắp:

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

Đoạn mã ví dụ:

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

Phiên bản đầy đủ / định dạng:

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

Hãy thử trực tuyến!

Lấy đầu vào dưới dạng danh sách các chuỗi và trả về hai danh sách, danh sách đầu tiên có các phần tử fun a -> a="L"là đúng và phần còn lại có các phần tử dẫn đến sai.

Thạch , 10 byte

ẎfЀ⁾LDW€€

Hãy thử trực tuyến!

Trong Jelly một chuỗi là danh sách các chuỗi Python 1-char, vd ['a', 'b', 'c']. Đó là lý do tại sao bạn nhận được đầu ra như[[['L'], ['L']], [['D'], ['D'], ['D']]] , vì các chuỗi Jelly 1-char hoạt động giống nhau.

Không hoạt động như một chương trình đầy đủ, do đó ÇŒṘở phía dưới.

Perse , 21 byte

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

Tôi có thể hoặc không thể thực hiện chức năng phân vùng danh sách cụ thể cho thử thách này. Lấy đầu vào là một chuỗi các chuỗi.

Husk , 7 byte

Mof-"DL

Hãy thử trực tuyến!

Giải trình

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 nhờ @Nevay .

Giải trình:

Hãy thử nó ở đây.

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 byte

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

Đầu vào là một mảng các ký tự, đầu ra là một mảng ô. Tái chế từ câu trả lời của tôi ở đây .

Thực hiện mẫu trên ideone .

R , 35 byte

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

Hãy thử trực tuyến!

Đọc từ stdin.

Julia, 26 byte

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

Haskell (Lambdabot), 41 byte

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

Hãy thử trực tuyến!

PowerShell , 27 byte

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

Hãy thử trực tuyến!

Chỉnh sửa: trước đây $args.where({$_-eq'L'},'sp')cho 28 byte. Có thể là $args.where({+"0x$_"},'sp')27 nếu không phải vì quy tắc mà L phải đến trước.

CJam , 14 byte

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

Đầu vào là danh sách các ký tự (chuỗi), đầu ra là danh sách các danh sách các ký tự (danh sách các chuỗi).

Hãy thử trực tuyến!

Giải trình:

"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 byte

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

Hãy thử trực tuyến!