Помогите! Мои полностью автоматизированные фары от Darks Separator V3001.01 сломались! :(

Методические рекомендации

задача

Напишите программу, которая будет принимать входные данные массива (или списка на некоторых языках) любого количества строк, которые представляют собой либо букву L, либо букву D (представляющую свет или штрихи), и выводят массив, содержащий два массива, один со всеми буквами «L» и со всеми буквами «D».

правила

• Это код гольф, поэтому выигрывает самый короткий ответ в байтах
• На входе будут только прописные буквы
• На выходе должно быть одинаковое количество букв L и столько же, сколько на входе.
• Вход может иметь только один элемент (или, может быть, даже нулевые элементы)
• Если один или оба выходных массива не содержат элементов, выведите пустой список (в некоторых языках это может означать, что вам нужно вывести строку)
• Всегда иметь первый массив быть массивом 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, а Lс будет возвращен первый так как 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örg Hü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в индексе 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

Попробуйте онлайн!

Принимает input как список строк и возвращает два списка, первый с элементами, где 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

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

Ввод - это массив символов, вывод - это массив ячеек. Восстановлено из моего ответа здесь .

Пример исполнения на идеоне .

R 35 байт

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

Попробуйте онлайн!

Читает со стандартного ввода.

Юлия, 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')для 27, если не для правила, что L должны быть на первом месте.

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

Попробуйте онлайн!