regex c # corresponde a qualquer coisa entre parênteses
<p>quero corresponder qualquer coisa entre parênteses, mas o resultado também deve excluir os parênteses.</p><p><strong>exemplos:</strong><br> inicializar (p90w)<br> freio (45x)</p><p><strong>resultado:</strong><br> 990w<br> 45x</p><p>observe os resultados sem os parênteses.</p><p>eu tenho tentado fazer isso funcionar, mas sem sucesso tentei algumas variações, mas sei que é uma coisa simples que estou perdendo e não quero usar o replace para alcançá-lo.</p><pre><code>var item = "brake(45x)" regex searchterm = new regex(@"\((.*)\)"); var value = (searchterm.match(item).groups.count &gt; 0) ? searchterm.match(item).groups[0].value : string.empty; </code></pre>
<p>algumas pessoas me acusam de usar afirmações de largura zero o tempo todo:</p><pre><code>resultstring = regex.match(subjectstring, @"(?&lt;=\().+?(?=\))").value; </code></pre><p>mas eles fazem exatamente o que você deseja. não capture o que não deseja capturar.</p>
você pode concatenar os parênteses e o valor com o retorno da função, p.ex,
 


  
 

dim valor as double
 
valor = 1000000
 
msgbox "(" & valor & " - " & extenso\_valor(valor) & ")" <p>opa mayki, tudo bem com você?</p>
<p>isso aconteceu porque o <code>&#43;</code> também é um quantificador dentro das expressões regulares, então precisamos utilizar a <code>\</code> para dizer que queremos o literal mesmo:</p>
<p>eu criei uma regex para testar aqui, um pouco diferente da sua veja:</p>
<pre class="prettyprint"><code>let pattern &#61; /[\d\.]&#43;e\&#43;\d{2}/g</code></pre><p>veja que eu estou criando um grupo que vai receber dígitos e ponto final, ai eu utilizo o <code>&#43;</code> para identificar que esse padrão de números e pontos para pegar mais de um</p>
<p>depois coloquei o <code>e</code>e o <code>\&#43;</code> para identificar que é de fato um <code>&#43;</code> e um <code>\d{2}</code> para ser os 2 últimos digitos</p>
<p>testando esse padrão:</p>
<pre class="prettyprint"><code>let valor &#61; &#34;2.4446506362607e&#43;29&#43;3.7298826723704e&#43;29&#34;
let pattern &#61; /[\d\.]&#43;e\&#43;\d{2}/g

let resposta &#61; valor.matchall(pattern)
resposta.next()

&gt;&gt;&gt;&gt;
done: false
value: array [ &#34;2.4446506362607e&#43;29&#34; ]

resposta.next()
&gt;&gt;&gt;
done: false
value: array [ &#34;3.7298826723704e&#43;29&#34; ]
</code></pre><p>compreendeu? </p>
<p>abraços e bons estudos!</p> paulo,uma das regras do enem é respeitar os direitos humanos. não desrespeitando-os, tudo bem. mas penso não ser necesário citar o nome de um remédio para propor uma solução. basta enunciar o que poderia ser feito, por quem e como.  aqui há uma redação comentada sobre o tema: https://educacao.uol.com.br/bancoderedacoes/redacao/ult4657u420.jhtm espero que tenha ajudado. se precisar de aulas de redação, é só entrar em contato. at.te, prof. miguel augusto ribeiro <p>você esqueceu de colocar o parenteses na função &#34;acertou&#34; dentro da condição do while.</p>
<pre class="prettyprint"><code>do{

 desenhaforca( );
 chuta();

 }while (!acertou &amp;&amp; !enforcou());</code></pre><p>tente agora:</p>
<pre class="prettyprint"><code>#include&lt;stdio.h&gt;
#include&lt;string.h&gt;
#include&lt;time.h&gt;
#include&lt;stdlib.h&gt;

char palavrasecreta[20];
char chutes[26];
int tentativas &#61; 0;

void baner(){
 printf(&#34;****************\n&#34;);
 printf(&#34; jogo de forca *\n&#34;);
 printf(&#34;****************\n\n&#34;);
}
void chuta(){
 char chute;
 scanf(&#34; %c&#34;,&amp;chute); 
 chutes[tentativas] &#61; chute;
 tentativas&#43;&#43;;
}
int jachutou(char letra){
 int achou &#61; 0; 

 for(int j &#61; 0;j &lt; tentativas; j&#43;&#43;){ 
 if(chutes[j] &#61;&#61; letra){
 achou &#61; 1;
 break;
 }
 }
 return achou;
}
void desenhaforca( ){
 for(int i &#61; 0; i &lt; strlen(palavrasecreta); i&#43;&#43;) { 

 int achou &#61; jachutou(palavrasecreta[i]);

 if (achou){
 printf(&#34;%c &#34;, palavrasecreta[i]);
 }else{
 printf(&#34;\_ &#34;);
 } 
 }
 printf(&#34;\n&#34;); 
}
void escolhepalavra( ){

 file* f;

 f &#61; fopen(&#34;palavras.txt&#34;,&#34;r&#34;);
 if( f &#61;&#61; 0){
 printf(&#34;banco de dados nao disponivel!\n\n&#34;);
 exit(1);
 }

 int qpalavras;
 fscanf(f, &#34;%d&#34;, &amp;qpalavras);

 srand(time(0));
 int rando &#61; rand() % qpalavras;

 for(int i &#61; 0;i &lt;&#61; rando; i&#43;&#43;){
 fscanf(f,&#34;%s&#34;,palavrasecreta);
 }

 fclose(f); 
}

int acertou(){
 for(int i &#61; 0; i &lt; strlen(palavrasecreta); i&#43;&#43;){
 if(!jachutou(palavrasecreta[i])){
 return 0;
 }
 } 
 return 1;
}


int enforcou(){

 int erros &#61; 0;

 for(int i; i &lt; tentativas; i&#43;&#43;){

 int existe &#61; 0;

 for(int j &#61; 0; j &lt; strlen(palavrasecreta); j&#43;&#43;){

 if (chutes[i] &#61;&#61; palavrasecreta[j]){
 existe &#61; 1;
 break;
 }
 }

 if(!existe) erros&#43;&#43;; 

 }
 return erros &gt;&#61; 6;
}

int main(void){

 baner();
 escolhepalavra();
 acertou();


 do{

 desenhaforca( );
 chuta();

 }while (!acertou() &amp;&amp; !enforcou()); // &#34;!&#34; negacao (1) 

}</code></pre> <p>encontrei uma solução para o seu problema.</p><p>baseado em <a href="https://stackoverflow.com/a/8798355/637284">this so answer</a> eu fiz um programa que usa classes de caracteres regex para procurar por letras que possam ter modificadores opcionais. ele divide sua string em caracteres simples (combinados, se necessário) e os coloca em uma lista:</p><pre><code>import java.util.*; import java.lang.*; import java.util.regex.*; class main { public static void main (string[] args) { string s="குமார்"; list&lt;string&gt; characters=new arraylist&lt;string&gt;(); pattern pat = pattern.compile("\\p{l}\\p{m}*"); matcher matcher = pat.matcher(s); while (matcher.find()) { characters.add(matcher.group()); } // test if we have the right characters and length system.out.println(characters); system.out.println("string length: " + characters.size()); } } </code></pre><p>onde <code>\\p{l}</code> significa uma letra unicode e <code>\\p{m}</code> significa uma marca unicode.</p><p>a saída do trecho é:</p><pre><code>கு மா ர் string length: 3 </code></pre><p>veja <a href="https://ideone.com/apkapn">https://ideone.com/apkapn</a> para uma demonstração funcional</p><hr><p><strong>edit</strong></p><p>eu agora chequei meu regex com todas as cartas tamil válidas tiradas das tabelas em <a href="http://en.wikipedia.org/wiki/tamil\_script">http://en.wikipedia.org/wiki/tamil\_script</a> . descobri que com o regex atual não capturamos todas as letras corretamente (cada letra na última linha da tabela composta de grantha é dividida em duas letras), então refinei meu regex para a seguinte solução:</p><pre><code>pattern pat = pattern.compile("\u0b95\u0bcd\u0bb7\\p{m}?|\\p{l}\\p{m}?"); </code></pre><p>com este padrão em vez do acima, você deve ser capaz de dividir sua sentença em cada letra tamil válida (desde que a tabela da wikipédia esteja completa).</p><p>o código que usei para verificar é o seguinte:</p><pre><code>string s = "ஃஅஆஇஈஉஊஎஏஐஒஓஔக்ககாகிகீகுகூகெகேகைகொகோகௌங்ஙஙாஙிஙீஙுஙூஙெஙேஙைஙொஙோஙௌச்சசாசிசீசுசூசெசேசைசொசோசௌஞ்ஞஞாஞிஞீஞுஞூஞெஞேஞைஞொஞோஞௌட்டடாடிடீடுடூடெடேடைடொடோடௌண்ணணாணிணீணுணூணெணேணைணொணோணௌத்ததாதிதீதுதூதெதேதைதொதோதௌந்நநாநிநீநுநூநெநேநைநொநோநௌப்பபாபிபீபுபூபெபேபைபொபோபௌம்மமாமிமீமுமூமெமேமைமொமோமௌய்யயாயியீயுயூயெயேயையொயோயௌர்ரராரிரீருரூரெரேரைரொரோரௌல்லலாலிலீலுலூலெலேலைலொலோலௌவ்வவாவிவீவுவூவெவேவைவொவோவௌழ்ழழாழிழீழுழூழெழேழைழொழோழௌள்ளளாளிளீளுளூளெளேளைளொளோளௌற்றறாறிறீறுறூறெறேறைறொறோறௌன்னனானினீனுனூனெனேனைனொனோனௌஶ்ஶஶாஶிஶீஶுஶூஶெஶேஶைஶொஶோஶௌஜ்ஜஜாஜிஜீஜுஜூஜெஜேஜைஜொஜோஜௌஷ்ஷஷாஷிஷீஷுஷூஷெஷேஷைஷொஷோஷௌஸ்ஸஸாஸிஸீஸுஸூஸெஸேஸைஸொஸோஸௌஹ்ஹஹாஹிஹீஹுஹூஹெஹேஹைஹொஹோஹௌக்ஷ்க்ஷக்ஷாக்ஷிக்ஷீக்ஷுக்ஷூக்ஷெக்ஷேக்ஷைஷொக்ஷோஷௌ"; list&lt;string&gt; characters = new arraylist&lt;string&gt;(); pattern pat = pattern.compile("\u0b95\u0bcd\u0bb7\\p{m}?|\\p{l}\\p{m}?"); matcher matcher = pat.matcher(s); while (matcher.find()) { characters.add(matcher.group()); } system.out.println(characters); system.out.println(characters.size() == 325); </code></pre> <p>olá daniel,</p>
<p>parece que o problema é que você está comparando o texto digitado no input com um número inteiro.</p>
<p>o valor retornado pela função <code>input</code> é string.</p>
<p>experimente modificar o código para:</p>
<pre class="prettyprint"><code>if g &#61;&#61; &#39;1&#39;:
 print(&#39;oque é oque é?&#39;)
 oque.adivinhacao()
elif g &#61;&#61; &#39;2&#39;:
 print(&#39;ultimas palavras?&#39;)
 game.forca()</code></pre><p>se tiver problemas avise...</p>
<p>luan</p> <p>oi rodrigo,</p>
<p>aí nesses casos, nos avise, pq atualizamos o texto do exercício! :)</p>
<p>um abraço,</p> <p>encontrei o erro,por causa de uma &#34;vírgula&#34; meu código não estava rodando rsrsrsrs.</p>
<pre class="prettyprint"><code> &#34;scripts&#34;: {
 &#34;test&#34;: &#34;echo \&#34;error: no test specified\&#34; &amp;&amp; exit 1&#34;
 &#34;start&#34;: &#34;electron .&#34;
 },</code></pre>
<p>após &#34;exit 1&#34; falta uma vírgula.</p>
<pre class="prettyprint"><code> &#34;scripts&#34;: {
 &#34;test&#34;: &#34;echo \&#34;error: no test specified\&#34; &amp;&amp; exit 1&#34;,
 &#34;start&#34;: &#34;electron .&#34;
 },</code></pre>
<p>obrigado a todos pela ajuda!</p> oi, pamela! como está? espero que bem! :blush:

perceba que temos 1 ca de um lado e 1 ca de outro. 1 co3 de um lado e um co3 de outro. porém, note que temos 2 na no lado dos reagentes e apenas um nos produtos.

sendo assim, na tentativa, você coloca 2 ali no naoh

feito isso, você irá reparar que a … <h2>7 bits ascii?</h2><p>se o seu tardis acabou de chegar em 1963, e você quer apenas o 7 bit imprimível ascii chars, você pode copiar tudo de 0 a 31 e 127 a 255 com isto:</p><pre><code>$string = preg\_replace('/[\x00-\x1f\x7f-\xff]/', '', $string); </code></pre><p>ele corresponde a qualquer coisa no intervalo de 0 a 31, 127 a 255 e remove-o. </p><h2>8 bits estendido ascii?</h2><p>você caiu em um time machine hot tub, e você está de volta nos anos oitenta. se você tem alguma forma de ascii de 8 bits, então você pode querer manter os caracteres no intervalo de 128-255. um ajuste fácil - basta olhar para 0-31 e 127</p><pre><code>$string = preg\_replace('/[\x00-\x1f\x7f]/', '', $string); </code></pre><h2>utf-8?</h2><p>ah, bem vindo de volta ao século 21. se você tem uma string codificada em utf-8, então o <code>/u</code> <a href="http://php.net/manual/en/reference.pcre.pattern.modifiers.php">modifier</a> pode ser usado no regex</p><pre><code>$string = preg\_replace('/[\x00-\x1f\x7f]/u', '', $string); </code></pre><p>isso apenas remove 0-31 e 127. isso funciona em ascii e utf-8 porque ambos compartilham o <a href="http://www.fileformat.info/info/charset/utf-8/list.htm">mesmo intervalo de conjunto de controles</a> (como observado por mgutt abaixo). estritamente falando, isso funcionaria sem o modificador <code>/u</code>. mas isso facilita a vida se você quiser remover outros caracteres ...</p><p>se você está lidando com unicode, existem <a href="https://stackoverflow.com/questions/3770117/what-is-the-range-of-unicode-printable-characters">potencialmente muitos elementos não-imprimíveis</a> , mas vamos considerar um simples: <a href="https://unicode-table.com/en/00a0/">no-break space (u + 00a0)</a> </p><p>em uma string utf-8, isso seria codificado como <code>0xc2a0</code>. você pode procurar e remover essa sequência específica, mas com o modificador <code>/u</code> no lugar, você pode simplesmente adicionar <code>\xa0</code> à classe de caractere:</p><pre><code>$string = preg\_replace('/[\x00-\x1f\x7f\xa0]/u', '', $string); </code></pre><h2>adenda: e sobre str\_replace?</h2><p>preg\_replace é bastante eficiente, mas se você está fazendo esta operação muito, você pode construir uma matriz de caracteres que você deseja remover, e usar str\_replace como observado por mgutt abaixo, por exemplo.</p><pre><code>//build an array we can re-use across several operations $badchar=array( // control characters chr(0), chr(1), chr(2), chr(3), chr(4), chr(5), chr(6), chr(7), chr(8), chr(9), chr(10), chr(11), chr(12), chr(13), chr(14), chr(15), chr(16), chr(17), chr(18), chr(19), chr(20), chr(21), chr(22), chr(23), chr(24), chr(25), chr(26), chr(27), chr(28), chr(29), chr(30), chr(31), // non-printing characters chr(127) ); //replace the unwanted chars $str2 = str\_replace($badchar, '', $str); </code></pre><p>intuitivamente, isso parece que seria rápido, mas nem sempre é o caso, você deve definitivamente comparar para ver se você economiza alguma coisa. fiz alguns benchmarks em vários comprimentos de string com dados aleatórios, e esse padrão surgiu usando o php 7.0.12</p><pre><code> 2 chars str\_replace 5.3439ms preg\_replace 2.9919ms preg\_replace is 44.01% faster 4 chars str\_replace 6.0701ms preg\_replace 1.4119ms preg\_replace is 76.74% faster 8 chars str\_replace 5.8119ms preg\_replace 2.0721ms preg\_replace is 64.35% faster 16 chars str\_replace 6.0401ms preg\_replace 2.1980ms preg\_replace is 63.61% faster 32 chars str\_replace 6.0320ms preg\_replace 2.6770ms preg\_replace is 55.62% faster 64 chars str\_replace 7.4198ms preg\_replace 4.4160ms preg\_replace is 40.48% faster 128 chars str\_replace 12.7239ms preg\_replace 7.5412ms preg\_replace is 40.73% faster 256 chars str\_replace 19.8820ms preg\_replace 17.1330ms preg\_replace is 13.83% faster 512 chars str\_replace 34.3399ms preg\_replace 34.0221ms preg\_replace is 0.93% faster 1024 chars str\_replace 57.1141ms preg\_replace 67.0300ms str\_replace is 14.79% faster 2048 chars str\_replace 94.7111ms preg\_replace 123.3189ms str\_replace is 23.20% faster 4096 chars str\_replace 227.7029ms preg\_replace 258.3771ms str\_replace is 11.87% faster 8192 chars str\_replace 506.3410ms preg\_replace 555.6269ms str\_replace is 8.87% faster 16384 chars str\_replace 1116.8811ms preg\_replace 1098.0589ms preg\_replace is 1.69% faster 32768 chars str\_replace 2299.3128ms preg\_replace 2222.8632ms preg\_replace is 3.32% faster </code></pre><p>os tempos próprios são para 10000 iterações, mas o que é mais interessante são as diferenças relativas. até 512 chars, eu estava vendo preg\_replace sempre vencer. no intervalo de 1-8kb, o str\_replace tinha um edge marginal. </p><p>eu pensei que era um resultado interessante, então incluí-lo aqui. <em>o importante é não pegar este resultado e usá-lo para decidir qual método utilizar, mas para fazer benchmark com seus próprios dados e depois decidir.</em></p>