como pronunciar achar em portuguese?
ah-shahr
<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> Você pode verificar o valor do caráter:



```
if ord(c) < 128 then
    // is an ascii character

``` procurando é a melhor maneira de achar olá victor, tudo bem?o problema do seu código é que você está declarando o vetor de strings de maneira incorreta. o certo é usar assim: char nome[5][100]; onde o primeiro par de colchetes é o ta... <p>você pode usar find com <a href="http://en.wikipedia.org/wiki/xargs">xargs</a> para isso</p><p><code>find /thisdir -type f -name "*.ogg" -print0 | xargs -0 -imysongs mv -i mysongs /somedir</code></p><blockquote> <p>o comando -i no comando acima informa ao xargs qual string de substituição você deseja usar (caso contrário, adiciona os argumentos ao final do comando).</p> </blockquote><p>or<br> no seu comando, tente mover '{}' após o comando <code>mv</code>.</p><p><code>find /thisdir -type f -name '*.ogg' -exec mv -i {} /somedir \;</code></p> <p>tente isto:</p><pre><code>$str = preg\_replace\_callback('/\\\\u([0-9a-fa-f]{4})/', function ($match) { return mb\_convert\_encoding(pack('h*', $match[1]), 'utf-8', 'ucs-2be'); }, $str); </code></pre><p>caso seja baseado em utf-16, c/c++/java/json-style:</p><pre><code>$str = preg\_replace\_callback('/\\\\u([0-9a-fa-f]{4})/', function ($match) { return mb\_convert\_encoding(pack('h*', $match[1]), 'utf-8', 'utf-16be'); }, $str); </code></pre> <p>o último parâmetro no <code>angular.foreach</code> (veja <a href="http://docs.angularjs.org/api/angular.foreach">http://docs.angularjs.org/api/angular.foreach</a> ) a função é o contexto para <code>this</code>. então você vai querer algo assim:</p><pre><code>app.service('myservice', function() { this.list = []; this.execute = function() { //this.list is reachable here angular.foreach(anarrayhere, function(val, key) { //access this.list }, this); } } </code></pre> Hi AmCarlos,eu também tenho uma dica para deixar : <http://www.oddcast.com/home/demos/tts/tts_example.php> ;neste site você digita a palavra ou frase ,em inglês ,que deseja ouvir, e pronto é só ir praticando.Você também pode mudar a voz,por efeitos(deixar a pronuncia lenta,rápida etc.) e pode mudar idioma,se quiser treinar outra língua.Good studies and have fun! :) resumindo aqui a resposta que demos em aula: essas duas são mesmo as melhores opções e o uso depende muito de qual o seu objetivo. se você quiser capturar o erro e agir sobre ele, melhor a trycatch(); nas outras situações é melhor a possibly().

nossa única outra recomendação é evitar ao máximo o us… <p>lidar com vários níveis de citação (na verdade, vários níveis de análise/interpretação) pode ser complicado. isso ajuda a manter algumas coisas em mente:</p><ul> <li>cada “nível de citação” pode envolver potencialmente uma linguagem diferente.</li> <li>as regras de cotação variam de acordo com o idioma.</li> <li>ao lidar com mais de um ou dois níveis aninhados, geralmente é mais fácil trabalhar "de baixo para cima" (ou seja, do interior para o exterior).</li> </ul><h1>níveis de citação</h1><p>vejamos seus comandos de exemplo.</p><pre><code>pgrep -fl java | grep -i datanode | awk '{print $1}' </code></pre><p>seu primeiro exemplo de comando (acima) usa quatro idiomas: seu shell, o regex em <em> pgrep </em>, o regex em <em> grep </em> (que pode ser diferente da linguagem regex em <em> pgrep </em>) e <em> awk </em>. existem dois níveis de interpretação envolvidos: o shell e um nível após o shell para cada um dos comandos envolvidos. existe apenas um nível explícito de citação (shell citação em <em> awk </em>).</p><pre><code>ssh host … </code></pre><p>em seguida, você adicionou um nível de <em> ssh </em> no topo. este é efetivamente outro nível de shell: <em> ssh </em> não interpreta o comando em si, ele o entrega a um shell na extremidade remota (via (por exemplo) <code>sh -c …</code>) e que shell interpreta a string.</p><pre><code>ssh host "sudo su user -c …" </code></pre><p>então, você perguntou sobre a adição de outro nível de shell no meio usando <em> su </em> (via <em> sudo </em>, que não interpreta seus argumentos de comando, portanto, podemos ignorá-lo). neste ponto, você tem três níveis de aninhamento em andamento (<em> awk </em> → shell, shell → shell (<em> ssh </em>), shell → shell (<em> su user -c </em>), então aconselho usar a abordagem “de baixo para cima”. vou assumir que seus shells são compatíveis com bourne (por exemplo <em> sh </em>, <em> ash </em> , <em> traço </em>, <em> ksh </em>, <em> bash </em>, <em> zsh </em>, etc.). algum outro tipo de shell (<em> fish </em>, <em> rc </em>, etc.) pode exigir sintaxe diferente, mas o método ainda se aplica.</p><h1>debaixo para cima</h1><ol> <li>formule a string que deseja representar no nível mais interno.</li> <li>selecione um mecanismo de citações do repertório de citações do idioma seguinte.</li> <li>cite a string desejada de acordo com o mecanismo de cotação selecionado. <ul> <li>freqüentemente, há muitas variações de como aplicar qual mecanismo de cotação. fazer manualmente é geralmente uma questão de prática e experiência. ao fazer isso de forma programática, geralmente é melhor escolher o mais fácil de acertar (geralmente o “mais literal” (menos escapes)).</li> </ul> </li> <li>opcionalmente, use a string entre aspas resultante com código adicional.</li> <li>se você ainda não atingiu o nível desejado de citação/interpretação, pegue a string entre aspas resultante (mais qualquer código adicionado) e use-a como string inicial na etapa 2.</li> </ol><h1>a semântica das citações varia</h1><p>o que se deve ter em mente aqui é que cada idioma (nível de citação) pode fornecer semânticas ligeiramente diferentes (ou mesmo semânticas drasticamente diferentes) para o mesmo personagem de citação.</p><p>a maioria das linguagens tem um mecanismo de citação “literal”, mas eles variam exatamente em quão literais são. a aspa simples de shells do tipo bourne é literal (o que significa que você não pode usá-la para citar um caractere de aspas simples). outras linguagens (perl, ruby) são menos literais porque interpretam <strong>algumas</strong> sequências de barra invertida dentro de regiões entre aspas simples não literalmente (especificamente, <code>\\</code> e <code>\'</code> resulta em <code>\</code> e <code>'</code>, mas outras sequências de barra invertida são, na verdade, literais).</p><p>você terá que ler a documentação de cada um de seus idiomas para entender suas regras de cotação e a sintaxe geral.</p><h1>seu exemplo</h1><p>o nível mais interno do seu exemplo é um programa <em> awk </em>.</p><pre><code>{print $1} </code></pre><p>você vai incorporar isso em uma linha de comando do shell:</p><pre><code>pgrep -fl java | grep -i datanode | awk … </code></pre><p>precisamos proteger (no mínimo) o espaço e o <code>$</code> no programa <em> awk </em>. a escolha óbvia é usar aspas simples no shell em todo o programa.</p><ul> <li><code>'{print $1}'</code></li> </ul><p>no entanto, existem outras opções:</p><ul> <li><code>{print\ \$1}</code> escape diretamente do espaço e <code>$</code></li> <li><code>{print' $'1}</code> aspas simples apenas o espaço e <code>$</code></li> <li><code>"{print \$1}"</code> aspas duplas o todo e escapar de <code>$</code></li> <li><code>{print" $"1}</code> aspas duplas apenas o espaço e <code>$</code><br> isso pode estar distorcendo um pouco as regras (sem escape <code>$</code> no final de uma string entre aspas duplas é literal), mas parece funcionar na maioria dos shells.</li> </ul><p>se o programa usasse uma vírgula entre as chaves de abertura e fechamento, também precisaríamos citar ou escapar a vírgula ou as chaves para evitar a “expansão da chave” em alguns shells.</p><p>nós escolhemos <code>'{print $1}'</code> e incorporá-lo ao resto do “código” shell:</p><pre><code>pgrep -fl java | grep -i datanode | awk '{print $1}' </code></pre><p>em seguida, você queria executar isso via <em> su </em> e <em> sudo </em>.</p><pre><code>sudo su user -c … </code></pre><p><code>su user -c …</code> é como <code>some-shell -c …</code> (exceto rodando em algum outro uid), então <em> su </em> apenas adiciona outro nível de shell. <em> sudo </em> não interpreta seus argumentos, então não adiciona nenhum nível de citação.</p><p>precisamos de outro nível de shell para nossa string de comando. podemos escolher aspas simples novamente, mas temos que dar tratamento especial às aspas simples existentes. a maneira usual é assim:</p><pre><code>'pgrep -fl java | grep -i datanode | awk '\''{print $1}'\' </code></pre><p>existem quatro strings aqui que o shell irá interpretar e concatenar: a primeira string entre aspas simples (<code>pgrep … awk</code>), uma aspa simples de escape, o programa de aspas simples <em> awk </em>, outra aspa simples de escape.</p><p>existem, é claro, muitas alternativas:</p><ul> <li><code>pgrep\ -fl\ java\ \|\ grep\ -i\ datanode\ \|\ awk\ \'{print\ \$1}</code> fuja de tudo que é importante</li> <li><code>pgrep\ -fl\ java\|grep\ -i\ datanode\|awk\ \'{print\$1}</code> o mesmo, mas sem espaços em branco supérfluos (mesmo no programa <em> awk </em>!)</li> <li><code>"pgrep -fl java | grep -i datanode | awk '{print \$1}'"</code> aspas duplas, escape de <code>$</code></li> <li><code>'pgrep -fl java | grep -i datanode | awk '"'"'{print \$1}'"'"</code> sua variação; um pouco mais longo do que o normal devido ao uso de aspas duplas (dois caracteres) em vez de escapes (um caractere)</li> </ul><p>usar citações diferentes no primeiro nível permite outras variações neste nível:</p><ul> <li><code>'pgrep -fl java | grep -i datanode | awk "{print \$1}"'</code></li> <li><code>'pgrep -fl java | grep -i datanode | awk {print\ \$1}'</code></li> </ul><p>incorporar a primeira variação na linha de comando <em> sudo </em>/* su * fornece o seguinte:</p><pre><code>sudo su user -c 'pgrep -fl java | grep -i datanode | awk '\''{print $1}'\' </code></pre><p>você pode usar a mesma string em qualquer outro contexto de nível de shell (por exemplo, <code>ssh host …</code>).</p><p>em seguida, você adicionou um nível de <em> ssh </em> no topo. este é efetivamente outro nível de shell: <em> ssh </em> não interpreta o comando em si, mas o entrega a um shell na extremidade remota (via (por exemplo) <code>sh -c …</code>) e que shell interpreta a string.</p><pre><code>ssh host … </code></pre><p>o processo é o mesmo: pegue a string, escolha um método de cotação, use-a, incorpore-a.</p><p>usando aspas simples novamente:</p><pre><code>'sudo su user -c '\''pgrep -fl java | grep -i datanode | awk '\'\\\'\''{print $1}'\'\\\' </code></pre><p>agora, existem onze strings que são interpretadas e concatenadas: <code>'sudo su user -c '</code>, aspas simples com escape, <code>'pgrep … awk '</code>, aspas simples de escape, barra invertida de escape, duas aspas simples de escape, o programa entre aspas simples <em> awk </em>, aspas simples de escape, barra invertida de escape e um aspas simples com escape final.</p><p>a forma final é parecida com esta:</p><pre><code>ssh host 'sudo su user -c '\''pgrep -fl java | grep -i datanode | awk '\'\\\'\''{print $1}'\'\\\' </code></pre><p>é um pouco complicado digitar à mão, mas a natureza literal da citação única do shell torna mais fácil automatizar uma ligeira variação:</p><pre><code>#!/bin/sh sq() { # single quote for bourne shell evaluation # change ' to '\'' and wrap in single quotes. # if original starts/ends with a single quote, creates useless # (but harmless) '' at beginning/end of result. printf '%s\n' "$*" | sed -e "s/'/'\\\\''/g" -e 1s/^/\'/ -e \$s/\$/\'/ } # some shells (ksh, bash, zsh) can do something similar with %q, but # the result may not be compatible with other shells (ksh uses $'...', # but dash does not recognize it). # # sq() { printf %q "$*"; } ap='{print $1}' s1="pgrep -fl java | grep -i datanode | awk $(sq "$ap")" s2="sudo su user -c $(sq "$s1")" ssh host "$(sq "$s2")" </code></pre>