अमृत ​​अर्रे सिंथेटिक शुगर

17

अमृत ​​में, (लिंक की गई) सूचियाँ प्रारूप में हैं, [head | tail]जहाँ सिर कुछ भी हो सकता है और पूंछ बाकी सूची की एक सूची है, और []- खाली सूची - इसके लिए एकमात्र अपवाद है।

सूचियाँ भी लिखी जा सकती हैं जैसे [1, 2, 3]कि इसके बराबर है[1 | [2 | [3 | []]]]

आपका कार्य वर्णित के रूप में एक सूची में परिवर्तित करना है। इनपुट हमेशा एक मान्य सूची (अमृत में) होगी जिसमें केवल रेक्सक्स से मेल खाते नंबर होंगे \[(\d+(, ?\d+)*)?\]। आप इनपुट के साथ (प्रत्येक अल्पविराम के बाद एक स्थान) या रिक्त स्थान के बिना ले सकते हैं। आउटपुट (प्रत्येक से पहले और बाद में एक स्थान |) या रिक्त स्थान के बिना हो सकता है।

अग्रणी शून्य के साथ इनपुट के लिए आप या तो शून्य के साथ या बिना आउटपुट कर सकते हैं।

इनपुट को एक स्ट्रिंग के रूप में लिया जाना चाहिए (यदि कोई फ़ंक्शन लिख रहा है), जैसा कि आउटपुट करता है।

उदाहरण

[] -> []
[5] -> [5 | []]
[1, 7] -> [1 | [7 | []]]
[4, 4, 4] -> [4 | [4 | [4 | []]]]
[10, 333] -> [10 | [333 | []]]

संबंधित , नहीं एक डुप्लिकेट के रूप में इस भाग में ]अंत करने के लिए मोड जोड़ने शामिल है । इसके अतिरिक्त, यहां हास्केल का उत्तर वहां के व्यक्ति से काफी भिन्न है।

code-golf  string  parsing 
— Okx
स्रोत
5
-1 मुझसे। बोझिल आईओ प्रारूप हतोत्साहित होते हैं। यदि इनपुट एक सूची है, तो हमें इनपुट के पार्सिंग के बजाय हमारे कोड का 90% होने के बजाय इसे एक सूची के रूप में लें
— जो किंग
2
क्या हमें प्रमुख 0s का समर्थन करना है? वे रेगेक्स फिट करते हैं।
— जो किंग
2
— NoOneIsHere
5
@JoKing मैं तर्क दूंगा कि यहां चुनौती दो विशिष्ट स्वरूपों के बीच परिवर्तित होने के बारे में है, इसलिए इनपुट को पार्स करना चुनौती का एक मूलभूत हिस्सा है और इसमें कुछ अतिरिक्त नहीं जोड़ा गया है। PS मुझे अब केवल एहसास हुआ है कि आपका उपनाम वास्तव में क्या है
— सिंह
2
@MuhammadSalman: चुनौती को "पार्सिंग" के रूप में चिह्नित किया गया है, इसलिए / से एक स्ट्रिंग में परिवर्तित करना इरादे के साथ इसका एक महत्वपूर्ण हिस्सा है।
— nimi

जवाबों:

9

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

f.read
f(a:b)='[':show(a+0)++'|':f b++"]"
f _="[]"

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

+0हास्केल प्रकार चेकर पता है कि हम संख्या की सूची के साथ काम कर रहे हैं देता है, ताकि readहमारे लिए इनपुट स्ट्रिंग पार्स होगा।

— nimi
स्रोत
1
+1, मुझे +0 चाल पसंद है!
— बी। मेहता
4

रेटिना , 39 33 32 20 बाइट्स

\b]
,]
+`,(.*)
|[$1]

H.PWiz, ovs, ASCII- केवल, और नील की बदौलत 13 बाइट्स बचाए।
इसे ऑनलाइन आज़माएं!

व्याख्या

\b]
,]

यदि हमारे पास कोई खाली सूची नहीं है, तो एक अनुगामी अल्पविराम जोड़ें।

+`,(.*)
|[$1]

जबकि अल्पविराम हैं, चीजों को लपेटें |[ thing ]।

@ नोव्स 24?
— केवल
— केवल
@ ASCII- केवल आप के \b]साथ प्रतिस्थापित करके अन्य 4 बाइट्स बचा सकते हैं,] । (अन्यथा मैंने स्वतंत्र रूप से एक ही समाधान खोजा था।)
— नील
ओह! वह सही है। मैं \bकिसी कारण से भूल गया था> _> 20 बाइट्स @Mememonic
— केवल
3

अमृत , 111 85 बाइट्स

f=fn[h|t],f->"[#{h}|#{f.(t,f)}]"
[],_->"[]"
h,f->f.(elem(Code.eval_string(h),0),f)end

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

मैंने पहले कभी अमृत का इस्तेमाल नहीं किया। एक फ़ंक्शन को परिभाषित करता है जो एक स्ट्रिंग और खुद को एक संदर्भ लेता है और एक स्ट्रिंग लौटाता है।

— मजाक कर रहा है
स्रोत
3

सीलोन , 113 बाइट्स

String p(String s)=>s.split(" ,[]".contains).select((x)=>!x.empty).reversed.fold("[]")((t,h)=>"[``h`` | ``t``]");

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

यहाँ यह लिखा है:

// define a function p mapping Strings to Strings.
String p(String s) =>
    // we split the string at all characters which are brackets, comma or space.
    s.split(" ,[]".contains)    // → {String+}, e.g.  { "", "1", "7", "" }
    // That iterable contains empty strings, so let's remove them.
    // Using `select` instead of `filter` makes the result a sequential instead of
    // an Iterable.
     .select((x)=>!x.empty)    // → [String*], e.g.   [1, 7]
    // now invert the order.
    // (This needs a Sequential (or at least a List) instead of an Iterable.)
     .reversed                 // → [String*], e.g.   [7, 1]
    // Now iterate over the list, starting with "[]", and apply a function
    // to each element with the intermediate result.
     .fold("[]")                       // → String(String(String, String))
    //    This function takes the intermediate result `t` (for tail) and an element
    //    `h` (for head), and puts them together into brackets, with a " | " in the
    //    middle. This uses String interpolation, I could have used `"+` and `+"`
    //    instead for the same length.
          ((t,h)=>"[``h`` | ``t``]");  // → String

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

जैसा कि (अब हटाए गए) टिप्पणी में ovs द्वारा उल्लेख किया गया है: यदि कोई प्रश्न में संकेतित इनपुट और आउटपुट के लिए "रिक्त स्थान के बिना" विकल्पों का चयन करता है, तो 3 अधिक बाइट्स (उनमें रिक्त स्थान वाले स्पष्ट) सुरक्षित कर सकते हैं।

यदि हमें इनपुट पार्स करने की आवश्यकता नहीं है, लेकिन इनपुट के रूप में केवल एक अनुक्रम मिल सकता है, तो यह बहुत कम हो जाता है (69 बाइट्स)।

String p(Object[]s)=>s.reversed.fold("[]")((t,h)=>"[``h`` | ``t``]");

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

— पाओलो एबरमन
स्रोत
2

SNOBOL4 (CSNOBOL4) , 114 बाइट्स

	I =INPUT
S	N =N + 1	
	I SPAN(1234567890) . L REM . I	:F(O)
	O =O '[' L ' | '	:(S)
O	OUTPUT =O '[' DUPL(']',N)
END

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

	I =INPUT				;* read input
S	N =N + 1				;* counter for number of elements (including empty list)
	I SPAN(1234567890) . L REM . I	:F(O)	;* get value matching \d until none left
	O =O '[' L ' | '	:(S)		;* build output string
O	OUTPUT =O '[' DUPL(']',N)		;* print O concatenated with a '[' and N copies of ']'
END
— ग्यूसेप
स्रोत
2

स्टैक्स , 19 बाइट्स

É▲²:WlÖ└%ï╪☺╒▓"We↨Φ

इसे चलाएं और डीबग करें

मेरा पहला स्टैक्स पोस्ट, इसलिए शायद इष्टतम नहीं है।

अनपैक्ड और टिप्पणी:

U,                      Put -1 under input
  {                     Block
   i                      Push loop index, needed later
    '[a$'|++              Wrap the element in "[...|"
            m           Map
             '[+        Add another "["
                s2+     Get the latest loop index + 2
                   ']*+ Add that many "]"

इसे चलाएं और डीबग करें

— wastl
स्रोत
2

बेफ़ुंज -98 (PyFunge) , 22 21 बाइट्स

'[,1;@j,]';#$&." |",,

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

यदि आउटपुट पर अजीब प्रतिबंध नहीं थे, तो हम 18 में ऐसा कर सकते थे:

'[,1;@j,]';#$&.'|,

मजेदार तथ्य, यह तकनीकी रूप से एक ऐसा कार्यक्रम है जो पायथन में कुछ भी नहीं करता है।

— मजाक कर रहा है
स्रोत
2

आर , 84 71 69 बाइट्स

function(x){while(x<(x=sub('(,|\\d\\K(?=]))(.+)','|[\\2]',x,,T)))1;x}

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

  • -15 बाइट्स @KirillL को धन्यवाद।
— digEmAll
स्रोत
1
मेरे रूबी जवाब के आधार पर एकल प्रतिस्थापन के साथ 71 बाइट्स ।
— किरिल एल।
@KirillL। : धन्यवाद, मुझे यकीन था कि ऐसा करने के लिए एक छोटा रेगेक्स था, लेकिन मैं हमेशा
— लुकअप के
-2 और , मैं पूरी तरह से एक छोटे से \Kतलाश के बारे में भूल गया
— किरिल एल।
1

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

ŒVµ⁾[]jj⁾|[ṫ3;”]ṁ$

परिणाम को मुद्रित करने वाला एक पूरा कार्यक्रम (एक विवादास्पद लिंक के रूप में यह पात्रों की सूची को स्वीकार करता है लेकिन पात्रों और पूर्णांक की एक सूची देता है)।

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

कैसे?

ŒVµ⁾[]jj⁾|[ṫ3;”]ṁ$ - Main link: list of characters  e.g. "[10,333]"
ŒV                 - evaluate as Python code              [10,333]
  µ                - start a new monadic chain, call that X
   ⁾[]             - list of characters                   ['[',']']
      j            - join with X                          ['[',10,333,']']
        ⁾|[        - list of characters                   ['|','[']
       j           - join                                 ['[','|','[',10,'|','[',333,'|','[',']']
           ṫ3      - tail from index three                ['[',10,'|','[',333,'|','[',']']
                 $ - last two links as a monad (f(X)):
              ”]   -   character                          ']'
                ṁ  -   mould like X                       [']',']'] (here 2 because X is 2 long)
             ;     - concatenate                          ['[',10,'|','[',333,'|','[',']',']',']']
                   - implicit (and smashing) print        [10|[333|[]]]
— जोनाथन एलन
स्रोत
1

जावा 10, 107 बाइट्स

s->{var r="[]";for(var i:s.replaceAll("[\\[\\]]","").split(","))r="["+i+"|"+r+"]";return s.length()<3?s:r;}

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

स्पष्टीकरण:

s->{                       // Method with String as both parameter and return-type
  var r="[]";              //  Result-String, starting at "[]"
  for(var i:s.replaceAll("[\\[\\]]","") 
                           //  Removing trailing "[" and leading "]"
             .split(","))  //  Loop over the items
    r="["+i+"|"+r+"]";     //   Create the result-String `r`
  return s.length()<3?     //  If the input was "[]"
          s                //   Return the input as result
         :                 //  Else:
          r;}              //   Return `r` as result
— केविन क्रूज़सेन
स्रोत
1

मानक एमएल , 71 बाइट्स

fun p[_]="]|[]]"|p(#","::r)="|["^p r^"]"|p(d::r)=str d^p r;p o explode;

इसे ऑनलाइन आज़माएं! रिक्त स्थान के बिना प्रारूप का उपयोग करता है। जैसे it "[10,333,4]"पैदावार "[10|[333|[4]|[]]]]"।

ungolfed

fun p [_]       = "]|[]]"          (* if there is only one char left we are at the end *)
  | p (#","::r) = "|[" ^ p r ^ "]" (* a ',' in the input is replaced by "|[" and an closing "]" is added to the end *)
  | p (d::r)    = str d ^ p r      (* all other chars (the digits and the initial '[') are converted to a string and concatenated to recursive result *)

val f = p o explode  (* convert string into list of chars and apply function p *)

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

— Laikoni
स्रोत
1

आर , १४० 136 बाइट्स

Giuseppe की ध्वनि सलाह के अनुसार नीचे 4 बाइट्स। 

function(l,x=unlist(strsplit(substr(l,2,nchar(l)-1),", ")))paste(c("[",paste0(c(x,"]"),collapse=" | ["),rep("]",length(x))),collapse="")

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

— Jayce
स्रोत
substrकम है और पहली बार यह 136 बाइट्स के लिए हो paste0सकता pasteहै।
— ग्यूसेप
1
का उपयोग कर eval, parseऔर के subबजाय unlist, strsplitऔर substrमैं भी केवल 136 बाइट्स प्रबंधित (मुझे लगा कि यह कम हो सकता है, लेकिन यह नहीं था)
— Giuseppe
@Giuseppe -4 बाइट्स के लिए धन्यवाद! काश हमारे पास कुछ कम होता। पुनरावर्ती समाधान शायद?
— JayCe
1

आर , 108 बाइट्स

function(l)Reduce(function(x,y)paste0("[",x,"|",y,"]"),eval(parse(t=sub("]",")",sub("\\[","c(",l)))),"[]",T)

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

पहले की तुलना में बेहतर R समाधान खोजने में लगभग एक साल लग गया ... पता होना Reduceचाहिए था उत्तर! रिक्त स्थान के बिना आउटपुट, इनपुट अंतरिक्ष के साथ या बिना हो सकते हैं।

— ग्यूसेप
स्रोत
— digEmAll
0

सीड + -E, 46 बाइट्स

:
s/\[([0-9]+)(, ?([^]]*)|())\]/[\1 | [\3]]/
t

काफी सीधा दृष्टिकोण। दूसरी पंक्ति [\d+, ...]इसे ले जाती है और इसे बदल देती है[\d | [...]] । तीसरी पंक्ति पहली पंक्ति में वापस आती है, यदि प्रतिस्थापन सफल था। प्रतिस्थापन तब तक दोहराता है जब तक कि वह विफल न हो जाए और फिर कार्यक्रम समाप्त हो जाए। sed -E -f filename.sedस्टड के माध्यम से इनपुट के साथ , भागो ।

— सिल्वियो मायोलो
स्रोत
0

लाल , 110 बाइट्स

func[s][if s ="[]"[return s]replace append/dup replace/all b: copy s",""|[""]"(length? b)- length? s"]""|[]]"]

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

असंगठित संस्करण की व्याख्या:

f: func[s][                      
    if s = "[]" [return s]                    ; if the list is empty, return it    
    b: copy s                                 ; save a copy of the input in b 
    replace/all b "," "|["                    ; replace every "," with "|["  
    append/dup b "]" (length? b) - length? s  ; append as many "]" as there were ","
    replace b "]" "|[]]"                      ; replace the first "]" with "|[]]"     
]                                             ; the last value is returned implicitly

रेड इतनी आसानी से पठनीय है, कि मुझे संदेह है कि मुझे उपरोक्त टिप्पणियों को जोड़ने की आवश्यकता है :)

— गैलेन इवानोव
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.