Contrairement à la plupart des langages, Python évalue a<b<ccomme il le ferait en mathématiques, comparant en fait les trois nombres, au lieu de comparer le booléen a<bà c. La bonne façon d'écrire cela en C (et bien d'autres) serait a<b && b<c.

Dans ce défi, votre tâche consiste à étendre ces chaînes de comparaison de longueurs arbitraires de la représentation Python / intuitive, à la façon dont elle serait écrite dans d'autres langues.

Caractéristiques

• Votre programme devra gérer les opérateurs: ==, !=, <, >, <=, >=.
• L'entrée aura des chaînes de comparaison utilisant uniquement des entiers.
• Ne vous inquiétez pas de la justesse des comparaisons en cours de route, il s'agit uniquement d'un défi d'analyse syntaxique.
• L'entrée n'aura aucun espace pour empêcher les réponses qui banalisent l'analyse en se divisant en espaces.
• Cependant, votre sortie peut avoir un seul espace entourant uniquement le &&s, ou les deux opérateurs de comparaison et les &&s, ou aucun, mais être cohérent.

Cas de test

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

C'est le code-golf , donc le code le plus court en octets gagne!

Rétine , 33 22 17 octets

-5 octets grâce à @MartinEnder

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

Essayez-le en ligne!

Husk , 16 14 octets

Imprime un espace autour de chaque opérateur.

wJ"&&"m←C2X3ġ±

Essayez-le en ligne!

Explication:

                  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

Rétine , 42 47 22 octets

Golf massif grâce à Kevin Cruijssen

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

Essayez-le en ligne!

V , 37 octets

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

Essayez-le en ligne!

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 octets

Mise à jour: subsau lieu de clojure.string/join.

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

J , 59 46 octets

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

Essayez-le en ligne!

Comment cela fonctionnait

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

Nous recherchons des limites d'opérateur. Les chaînes «décapitées» et «raccourcies» sont transformées en zéros et en uns où les 0 sont des chiffres, puis sont xorés ensemble. Ajoutez le zéro à la longueur.

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

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

Essayez-le en ligne!

Fusain, 29 octets

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

Deux formulations légèrement différentes du même algorithme de base. La chaîne d'entrée est itérée par caractère. Lorsque les chiffres sont trouvés, ils sont collectés dans une variable. Lorsqu'une frontière entre un nombre et un opérateur est trouvée, un "&&" supplémentaire plus la variable est imprimé et la variable est effacée. La variable est initialement initialisée à un espace afin que la première frontière ne déclenche pas le "&&" supplémentaire.

Gelée , 16 octets

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

Essayez-le en ligne!

Explication:

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 octets

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

Explication:

Essayez-le ici.

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)

Explication de l'expression régulière:

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

Exemple étape par étape des remplacements:

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 octets

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

Essayez-le en ligne!

Rubis , 37 octets

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

Essayez-le en ligne!

JavaScript (SpiderMonkey) , 43 octets

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

Essayez-le en ligne!