Avalie uma expressão de menos e de til

16

Dada uma expressão que corresponde ao regex /^[-~]*x$/, avalie-o em termos de xe produza uma string correspondente ao regex /^-?x[+-]\d+$/.

Por exemplo, a sequência é -~xavaliada como x+1, enquanto a sequência é -~-xavaliada como -x+1e a sequência é -~-~--xavaliada como x+2.

Começamos xe avaliamos a string da direita para a esquerda. -nega o termo, enquanto ~converte ypara -y-1.

Casos de teste:

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

Isso é código-golfe . A resposta mais curta em bytes vence.

O formato de entrada / saída é rigoroso. O "x"é obrigatório.

code-golf string Freira Furada
fonte
Podemos produzir em x+010vez de x+10para -~-~-~-~-~-~-~-~-~-~x? Corresponde ao segundo regex.
Você pode, embora eu não veja nenhuma razão para isso.
gotejante Nun
3
O til tem um significado diferente em diferentes idiomas. Provavelmente, você deve esclarecer que pretende o significado do Python
18136 Luis Mendo
3
@LuisMendo ler a última frase do meu terceiro parágrafo
Leaky Nun
1
@LeakyNun Ah, desculpe, eu não vi isso. Enfim, acho que deveria aparecer mais cedo. Os dois primeiros parágrafos e parte do terceiro falam sobre ~enquanto ele não foi definido.
Luis Mendo

Respostas:

7

Retina , 47 44 bytes

+`--|~~

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

Experimente online! Editar: salvou 3 bytes graças a @MartinEnder. Expansão:

+`--|~~

Exclua pares de duplicatas adjacentes.

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

Conte o número de ~s que nos dá a magnitude do termo.

T`+`-`^~.*

Se o primeiro caractere for a ~, o termo deverá ser negativo.

~
-
--

Se o número de se ~es -for ímpar, então xdeve ser negativo.

Neil
fonte
6

JavaScript, 59 bytes

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

Experimente online!


fonte
2
Bata-me por 16 segundos e 38 bytes. Bem feito.
Luke
Falha nos casos de teste que contêm vários -em uma linha. (ie --~-~x)
Lucas
@Lucas. Não tenho certeza do que você quer dizer. Meu script também funciona para esses casos de teste.
Isto sobrevive ao meu novo caso de teste: D
Leaky Nun 15/17
@ThePirateBay: oops, nvm então ...
Lucas
1

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

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

Experimente online!

Xcali
fonte
1

C (gcc) , 69 bytes

a;s;f(char*p){for(a=s=0;*p;a-=*p++%5*~-s)s^=2;printf("-x%+d"+!!s,a);}

Experimente online!

-1 byte graças a @ThePirateBay

Nwellnhof
fonte
0

Java 8, 186 bytes

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("--","");}

Definitivamente espaço para melhorias ..

Explicação:

Experimente aqui.

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
fonte