मेरी धुलाई करने में मदद करें

Question

मदद! मेरी पूरी तरह से स्वचालित लाइट्स सेपरेटर V3001.01 टूट गया! :(

दिशा-निर्देश

---

कार्य

एक प्रोग्राम लिखें जो किसी भी प्रकार के तार की एक सरणी (या कुछ भाषाओं में एक सूची) का इनपुट लेगा जो कि या तो अक्षर L या अक्षर D (रोशनी या अंधेरे का प्रतिनिधित्व करते हैं) और एक सरणी को आउटपुट करते हैं जिसमें दो सरणियाँ होती हैं, एक सभी एल के साथ, और सभी डी के साथ।

---

नियम

• यह कोड गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा जवाब है
• इनपुट में केवल राजधानियाँ होंगी
• आउटपुट में L की संख्या उतनी ही होनी चाहिए जितनी इनपुट में होती है, वही D के लिए जाती है
• इनपुट में केवल एक तत्व हो सकता है (या शायद शून्य तत्व भी )
• यदि एक या दोनों आउटपुट सरणियों में कोई तत्व नहीं हैं, तो एक खाली सूची का उत्पादन करें (कुछ भाषाओं में इसका मतलब हो सकता है कि आपको एक स्ट्रिंग का उत्पादन करने की आवश्यकता है)
• हमेशा पहली सरणी L की सरणी हो

---

उदाहरण आउटपुट:

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

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

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

[] -> [[],[]]

Comments

क्या हम एक स्ट्रिंग के रूप में इनपुट / आउटपुट कर सकते हैं? उदाहरण के लिए: "LDLDD" -> "LL DDD"या ऐसा कुछ?

— कॉमरेड स्पार्कलेपनी

या शायद दो तारों की सूची के रूप में आउटपुट, उदाहरण के लिए "" LDLDD "-> [" LL "," DDD "]

— कॉमरेड स्पार्कलेपनी

एक उत्तर भी चाहेंगे, जैसा कि मेरा उत्तर इस पर निर्भर करता है

— स्किड्सदेव

मिश्रित उत्पादन के बारे में कैसे? जैसे कि एक स्ट्रिंग में एक स्ट्रिंग और एक सरणी में तार होते हैं? जैसे, ["L","L",["D","D","D"]]।

— झबरा

नहीं, आउटपुट एक सरणी / सूची होना चाहिए। @ कॉमरेडस्पार्कलेपनी

— अमोरिस

Answer 1

एपीएल, 8 बाइट्स

'DL'~⍨¨⊂

स्पष्टीकरण:

• ⊂: संलग्न इनपुट
• ~⍨¨: प्रत्येक के बिना
• 'DL': 'डी' और 'एल'

उदाहरण:

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

Comments

ऐसा क्यों है 'DL', लेकिन नहीं 'LD'?

— लीक नन

@ लीकन: जोड़ा गया स्पष्टीकरण। यह सही को चुनने के बजाय गलत चरित्र को हटाकर काम करता है।

— मारिनस

'LD'∩⍨¨⊂या ⍞∘∩¨'LD'समझाने में आसान हो सकता है।

— एडम जूल

Answer 2

पायथन 3 , 37 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 3

हास्केल , 28 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यदि इनपुट वर्णों की एक सूची हो सकती है, तो []आसपास cको हटाया जा सकता है।

Answer 4

PHP, 46 बाइट्स

मान लिया गया सूची है: $arr = ['L','L','D','D','L','D','D','D','D','L'];

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

Comments

डिफ़ॉल्ट I / O नियम के रूप में, आप यह नहीं मान सकते हैं कि इनपुट एक चर में संग्रहीत है

— Keyu Gan

@ केकयगन अर्घ! फेयर काफी

— स्कॉटमैक्ग्रेड

$argvइसके बजाय $arrकमांड लाइन से स्क्रिप्ट को चलाने के लिए उपयोग कर सकते हैं और उम्मीद कर सकते हैं php -f golf.php L L D D L D D D D L- लेकिन फिर आपको $ argv [0] के आसपास जाना होगा जो कि फ़ाइल का नाम है

— Ezenhis

इस तरह का उपयोग कर कम से कम समाधान कर रहे हैं for(;$b=$argv[++$i];)$a[$b][]=$b;print_r($a);या<?foreach($_GET as$b)$a[$b][]=$b;print_r($a);

— Jörg Hülsermann

मेरा पहला गोल्फ प्रयास वर्षों के बाद दुबका हुआ है और मैं अभी भी कुल शौकिया हूँ! प्रतिक्रिया के लिए धन्यवाद (और वोट) हालांकि हर कोई :)!

— स्कॉट मैक्ग्रे पहले से ही 23

Answer 5

गणितज्ञ, 27 बाइट्स

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

शुद्ध फ़ंक्शन इनपुट के रूप में Ls और Ds (प्रतीकों, वर्ण / तार नहीं) की सूची ले रहा है और दो सूचियों की सूची लौटा रहा है। उदाहरण के लिए,

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

लौटता है {{L, L, L}, {D, D}}। इसे ऑनलाइन आज़माएं!

Gatherअपने आप से जो हम चाहते हैं उसके करीब है, लेकिन दो तरीकों से कल्पना को पूरा करने में विफल रहता है: यह खाली सूचियों का उत्पादन नहीं करता है यदि इनपुट गायब है Lया Dएस, और यह हमेशा Lबाईं ओर सॉर्ट नहीं करता है । एक बार में दोनों समस्याओं को हल करने के #साथ इनपुट को प्रतिस्थापित करना {L,D}~Join~#: इसका मतलब है कि कम से कम एक Lऔर कम से कम एक होगा D, और Lएस को पहले लौटा दिया जाएगा क्योंकि Lपहले सामना किया गया था। Rest/@फिर प्रारंभिक Lऔर हटाता है D।

(मैंने एक समाधान का उपयोग करने की कोशिश की Count, लेकिन करी मुद्दों के कारण, यह छोटा नहीं लगता था: ±q_:=#~Table~Count[q,#]&/@{L,D}31 बाइट्स है।)

Comments

TIO लिंक (गणित)?

— लीक नून

कैसे के बारे में Cases@@@{{#,L},{#,D}}&, 22 बाइट्स के लिए?

— एक पेड़ नहीं

महान विचार, पेड़ नहीं! आपको उस उत्तर को पोस्ट करना चाहिए- I upvote :)

— ग्रेग मार्टिन

किया हुआ!

— पेड़ नहीं

Answer 6

हास्केल, 32 बाइट्स

import Data.List
partition(>"K")

बस एक उबाऊ पुस्तकालय समारोह।

इसे ऑनलाइन आज़माएं!

Comments

कोई आयात के साथ प्रयास करें: P

— अमोरिस

Answer 7

माणिक , 26 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 8

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

स्क्रिप्ट प्रदान किए गए तर्कों के माध्यम से जाती है और उन्हें इसके मूल्य के आधार पर एक सरणी में जोड़ देती है।

Comments

45 बाइट्स -rको -fहटाने के बजाय विकल्प का उपयोग करने के <?phpबाद और जगह को गिरा देंas

— Jörg Hülsermann

Answer 9

आम लिस्प, 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)) 

Answer 10

रैकेट , 48 बाइट्स

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

बस इस अनाम फ़ंक्शन को लागू करें, जैसे, '(L D L D D L)

Answer 11

गणितज्ञ, 22 18 बाइट्स

कैलक्यूलेटरफल की प्रतिभा द्वारा 4 बाइट्स बचाए गए!

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

इसे ऑनलाइन या वुल्फ्राम सैंडबॉक्स पर आज़माएं !

इनपुट प्रतीकों की एक सूची है - Lऔर Dतार नहीं, बस अपने आप ही पत्र, जैसे कि ग्रेग मार्टिन के उत्तर में । सिंटैक्स के #|Lलिए शॉर्टहैंड है Alternatives[#,L], लेकिन @@@सिंटैक्स सिर Alternativesको बदल देता है Cases, इसलिए यह कोड बराबर है {Cases[#,L],Cases[#,D]}&।

Comments

{#,x}#|x-4 बाइट्स के लिए हो सकता है ।

— कैलक्यूलेटरफुल

@CalculatorFeline, वाह, यह चाल अद्भुत है! धन्यवाद!

— एक पेड़

@@और @@@किसी भी सिर के साथ काम करें, न कि सिर्फ List। अगर |नहीं काम करता है, तब भी आप के साथ कुछ मामलों में बचा सकता है &&, ||या **।

— कैलक्यूलेटरफ्लेन

तुम भी .और अंकगणित ऑपरेटरों का उपयोग कर सकते हैं ।

— कैलक्यूलेटरफ्लीन

इसके अलावा, पूर्वगामी दुर्व्यवहार से आपके लिए अधिक बचत होती है (आउटपुट स्वरूप में बदलाव के साथ):#.L|#.D

— कैलक्यूलेटरफ्लेन

Answer 12

जावा 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.*;बाइट की गिनती में शामिल होना है?

---

गैर-प्रतिस्पर्धात्मक, यह एक खाली इनपुट के साथ खाली सूची नहीं बनाता है। कुछ बाइट्स बचाने के लिए नेवे का धन्यवाद।

Comments

आयात की गणना की जानी चाहिए, या आप अपने वर्ग के नामों को पूरी तरह से योग्य कर सकते हैं यदि वह छोटा है।

आप आयात को कम करने के बजाय और इसके Stream#ofबजाय उपयोग कर सकते हैं । इसके अलावा कि कोड की आवश्यकताओं को पूरा नहीं करता है के रूप में यह उत्पादन एक खाली सूची है, तो कोई नहीं है / मौजूद है (परीक्षण मामलों 2-4)। Arrays#streamjava.util.stream.*"D"::equalsk->k.equals("D")LD

— नेवले

PPCG में आपका स्वागत है! दुर्भाग्य से, अमान्य उत्तरों को गैर-प्रतिस्पर्धी के रूप में चिह्नित नहीं किया जा सकता है। इस उत्तर को वैध बनाने के लिए इसे संशोधित करने के लिए आपका स्वागत है, लेकिन अभी के लिए इसे हटा दिया जाना चाहिए। (आपको शायद इसे स्वयं हटा देना चाहिए; यदि कोई मॉड इसे हटाता है, तो काम करने का एक बार समाधान होने के बाद आप इसे अपने आप से हटा नहीं सकते हैं।)

— बजे फल जूड

Answer 13

प्रोलोग (एसडब्ल्यूआई) , 42 , 37 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह देखते हुए कि Wधुलाई की एक सूची है, w/3एकजुट हो जाएगा LऔरD रोशनी और अंधेरे की सूचियों में क्रमशः एक विभाजन के खिलाफ धुलाई का विभाजन करके, जो सफल होता है यदि कोई आइटम लाइट है।

[संपादित करें: golfed -5 के लिए धन्यवाद Fatalize ]

Comments

l('L').5 बाइट्स से कम हैl(X):-X='L'.

— घातक

@Fatalize - धन्यवाद! में संपादित किया गया।

— TessellatingHeckler

Answer 14

जाप , 13 12 10 बाइट्स

2Æf¥"LD"gX

इसका परीक्षण करें ( -Qकेवल विज़ुअलाइज़ेशन उद्देश्यों के लिए ध्वज)

---

व्याख्या

सरणी का निहित इनपुट U।

2Æ

सरणी बनाएं [0,1]और प्रत्येक तत्व को फ़ंक्शन के माध्यम से Xचालू करें, वर्तमान तत्व होने के साथ ।

f¥

Uसमानता के लिए जाँच करके फ़िल्टर करें ...

"LD"gX

... LDसूचकांक में स्ट्रिंग में चरित्र के साथ X।

Comments

"हम्म, ¥काम हटा देना चाहिए ..." [["L","L","D","D"],[]]"नहीं, वहां नहीं जा रहे :)" - मुझे 2017

— ETHproductions

@ETHproductions: हा-हा! हाँ, मैंने इसके बिना काम करने की कोशिश करने के कई तरीके आजमाए ¥।

— शैगी

Answer 15

अजगर , 10 9 बाइट्स

mc@dQ1"LD

टेस्ट सूट ।

Comments

का उपयोग कम.g लगता है ।

— FryAmTheEggman

Answer 16

05AB1E , 8 बाइट्स

'Lù'DÃ)

इसे ऑनलाइन आज़माएं!

Answer 17

जावास्क्रिप्ट (ईएस 6), 37 बाइट्स

यह एक (अब हटाए गए) जावास्क्रिप्ट (ES6) उत्तर पर आधारित है।

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

Ungolfed संस्करण:

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

Answer 18

सी #, 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();
    }
}

Answer 19

एफ # , 37 बाइट्स

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

इसे ऑनलाइन आज़माएं!

इनपुट को स्ट्रिंग्स की एक सूची के रूप में लेता है, और दो सूचियों को वापस करता है, पहला उन तत्वों के साथ fun a -> a="L"जो सत्य है और दूसरा उन तत्वों के साथ है जिनके परिणामस्वरूप गलत है।

Answer 20

जेली , 10 बाइट्स

ẎfЀ⁾LDW€€

इसे ऑनलाइन आज़माएं!

जेली में एक स्ट्रिंग 1-चार पायथन स्ट्रिंग्स की सूची है, जैसे ['a', 'b', 'c']। इसलिए आपको आउटपुट मिलता है जैसे[[['L'], ['L']], [['D'], ['D'], ['D']]] , 1-चार जेली स्ट्रिंग्स एक ही व्यवहार करते हैं।

एक पूर्ण कार्यक्रम के रूप में काम नहीं करता है, इसलिए ÇŒṘतल पर।

Comments

@ लियो हम्म, आप सही हो सकते हैं ... निश्चित।

— एर्ग आउटफोलर

ऐसा लगता है कि जेली इनपुट जेली आउटपुट से अलग है? क्या दुभाषिया string->char[]स्वचालित रूप से करता है?

— nmjcman101

@ nmjcman101 स्ट्रिंग्स पर यह अलग है, क्योंकि इनपुट पायथन प्रारूप में है और आउटपुट जेली प्रारूप में है। इसलिए मुझे W€€हिस्सा चाहिए।

— एरिक आउटगॉल्फ जूल

Answer 21

पद , 21 बाइट्स

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

मैं विशेष रूप से इस चुनौती के लिए सूची विभाजन समारोह को लागू कर सकता हूं या नहीं कर सकता। इनपुट को स्ट्रिंग्स की एक सरणी के रूप में लेता है।

Answer 22

भूसी , 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

Answer 23

जावा 8, 110 106 बाइट्स

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

-4 बाइट्स थैंक्स टू @ नवे ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

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

Comments

If-else स्टेटमेंट को हटाने के लिए आप सरणी में l और d स्टोर कर सकते हैं। a->{String[]r={"",""};for(char c:a)r[c/69]+=c;return new char[][]{r[1].toCharArray(),r[0].toCharArray()};}(-4 बाइट्स)

— नेवले जूल

Answer 24

ऑक्टेव, 21 बाइट्स

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

इनपुट वर्णों की एक सरणी है, आउटपुट एक सेल सरणी है। मेरे उत्तर से पुनर्नवीनीकरण यहाँ ।

Ideone पर नमूना निष्पादन ।

Answer 25

आर , 35 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्टड से पढ़ता है।

Answer 26

जूलिया, 26 बाइट्स

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

Answer 27

हास्केल (लैंबडॉट), 41 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 28

पॉवरशेल , 27 बाइट्स

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

इसे ऑनलाइन आज़माएं!

---

संपादित करें: पहले $args.where({$_-eq'L'},'sp')28 बाइट्स के लिए। $args.where({+"0x$_"},'sp')27 के लिए हो सकता है यदि उस नियम के लिए नहीं जो L के पहले आना चाहिए।

Answer 29

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

Answer 30

पर्ल 5 , 70 बाइट्स

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

इसे ऑनलाइन आज़माएं!