Yardım et! Benim Acı Ayırıcı V3001.01 itibaren Tamamen Otomatik Işıklar kırdı! :(

Kuralları

Görev

L harfi veya D harfi (ışıklar veya karanlıkları temsil eden) herhangi bir miktarda dizenin (veya bazı dillerde bir listenin) girdisini alacak bir program yazın ve iki dizi içeren bir dizi çıktısı alın. tüm L'ler ile ve bir de D'ler ile.

kurallar

• Kod golf, bayt cinsinden en kısa cevap kazanır
• Girdi yalnızca hiç büyük harf içerecek
• Girişte olduğu gibi çıktıda aynı L sayısı bulunmalıdır, aynı D'ler için de geçerli
• Giriş sadece bir elemente sahip olabilir (veya belki de sıfır elementler)
• Çıktı dizilerinden biri veya her ikisi de eleman içermiyorsa, boş bir liste çıktılayın (bazı dillerde bu, bir dizge çıkarmanız gerekebileceği anlamına gelir)
• Her zaman ilk dizinin L's dizisi olması

Örnek çıktı:

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

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

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

[] -> [[],[]]

APL, 8 bayt

'DL'~⍨¨⊂

Açıklama:

• ⊂: kapalı giriş
• ~⍨¨: her biri olmadan
• 'DL': 'D' ve 'L'

Örnekler:

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

Python 3 , 37 bayt

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

Çevrimiçi deneyin!

Haskell , 28 bayt

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

Çevrimiçi deneyin!

Giriş bir karakter listesi olabiliyorsa , []etraftakiler ckaldırılabilir.

PHP, 46 bayt

Verilen listenin: $arr = ['L','L','D','D','L','D','D','D','D','L'];

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

Mathematica, 27 bayt

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

Girdi olarak Ls ve Ds (sembol, karakter / karakter değil) listesini alan ve iki listenin bir listesini döndüren saf işlev . Örneğin,

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

döner {{L, L, L}, {D, D}}. Çevrimiçi deneyin!

Gatherkendi başımıza istediklerimize yakın, ancak iki şekilde belirtimi karşılayamıyor: giriş eksik Lveya eksikse boş listeler üretmiyor Dve her zaman Lsola göre sıralamıyor. Girdiyi değiştirmek aynı anda her iki sorunu #da {L,D}~Join~#çözer: en az bir Lve en az bir tane olacağı Dve Ls ilk Lkarşılaştığından beri ilk önce geri döneceği anlamına gelir . Rest/@sonra başlangıç ​​kaldırır LveD .

(Kullanarak bir çözüm denedim Count, ancak sorunların körüklenmesi nedeniyle kısa gözükmüyordu: ±q_:=#~Table~Count[q,#]&/@{L,D}31 bayttır.)

Haskell, 32 bayt

import Data.List
partition(>"K")

Sadece sıkıcı bir kütüphane işlevi.

Çevrimiçi deneyin!

Ruby , 26 bayt

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

Çevrimiçi deneyin!

PHP7, 52 45 bayt

@ Jörg Hülsermann sayesinde -7 bayt

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

CLI ile kullan php -r a.php L L L D D L D

Betik, sağlanan argümanları gözden geçirir ve bunları değerini temel alan bir diziye ekler.

Ortak Lisp, 66 65 bayt

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

Çevrimiçi deneyin!

Dizeler yerine, semboller kullanırsak, o zaman çok daha kısa olur:

Ortak Lisp, 42 41 40 bayt

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

Çevrimiçi deneyin!

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

Raket , 48 bayt

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

Sadece bu isimsiz işlevi, örneğin '(L D L D D L)

Mathematica, 22 18 bayt

CalculatorFeline dehası tarafından kaydedilen 4 bayt!

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

Çevrimiçi deneyin ya da Wolfram sanal alanında !

Girdi sembollerin bir listesi Lve Ddeğil dizeleri, gibi kendi başlarına sadece harfler, - Greg Martin'in cevabı . Sözdizimi #|Liçin kısaltmadır Alternatives[#,L], ancak @@@sözdizimi kafa değiştirir Alternativesile Casesbu kod eşdeğerdir, böylece {Cases[#,L],Cases[#,D]}&.

Java 8, 105 bayt

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

İpuçları hoş geldiniz.

PPCG'de yeni import java.util.*;import java.util.stream.*;olan bayt sayımına dahil etmek zorunda mıyım ?

Rekabet etmeyen, boş bir giriş ile boş listeler oluşturmaz. Bazı baytları kaydettiğiniz için Nevay'a teşekkür ederiz.

Prolog (SWI) , 42 , 37 bayt

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

Çevrimiçi deneyin!

Bu verilen Wbir yıkama listesi, w/3birleştirecek LveD bir öğe bir Işıksa başarılı olan bir yüklemeye göre ayrılarak sırasıyla Işıklar ve Karanlıklar listesine .

[Düzenle: Fatalize sayesinde -5 golf oynadı ]

Japt , 13 12 10 bayt

2Æf¥"LD"gX

Test et ( -Qyalnızca görselleştirme amaçlı bayrak)

açıklama

Dizinin örtük girişi U.

2Æ

Diziyi oluşturun [0,1]ve her öğeyi Xgeçerli öğe olarak işlevden geçirin.

f¥

UEşitliği kontrol ederek filtrele ...

"LD"gX

... dizedeki karakterin bulunduğu LDdizinde X.

Pyth , 10 9 bayt

mc@dQ1"LD

Test paketi .

05AB1E , 8 bayt

'Lù'DÃ)

Çevrimiçi deneyin!

Javascript (ES6), 37 bayt

Bu bir (şimdi silinmiş) Javascript (ES6) cevabına dayanmaktadır.

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

Ungolfed versiyonu:

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

Örnek kod pasajı:

f=

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

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

C #, 61 bayt

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

Tam / Biçimli Sürüm:

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 bayt

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

Çevrimiçi deneyin!

Dizelerin bir listesi olarak girdiyi alır ve ilkini fun a -> a="L"doğru olan elementlerle, diğerini de yanlış yapan sonuçlarla iki liste döndürür .

Jöle , 10 bayt

ẎfЀ⁾LDW€€

Çevrimiçi deneyin!

Jelly'te bir dize 1-karakterli Python dizelerinin bir listesidir, örn ['a', 'b', 'c']. Bu yüzden çıktı alırsınız [[['L'], ['L']], [['D'], ['D'], ['D']]], çünkü 1-char Jelly dizeleri aynı davranır.

Tam bir program olarak çalışmaz, bu nedenle ÇŒṘalt kısımda.

Perse , 21 bayt

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

Liste bölümleme işlevini özellikle bu görev için özel olarak kullanabilir veya uygulamamış olabilirim. Girdiyi bir dizi dizisi olarak alır.

Kabuğu , 7 bayt

Mof-"DL

Çevrimiçi deneyin!

açıklama

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 bayt

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

@Nevay sayesinde -4 bayt .

Açıklama:

Burada dene.

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 bayt

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

Giriş bir karakter dizisi, çıkış bir hücre dizisidir. Cevabımdaki geri dönüşümü burada .

İdeone üzerinde örnek uygulama .

R , 35 bayt

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

Çevrimiçi deneyin!

Stdin'den okur.

Julia, 26 bayt

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

Haskell (Lambdabot), 41 bayt

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

Çevrimiçi deneyin!

PowerShell , 27 bayt

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

Çevrimiçi deneyin!

Düzenleme: daha önce $args.where({$_-eq'L'},'sp')28 bayt için. Olabilir $args.where({+"0x$_"},'sp')L'nin ilk gelmesi gerektiğini kural için değilse 27 için.

CJam , 14 bayt

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

Giriş bir karakter listesidir (dize), çıktı karakter listesidir (dizeler listesi).

Çevrimiçi deneyin!

Açıklama:

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