तुलना जंजीरों का विस्तार करें

Question

अधिकांश भाषाओं के विपरीत, पायथन मूल्यांकन करता है a<b<cक्योंकि यह गणित में किया जाएगा, वास्तव में तीन नंबरों की तुलना में, बूलियन की तुलना करने के a<bलिए c। सी (और कई अन्य) में इसे लिखने का सही तरीका होगा a<b && b<c।

इस चुनौती में, आपका कार्य पायथन / सहज प्रतिनिधित्व से मनमानी लंबाई की ऐसी तुलना श्रृंखलाओं का विस्तार करना है, जो अन्य भाषाओं में लिखी जाएंगी।

विशेष विवरण

• आपके कार्यक्रम को ऑपरेटरों को संभालना होगा ==, !=, <, >, <=, >=:।
• इनपुट में केवल पूर्णांक का उपयोग करते हुए तुलना श्रृंखला होगी।
• रास्ते में किसी भी तुलना की गंभीरता के बारे में चिंता न करें, यह विशुद्ध रूप से एक पार्सिंग / वाक्यविन्यास चुनौती है।
• रिक्त स्थान पर विभाजित करके पार्सिंग को निजीकृत करने वाले उत्तरों को रोकने के लिए इनपुट में कोई व्हाट्सएप नहीं होगा।
• हालाँकि, आपके आउटपुट में एक ही स्थान हो सकता है &&, या तो तुलनात्मक संचालक और दोनों तुलनात्मक रूप से &&या न ही हों, लेकिन निरंतर रहें।

परीक्षण के मामलों

Input                  Output
---------------------------------------------------------------

3<4<5                  3<4 && 4<5
3<4<5<6<7<8<9          3<4 && 4<5 && 5<6 && 6<7 && 7<8 && 8<9
3<5==6<19              3<5 && 5==6 && 6<19
10>=5<7!=20            10>=5 && 5<7 && 7!=20
15==15==15==15==15     15==15 && 15==15 && 15==15 && 15==15

ये है कोड गोल्फ, तो बाइट्स जीत में सबसे छोटा कोड !

Comments

संबंधित

— माल्टीसेन

क्या मेरे पास दो स्थान हो सकते हैं &&?

— H.PWiz

@ H.PWiz नप, श्रीरी।

— माल्टीसेन

Answer 1

रेटिना , 33 22 17 बाइट्स

-5 बाइट्स @MartinEnder को धन्यवाद

-2`\D(\d+)
$&&&$1

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

Comments

@MartinEnder एक दया एक 1>-2ही बार में दोनों सिरों को सीमित करने का काम नहीं करती ...

— नील

@ नील हां, रेटिना 1.0 को एक नई सीमा सिंटैक्स मिलेगा जहां यह संभव है।

— मार्टिन एंडर

क्या आप एक स्पष्टीकरण पोस्ट कर सकते हैं?

— जेम्स

Answer 2

भूसी , 16 14 बाइट्स

प्रत्येक ऑपरेटर के चारों ओर एक स्थान प्रिंट करता है।

wJ"&&"m←C2X3ġ±

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

स्पष्टीकरण:

                  Implicit input, e.g            "3<4<5<6"
            ġ±    Group digits                   ["3","<","4","<","5","<","6"]
          X3      Sublists of length 3           [["3","<","4"],["<","4","<"],["4","<","5"],["<","5","<"],["5","<","6"]]
        C2        Cut into lists of length 2     [[["3","<","4"],["<","4","<"]],[["4","<","5"],["<","5","<"]],[["5","<","6"]]]
      m←          Take the first element of each [["3","<","4"],["4","<","5"],["5","<","6"]]
 J"&&"            Join with "&&"                 ["3","<","4","&&","4","<","5","&&","5","<","6"]
w                 Print, separates by spaces

Comments

अच्छा है। रिक्त स्थान के साथ तार जुड़ने wके ;लिए अधिक प्रत्यक्ष दृष्टिकोण के बजाय आप उपयोग कर सकते हैं

— लियो

अरे हाँ, मैंने ऐसा कैसे नहीं सोचा?

— H.PWiz

Answer 3

रेटिना , 42 47 22 बाइट्स

केविन क्रूज़सेन के लिए बड़े पैमाने पर धन्यवाद

(\D(\d+))(?=\D)
$1&&$2

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

Comments

(==|!=|<=?|>=?)हो सकता है \D+

— ओक्ट्स

इसी तरह (?<!^|\d)हो सकता है (?<=\D)। इसके अलावा, (?=\d+)अनावश्यक है, ऑपरेटर हमेशा एक ऑपरेटर द्वारा पीछा किया जाएगा, जिस बिंदु पर आप के +बाद छोड़ सकते हैं \D। $&इसके बजाय भी है $1$2, और फिर एक और बाइट को पीछे कैप्चर करके और आगे देखने के बजाय आगे देख कर बचाया जा सकता है।

— नील

(\D(\d+))(?=\D)लाइन 1 पर, और $1&&$2लाइन दो पर पर्याप्त ( 22 बाइट्स ) है। इसे यहाँ आज़माएँ।

— केविन क्रूज़सेन

Answer 4

वी , 37 बाइट्स

òͨ䫄0-9& ]«©¨ä«©¨„0-9& ]«©/±² ¦¦ ²³

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

Hexdump:

00000000: f2cd a8e4 ab84 302d 3926 205d aba9 a8e4  ......0-9& ]....
00000010: aba9 a884 302d 3926 205d aba9 2fb1 b220  ....0-9& ]../.. 
00000020: a6a6 20b2 b3                             .. ..

Answer 5

क्लोजर, 88 बाइट्स

अद्यतन: के subsबजाय clojure.string/join।

#(subs(apply str(for[p(partition 3 2(re-seq #"(?:\d+|[^\d]+)" %))](apply str" && "p)))4)

Answer 6

जे , 59 46 बाइट्स

4(}.;)_2{.\3' && '&;\]</.~0+/\@,2~:/\e.&'!<=>'

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

यह कैसे काम करता था

                        (0 , }. ~:&(e.&'!<=>') }:)

हम ऑपरेटर सीमाओं की तलाश कर रहे हैं। "बेजेड" और "कर्ल किए गए" तार को शून्य और उन लोगों में बदल दिया जाता है जहां 0 अंक अंक होते हैं, फिर एक साथ xored। लंबाई से मिलान करने के लिए शून्य को प्रीपेंड करें।

                   +/\                      </. ]     Split on boundaries. 
              ┌──┬──┬─┬─┬─┬──┬──┐
              │10│>=│5│<│7│!=│20│
              └──┴──┴─┴─┴─┴──┴──┘
         3' && '&;\          Add && to infixes of 3.
              ┌────┬──┬──┬──┐
              │ && │10│>=│5 │
              ├────┼──┼──┼──┤
              │ && │>=│5 │< │
              ├────┼──┼──┼──┤
              │ && │5 │< │7 │
              ├────┼──┼──┼──┤
              │ && │< │7 │!=│
              ├────┼──┼──┼──┤
              │ && │7 │!=│20│
              └────┴──┴──┴──┘
    _2{.\                    Take even numbered rows.
;}.,                         Concatenate after dropping the first box.

Answer 7

पायथन 2 , 60 59 58 57 बाइट्स

lambda s:re.sub(r'(\D(\d+))(?=\D)',r'\1&&\2',s)
import re

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

Comments

re.sub(r'\D(\d+)(?=\D)',r'\g<0>&&\1',s)1 बाइट बचाता है।

— नील

@ नील धन्यवाद :)

— 8

Answer 8

चारकोल, 29 बाइट्स

≔ ηＦθ«¿›ι9«Ｆ›η!⁺&&η≔ωη»≔⁺ηιηι
≔ ηＦθ«Ｆ∧›ι9›η!⁺&&η≔⎇›ι9ω⁺ηιηι

एक ही मूल एल्गोरिथ्म के दो अलग-अलग रूप। इनपुट स्ट्रिंग चरित्र द्वारा पुनरावृत्त है। जैसे ही अंक मिलते हैं उन्हें एक चर में एकत्र किया जाता है। जब एक संख्या और ऑपरेटर के बीच एक सीमा पाई जाती है, तो एक अतिरिक्त "&&" प्लस चर मुद्रित होता है और चर साफ हो जाता है। चर को शुरू में एक स्थान पर शुरू किया जाता है ताकि पहली सीमा अतिरिक्त "&&" को ट्रिगर न करे।

Answer 9

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

e€ØDŒg⁸ṁṡ3m2j⁾&&

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

स्पष्टीकरण:

e€ØDŒg⁸ṁṡ3m2j⁾&& Uses Jelly stringification, thus full program only
eۯD             For each each char, 1 if it's in '0123456789', otherwise 0
    Œg           Split into longest runs of equal elements
      ⁸ṁ         Reshape original input like the list we just made
                 Reshaping will separate numbers from operators
        ṡ3       Get contiguous sublists of length 3
          m2     Keep every second item, starting from the first
                 This will keep every (number operator number) and
                 remove every (operator number operator) substring
            j⁾&& Join with '&&'

Answer 10

जावा 8, 46 बाइट्स

s->s.replaceAll("(\\D(\\d+))(?=\\D)","$1&&$2")

स्पष्टीकरण:

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

s->                       // Method with String as both parameter and return-type
   s.replaceAll("(\\D(\\d+))(?=\\D)",
                "$1&&$2") //  Replace the match of the regex
                          //  with the second String
                          // End of method (implicit / single-line return-statement)

रेगेक्स स्पष्टीकरण:

(\D(\d+))(?=\D)   # 1) For all matches of this regex
   (\d+)          #  Capture group 2: a number (one or more digits)
(\D \d+ )         #  Capture group 1: anything but a number + the number
                  #   (`\D` will match the `=`, `!`, `<`, or `>`)
         (?=\D)   #  Look-ahead so everything after the match remains as is

 $1&&$2           # 2) Replace it with
 $1               #  Result of capture group 1 (trailing part of the equation + the number)
   &&             #  Literal "&&"
     $2           #  Result of capture group 2 (the number)

प्रतिस्थापन के कदम से कदम उदाहरण:

Initial:                             10>=5<7!=20
 Match of first replacement:            =5
 Replace with:                          =5&&5
After first replacement:             10>=5&&5<7!=20
 Match of second replacement:                <7
 Replace with:                               <7&&7
After second replacement (result):   10>=5&&5<7&&7!=20

Answer 11

पर्ल 5 , 47 + 1 (-पी) = 48 बाइट्स

$\.=$1." && "x(!!$')while s/(\d+\D+(\d+))/$2/}{

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

Answer 12

रूबी , 37 बाइट्स

->s{s.gsub(/\D(\d+)(?=\D)/,'\&&&\1')}

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

Answer 13

जावास्क्रिप्ट (स्पाइडरमैन) , 43 बाइट्स

f=s=>s.replace(/(\W+(\d+))(?!$)/g,"$1&&$2")

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