Erweitern Sie die Vergleichsketten

9

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 , also gewinnt der kürzeste Code in Bytes !

Maltysen
quelle
verwandt
Maltysen
Kann ich zwei Leerzeichen auf beiden Seiten des haben &&?
H.PWiz
@ H.PWiz nein, srry.
Maltysen

Antworten:

6

Netzhaut , 33 22 17 Bytes

-5 Bytes dank @MartinEnder

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

Probieren Sie es online aus!

ovs
quelle
@ MartinEnder Schade, dass 1>-2es nicht funktioniert, von beiden Seiten gleichzeitig zu begrenzen ...
Neil
@Neil ja, Retina 1.0 erhält eine neue Limit-Syntax, wo dies möglich ist.
Martin Ender
Könnten Sie eine Erklärung posten?
James
5

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
H.PWiz
quelle
Schön. Sie könnten wstatt ;für einen direkteren Ansatz zum Verbinden von Strings mit Leerzeichen verwenden
Leo
Oh ja, wie habe ich das nicht gedacht?
H.PWiz
3

Retina , 42 47 22 Bytes

Dank Kevin Cruijssen massiv Golf gespielt

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

Probieren Sie es online aus!

Ein Taco
quelle
(==|!=|<=?|>=?)kann sein \D+
ovs
Ähnlich (?<!^|\d)kann sein (?<=\D). Auch das (?=\d+)ist unnötig, dem Operator folgt immer ein Operand, an welchem ​​Punkt Sie den +nach dem ablegen können \D. Es gibt auch $&statt $1$2, und dann kann ein weiteres Byte gespeichert werden, indem Sie nach hinten erfassen und nach vorne schauen, anstatt nach vorne zu erfassen und nach hinten zu schauen.
Neil
(\D(\d+))(?=\D)in Zeile 1 und $1&&$2in Zeile zwei ist ausreichend ( 22 Bytes ). Probieren Sie es hier aus.
Kevin Cruijssen
2

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                             .. ..
James
quelle
2

Clojure, 88 Bytes

Update: subsstatt clojure.string/join.

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

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.
FrownyFrog
quelle
1

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!

TFeld
quelle
re.sub(r'\D(\d+)(?=\D)',r'\g<0>&&\1',s)spart 1 Byte.
Neil
@ Neil Danke :)
TFeld
1

Holzkohle, 29 Bytes

≔ ηFθ«¿›ι9«F›η!⁺&&η≔ωη»≔⁺ηιηι
≔ ηFθ«F∧›ι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.

Neil
quelle
1

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 '&&'
Erik der Outgolfer
quelle
1

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
Kevin Cruijssen
quelle