Évaluer une expression de moins et de tilde

16

Étant donné une expression correspondant à l'expression régulière /^[-~]*x$/, évaluez-la en termes de xet sortie une chaîne correspondant à l'expression régulière /^-?x[+-]\d+$/.

Par exemple, la chaîne est -~xévaluée à x+1, tandis que la chaîne est -~-xévaluée à -x+1et la chaîne est -~-~--xévaluée à x+2.

Nous partons de xet évaluons la chaîne de droite à gauche. -annule le terme, tandis qu'il se ~convertit yen -y-1.

Testcases:

    x  x+0
   ~x -x-1
  -~x  x+1
 ~-~x -x-2
-~-~x  x+2
--~~x  x+0
  ~-x  x-1
 -~-x -x+1

C'est du code-golf . La réponse la plus courte en octets l'emporte.

Le format d'entrée / sortie est strict. Le "x"est obligatoire.

code-golf string Leaky Nun
la source
Pouvons-nous produire x+010au lieu de x+10pour -~-~-~-~-~-~-~-~-~-~x? Il correspond à la deuxième expression régulière.
Vous pouvez, mais je ne vois aucune raison.
Leaky Nun
3
Le tilde a une signification différente dans différentes langues. Vous devriez probablement préciser que vous entendez le sens Python
Luis Mendo
3
@LuisMendo a lu la dernière phrase de mon troisième paragraphe
Leaky Nun
1
@LeakyNun Ah, désolé, je n'ai pas vu ça. Quoi qu'il en soit, je pense que cela devrait apparaître plus tôt. Les deux premiers paragraphes et une partie du troisième parlent ~alors qu'il n'a pas été défini
Luis Mendo

Réponses:

7

Rétine , 47 44 octets

+`--|~~

((~)|-)*x
$&+$#2
T`+`-`^~.*
~
-
--

Essayez-le en ligne! Edit: sauvé 3 octets grâce à @MartinEnder. Expansion:

+`--|~~

Supprimez des paires de doublons adjacents.

((~)|-)*x
$&+$#2

Comptez le nombre de ~s qui nous donne l'ampleur du terme.

T`+`-`^~.*

Si le premier caractère est un, ~le terme doit être négatif.

~
-
--

Si le nombre de ~s et de -s est impair, le xdoit être négatif.

Neil
la source
6

JavaScript, 59 octets

x=>['-'[x.length&1]]+'x'+['+'[(x=eval(x.join` `))<0^0]]+~~x

Essayez-le en ligne!


la source
2
Battez-moi de 16 secondes et 38 octets. Bien joué.
Luke
Échoue pour les cas de test contenant plusieurs éléments -consécutifs. (c.-à-d. --~-~x)
Luke
@Luke. Je ne sais pas ce que tu veux dire. Mon script fonctionne également pour ces cas de test.
Cela survit à mon nouveau test: D
Leaky Nun
@ThePirateBay: oups, nvm alors ...
Luke
1

Perl 5 , 75 + 1 (-n) = 76 octets

map{$y=-$y;$y--if/~/}reverse/-|~/g;printf"%sx%+d",((-1)**y/-~//)=~s/1//r,$y

Essayez-le en ligne!

Xcali
la source
0

Java 8, 186 octets

s->{s=s.replaceAll("--|~~","");int l,i=(s.length()-(l=(s=s.replaceAll("-~","")).length()))/2,j=l-(s=s.replaceAll("~","")).length();return(j>0?"-"+s+"-"+-~i:s+"+"+i).replaceAll("--","");}

Certainement place pour des améliorations ..

Explication:

Essayez-le ici.

s->{                              // Method with String as both parameter and return-type
  s=s.replaceAll("--|~~","");     //  Remove all "--" and "~~"
  int l,                          //  Temp integer to reduce bytes
      i=(s.length()-(l=(s=s.replaceAll("-~","")).length()))/2,
                                 //  Remove all "-~" and save count in `i`
      j=l-(s=s.replaceAll("~","")).length();
                                 //  Remove all remaining "~" and save count in `j`
   return(j>0?                   //  If `j` is larger than 0:
           "-"                   //   Start with a minus sign
           +s                    //   followed by the remaining `s`
           +"-"                  //   followed by another minus sign
           +-~i                  //   followed by `i+1`
          :                      //  Else:
           s                     //   Start with the remaining `s`
           +"+"                  //   followed by a plus sign
           +i                    //   followed by `i`
         ).replaceAll("--","");  //  And then remove all "--"
}                                // End of method
Kevin Cruijssen
la source