Im Gegensatz zu den meisten Sprachen wertet Python a<b<cwie in der Mathematik aus und vergleicht die drei Zahlen im Gegensatz zum Vergleich des Booleschen a<bmit c. Der richtige Weg, dies in C (und vielen anderen) zu schreiben, wäre a<b && b<c.

Bei dieser Herausforderung besteht Ihre Aufgabe darin, solche Vergleichsketten beliebiger Länge von der Python / intuitiven Darstellung auf die Art und Weise zu erweitern, wie sie in anderen Sprachen geschrieben werden.

Spezifikationen

• Ihr Programm muss die Operatoren behandeln : ==, !=, <, >, <=, >=.
• Die Eingabe enthält Vergleichsketten, die nur Ganzzahlen verwenden.
• Machen Sie sich keine Sorgen über die Richtigkeit der Vergleiche auf dem Weg, dies ist eine rein parsende / syntaktische Herausforderung.
• Die Eingabe enthält kein Leerzeichen, um Antworten zu verhindern, die das Parsen durch Aufteilen auf Leerzeichen trivialisieren.
• Ihre Ausgabe kann jedoch einen einzelnen Raum haben, der entweder nur die &&'s oder sowohl die Vergleichsoperatoren als auch die &&' s oder keine umgibt , aber konsistent ist.

Testfälle

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

Dies ist Code-Golf , also gewinnt der kürzeste Code in Bytes !

Netzhaut , 33 22 17 Bytes

-5 Bytes dank @MartinEnder

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

Probieren Sie es online aus!

Schale , 16 14 Bytes

Druckt ein Leerzeichen um jeden Operator.

wJ"&&"m←C2X3ġ±

Probieren Sie es online aus!

Erläuterung:

                  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 Bytes

Dank Kevin Cruijssen massiv Golf gespielt

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

Probieren Sie es online aus!

V , 37 Bytes

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

Probieren Sie es online aus!

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 Bytes

Update: subsstatt clojure.string/join.

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

J , 59 46 Bytes

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

Probieren Sie es online aus!

Wie es früher funktioniert hat

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

Wir suchen nach Operatorgrenzen. "Enthauptete" und "verkürzte" Zeichenfolgen werden in Nullen und Einsen umgewandelt, wobei Nullen Ziffern sind, und dann zusammen xored. Stellen Sie Null entsprechend der Länge voran.

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

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

Probieren Sie es online aus!

Holzkohle, 29 Bytes

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

Zwei leicht unterschiedliche Formulierungen desselben Basisalgorithmus. Die Eingabezeichenfolge wird durch Zeichen iteriert. Wenn Ziffern gefunden werden, werden sie in einer Variablen gesammelt. Wenn eine Grenze zwischen einer Zahl und einem Operator gefunden wird, wird ein zusätzliches "&&" plus der Variablen gedruckt und die Variable gelöscht. Die Variable wird anfänglich mit einem Leerzeichen initialisiert, damit die erste Grenze nicht das zusätzliche "&&" auslöst.

Gelee , 16 Bytes

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

Probieren Sie es online aus!

Erläuterung:

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 Bytes

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

Erläuterung:

Probieren Sie es hier aus.

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)

Regex Erklärung:

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

Schritt für Schritt Beispiel für den Austausch:

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 Bytes

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

Probieren Sie es online aus!

Ruby , 37 Bytes

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

Probieren Sie es online aus!

JavaScript (SpiderMonkey) , 43 Byte

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

Probieren Sie es online aus!