Tidak seperti kebanyakan bahasa, Python mengevaluasi a<b<ckarena akan dilakukan dalam matematika, sebenarnya membandingkan tiga angka, yang bertentangan dengan membandingkan boolean a<buntuk c. Cara yang benar untuk menulis ini dalam C (dan banyak lainnya) adalah a<b && b<c.

Dalam tantangan ini, tugas Anda adalah untuk memperluas rantai perbandingan dengan panjang sewenang-wenang dari Python / representasi intuitif, hingga bagaimana itu akan ditulis dalam bahasa lain.

Spesifikasi

• Program Anda harus menangani operator: ==, !=, <, >, <=, >=.
• Input akan memiliki rantai perbandingan menggunakan hanya bilangan bulat.
• Jangan khawatir tentang kebenaran dari perbandingan mana pun di sepanjang jalan, ini murni tantangan parsing / sintaksis.
• Masukan tidak akan memiliki spasi putih untuk mencegah jawaban yang meremehkan penguraian dengan membagi pada spasi.
• Namun, output Anda mungkin memiliki ruang tunggal yang mengelilingi baik saja &&, atau kedua operator perbandingan dan &&, atau tidak, tetapi konsisten.

Uji Kasus

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

Ini adalah kode-golf , jadi kode terpendek dalam byte menang!

Retina , 33 22 17 byte

-5 byte terima kasih kepada @MartinEnder

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

Cobalah online!

Sekam , 16 14 byte

Mencetak ruang di sekitar masing-masing operator.

wJ"&&"m←C2X3ġ±

Cobalah online!

Penjelasan:

                  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

Retina , 42 47 22 byte

Bermain golf secara besar- besaran berkat Kevin Cruijssen

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

Cobalah online!

V , 37 byte

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

Cobalah online!

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                             .. ..

Clojure, 88 byte

Perbarui: subsalih-alih clojure.string/join.

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

J , 59 46 byte

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

Cobalah online!

Cara kerjanya dulu

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

Kami sedang mencari batasan operator. String "Dipenggal" dan "dibatasi" diubah menjadi nol dan yang 0 adalah digit, kemudian digabungkan bersama. Prepend nol untuk mencocokkan panjang.

                   +/\                      </. ]     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.

Python 2 , 60 59 58 57 byte

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

Cobalah online!

Arang, 29 byte

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

Dua formulasi yang sedikit berbeda dari algoritma dasar yang sama. String input diulangi oleh karakter. Ketika digit ditemukan mereka dikumpulkan dalam suatu variabel. Ketika batas antara angka dan operator ditemukan, "&&" tambahan ditambah variabel dicetak dan variabel dihapus. Variabel awalnya diinisialisasi ke spasi sehingga batas pertama tidak memicu ekstra "&&".

Jelly , 16 byte

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

Cobalah online!

Penjelasan:

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 '&&'

Java 8, 46 byte

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

Penjelasan:

Coba di sini.

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)

Penjelasan regex:

(\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)

Langkah demi langkah contoh penggantian:

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

Perl 5 , 47 + 1 (-p) = 48 byte

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

Cobalah online!

Ruby , 37 byte

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

Cobalah online!

JavaScript (SpiderMonkey) , 43 byte

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

Cobalah online!