https://wiki.unicentro.br/api.php?action=feedcontributions&user=Maprestes&feedformat=atomWikiunicentro - Contribuições do(a) usuário(a) [pt-br]2024-03-29T07:14:46ZContribuições do(a) usuário(a)MediaWiki 1.31.16https://wiki.unicentro.br/index.php?title=TL_PC&diff=16311TL PC2020-08-28T17:27:00Z<p>Maprestes: </p>
<hr />
<div>[[Arquivo: Treinamento_Logo_Desc.png|700px||right| <br />
<br />
<font size="2"><br />
<br />
</font><br />
<br />
]]<br />
<br />
<br />
== Treinamento em Lógica e Programação de Computadores no Ensino Técnico ==<br />
<br />
<br />
<br />
<br><br />
O enfoque do projeto é proporcionar treinamento para alunos do ensino técnico que possuem maior interesse em programação, sobretudo, que participam da [https://olimpiada.ic.unicamp.br Olimpíada Brasileira de Informática (OBI)].<br />
<br />
<br />
== Sobre a Olimpíada Brasileira de Informática ==<br />
<br />
O objetivo da [https://olimpiada.ic.unicamp.br Olimpíada Brasileira de Informática (OBI)] é despertar nos alunos o interesse por uma ciência importante na formação básica hoje em dia (no caso, ciência da computação), através de uma atividade que envolve desafio, engenhosidade e uma saudável dose de competição. A organização da OBI está cargo do Instituto de Computação da UNICAMP.<br />
<br />
[[Olimpíada_Brasileira_de_Informática| Leia mais.]]<br />
<br />
<br><br />
<br />
== Conteúdos ==<br />
<br />
* [[Formato_dos_problemas| Formato dos problemas ]] <br />
<br />
* [[Sistemas_automáticos_de_avaliação| Sistemas automáticos de avaliação ]] <br />
<br />
* [[Erros_Comuns| Erros comuns ]] <br />
<br />
* [[Entrada_e_saída_de_dados| Entrada/Saída de Dados]]<br />
<br />
* [[Operadores_Logicos| Operadores Lógicos]]<br />
<br />
* [[Estruturas_de_Seleção| Estruturas de Seleção]]<br />
<br />
* [[Estruturas_de_Repetição| Estruturas de Repetição]]<br />
<br />
* [[Vetores| Vetores]]<br />
<br />
<br><br />
<br />
== Equipe de execução ==<br />
<br />
'''Coordenação:'''<br />
* Ana Elisa T. P. da Palma<br />
* Mauro Miazaki<br />
<br />
'''Monitores:'''<br />
* Alexandro Luis da Rocha Junior<br />
* Erick Ascencio da Silva<br />
* Moises Alonso Prestes</div>Mapresteshttps://wiki.unicentro.br/index.php?title=DECOMP&diff=16310DECOMP2020-08-28T17:26:20Z<p>Maprestes: /* Treinamento em Lógica e Programação de Computadores no Ensino Técnico */</p>
<hr />
<div><br />
[[Arquivo: LogoCC.png|300px|thumb|right| <br />
<font size="2"><br />
Logo<br />
</font><br />
]]<br />
<br />
=DECOMP - Departamento de Ciência da Computação=<br />
<br />
Página em construção...<br />
<br><br><br />
<br />
== Projetos de Extensão ==<br />
<br />
=== [[Ensino_Extracurricular_de_Programação_de_Computadores| Ensino Extracurricular de Programação de Computadores - E2PC]] ===<br />
O projeto visa oferecer oportunidades extracurriculares de treinamento em Programação de Computadores aos alunos do Bacharelado em Ciência da Computação e demais acadêmicos interessados, bem como, oferecer treinamento e reforçar conceitos aos alunos do ensino médio de colégios da região utilizando principalmente o ambiente online [[MOODLE| MOODLE]] para disponibilização de material, envio de atividades, fórum de discussões, bem como a realização de desafios disponíveis no site da [http://olimpiada.ic.unicamp.br/info/geral Olimpíada Brasileira de Informática (OBI)] e no site [https://www.urionlinejudge.com.br URI Online Judge] que contam com ambiente de submissão e autojudge online, assim os alunos podem testar suas soluções e abrir discussões dentro do próprio [[MOODLE| MOODLE]] para que outros alunos possam interagir em conjunto.<br />
<br><br><br />
<br />
=== [[TL_PC| Treinamento em Lógica e Programação de Computadores no Ensino Técnico]] ===<br />
Por meio de treinamentos destinados aos alunos de cursos técnicos em informática, o projeto visa melhorar as habilidades em lógica e programação de computadores dos participantes.<br />
Os treinamentos são voltados à linguagens de programação, usando a metodologia das competições de programação (Olimpíada Brasileira de Informática - OBI), bem como outros paradigmas (orientação a objetos usando o ambiente Greenfoot).<br />
<br><br><br />
<br />
=== [[Projeto_Smart-me| Projeto Smart-me]] ===<br />
Os objetivos do projeto visam proferir palestras sobre navegação segura na Internet e aplicativos de utilidade pública, ministrar oficinas de curta duração sobre assuntos específicos sobre o uso da Internet, tais como privacidade, senhas, comércio eletrônico, redes sociais, dispositivos móveis, Internet cidadã (sites de utilidade pública e governo digital), fornecer, a partir das experiências e resultados do projeto, elementos que possam contribuir na formulação, implementação e acompanhamento das políticas públicas relacionadas ao uso das TICs (em especial, na oficina "Internet Cidadã"), criar, organizar e estruturar o conteúdo das ações no [[MOODLE|MOODLE]], possibilitando a replicação das ações, possibilitar aos estudanes de Ciência da Computação oportunidades para identificação de demanda de novos aplicativos que contribuam nas atividades cotidianas dos cidadãos, que poderão ser objetos de trabalhos de conclusão de curso, de<br />
Estágio Curricular, ou de outros projetos de extensão e difusão tecnológica, oferecer oportunidades de formação complementar exigida no Projeto Pedagógico do Curso de Ciência da Computação, possibilitar a formação técnico-científica, pessoal e social dos estudantes de graduação envolvidos no projeto e sistematizar, registrar as experiências e resultados do projeto para eventual divulgação<br />
técnico-científica.<br />
<br><br></div>Mapresteshttps://wiki.unicentro.br/index.php?title=TL_PC&diff=16308TL PC2020-08-28T17:24:32Z<p>Maprestes: Maprestes moveu a página TL&PC para TL PC</p>
<hr />
<div>[[Arquivo: Treinamento_Logo_Desc.png|700px||right| <br />
<br />
<font size="2"><br />
<br />
</font><br />
<br />
]]<br />
<br />
<br />
== O Projeto ==<br />
<br />
<br />
<br />
<br><br />
O enfoque do projeto é proporcionar treinamento para alunos do ensino técnico que possuem maior interesse em programação, sobretudo, que participam da [https://olimpiada.ic.unicamp.br Olimpíada Brasileira de Informática (OBI)].<br />
<br />
<br />
== Sobre a Olimpíada Brasileira de Informática ==<br />
<br />
O objetivo da [https://olimpiada.ic.unicamp.br Olimpíada Brasileira de Informática (OBI)] é despertar nos alunos o interesse por uma ciência importante na formação básica hoje em dia (no caso, ciência da computação), através de uma atividade que envolve desafio, engenhosidade e uma saudável dose de competição. A organização da OBI está cargo do Instituto de Computação da UNICAMP.<br />
<br />
[[Olimpíada_Brasileira_de_Informática| Leia mais.]]<br />
<br />
<br><br />
<br />
== Conteúdos ==<br />
<br />
* [[Formato_dos_problemas| Formato dos problemas ]] <br />
<br />
* [[Sistemas_automáticos_de_avaliação| Sistemas automáticos de avaliação ]] <br />
<br />
* [[Erros_Comuns| Erros comuns ]] <br />
<br />
* [[Entrada_e_saída_de_dados| Entrada/Saída de Dados]]<br />
<br />
* [[Operadores_Logicos| Operadores Lógicos]]<br />
<br />
* [[Estruturas_de_Seleção| Estruturas de Seleção]]<br />
<br />
* [[Estruturas_de_Repetição| Estruturas de Repetição]]<br />
<br />
* [[Vetores| Vetores]]<br />
<br />
<br><br />
<br />
== Equipe de execução ==<br />
<br />
'''Coordenação:'''<br />
* Ana Elisa T. P. da Palma<br />
* Mauro Miazaki<br />
<br />
'''Monitores:'''<br />
* Alexandro Luis da Rocha Junior<br />
* Erick Ascencio da Silva<br />
* Moises Alonso Prestes</div>Mapresteshttps://wiki.unicentro.br/index.php?title=TL%26PC&diff=16309TL&PC2020-08-28T17:24:32Z<p>Maprestes: Maprestes moveu a página TL&PC para TL PC</p>
<hr />
<div>#REDIRECIONAMENTO [[TL PC]]</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Treinamento_em_L%C3%B3gica_e_Programa%C3%A7%C3%A3o_de_Computadores_no_Ensino_T%C3%A9cnico&diff=16307Treinamento em Lógica e Programação de Computadores no Ensino Técnico2020-08-28T17:24:10Z<p>Maprestes: Maprestes moveu a página Treinamento em Lógica e Programação de Computadores no Ensino Técnico para TL&PC</p>
<hr />
<div>#REDIRECIONAMENTO [[TL&PC]]</div>Mapresteshttps://wiki.unicentro.br/index.php?title=TL_PC&diff=16306TL PC2020-08-28T17:24:09Z<p>Maprestes: Maprestes moveu a página Treinamento em Lógica e Programação de Computadores no Ensino Técnico para TL&PC</p>
<hr />
<div>[[Arquivo: Treinamento_Logo_Desc.png|700px||right| <br />
<br />
<font size="2"><br />
<br />
</font><br />
<br />
]]<br />
<br />
<br />
== O Projeto ==<br />
<br />
<br />
<br />
<br><br />
O enfoque do projeto é proporcionar treinamento para alunos do ensino técnico que possuem maior interesse em programação, sobretudo, que participam da [https://olimpiada.ic.unicamp.br Olimpíada Brasileira de Informática (OBI)].<br />
<br />
<br />
== Sobre a Olimpíada Brasileira de Informática ==<br />
<br />
O objetivo da [https://olimpiada.ic.unicamp.br Olimpíada Brasileira de Informática (OBI)] é despertar nos alunos o interesse por uma ciência importante na formação básica hoje em dia (no caso, ciência da computação), através de uma atividade que envolve desafio, engenhosidade e uma saudável dose de competição. A organização da OBI está cargo do Instituto de Computação da UNICAMP.<br />
<br />
[[Olimpíada_Brasileira_de_Informática| Leia mais.]]<br />
<br />
<br><br />
<br />
== Conteúdos ==<br />
<br />
* [[Formato_dos_problemas| Formato dos problemas ]] <br />
<br />
* [[Sistemas_automáticos_de_avaliação| Sistemas automáticos de avaliação ]] <br />
<br />
* [[Erros_Comuns| Erros comuns ]] <br />
<br />
* [[Entrada_e_saída_de_dados| Entrada/Saída de Dados]]<br />
<br />
* [[Operadores_Logicos| Operadores Lógicos]]<br />
<br />
* [[Estruturas_de_Seleção| Estruturas de Seleção]]<br />
<br />
* [[Estruturas_de_Repetição| Estruturas de Repetição]]<br />
<br />
* [[Vetores| Vetores]]<br />
<br />
<br><br />
<br />
== Equipe de execução ==<br />
<br />
'''Coordenação:'''<br />
* Ana Elisa T. P. da Palma<br />
* Mauro Miazaki<br />
<br />
'''Monitores:'''<br />
* Alexandro Luis da Rocha Junior<br />
* Erick Ascencio da Silva<br />
* Moises Alonso Prestes</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Erros_Comuns&diff=16299Erros Comuns2020-07-30T18:47:07Z<p>Maprestes: </p>
<hr />
<div><br />
Nesse tópico abordaremos quais são os erros mais comuns que os estudantes podem estar cometendo na hora de escrever seu código e enviar para a avaliação. Então se estiver tendo algum problema em uma dessas duas etapas talvez esse tópico possa te ajudar!<br />
<br />
== Observações gerais ==<br />
<br />
A saída deve apresentar estritamente o que foi solicitado, qualquer texto, espaço ou quebra de linha a mais (ou a menos) resultará em uma mensagem de erro.<br />
<br />
Os intervalos dos dados de entrada e saída, definidos no enunciado de um problema, servem para que as variáveis sejam corretamente dimensionadas. Esses intervalos não precisam ser testados, os valores de entrada dos conjuntos de teste estarão de acordo com essa especificação.<br />
<br />
== Por que o URI não aceita minha solução? ==<br />
<br />
Dentre os erros mais comuns, baseado nos problemas “Iniciante” estão:<br />
<br />
=== Wrong Answer (Resposta errada) ===<br />
<br />
<li> Impressão de mensagens fora da especificação (pedir entrada, sem o formato do exemplo) </li><br />
<br />
<pre><br />
cout << “Digite a distância: ”;<br />
</pre><br />
<br />
<li> Cálculo incorreto, cálculo sem precisão. No enunciado, é explicitado o tipo (e intervalo) dos dados de entrada e de saída. Um problema frequente é a precisão, pois alguns valores são muito maiores do que os exemplos do enunciado. Se o seu problema estiver tendo um percentual baixo de Wrong Answer (20% ou menos), tente aumentar a capacidade das variáveis (de int para long int, de float para double). </li><br />
<br />
<li> Sinal de igualdade para atribuição (expressão lógica com sintaxe incorreta) </li><br />
<br />
Código errado:<br />
<pre><br />
if(i = 0){<br />
//trecho de código<br />
}<br />
</pre><br />
<br />
Código certo:<br />
<pre><br />
if(i == 0){<br />
//trecho de código<br />
}<br />
</pre><br />
<br />
<li> Condição incorreta (atribuição e não igualdade, várias condições separadas por vírgula) ou estrutura de seleção mal escrita (vários if's sem operador lógico) </li><br />
<br />
//TABELA<br />
<br />
=== Presentation error ===<br />
<br />
Formatação dos dados de saída<br />
<br />
<li>Falta de quebrar linha no final da apresentação</li><br />
Exemplo:<br />
Código errado<br />
<br />
<pre><br />
//Em C<br />
printf("Olá");<br />
//Em C++<br />
cout << "Olá";<br />
//Em Python<br />
print('Olá'); <br />
</pre><br />
Código certo<br />
<pre><br />
//Em C<br />
printf("Olá\n");<br />
//Em C++<br />
cout << "Olá" << endl;<br />
//Em Python<br />
print('Olá\n');<br />
</pre><br />
<br />
<li>Falta de espaço</li><br />
<br />
//TABELA<br />
<br />
<br />
=== Compilation error ===<br />
<br />
<li> Linguagem errada selecionada na hora de submeter </li><br />
<br />
<li> Vírgula para demarcar casa decimal </li><br />
<br />
<li> Sem ; no fim da linha </li><br />
<br />
<li> Sem ; no fim da linha </li><br />
<br />
<li> Colocar ; no fim de um if </li><br />
<br />
<li> Troca de << por >> em cin/cout (C++) </li><br />
<br />
<li> Falta ou excesso de parênteses </li><br />
<br />
<li> Nomes de variáveis incorretos </li><br />
<br />
<li> Ausência de chaves (ao copiar o código para colar na janela de submissão, a chave não foi selecionada) </li><br />
<br />
<li> Ausência de bibliotecas utilizadas (#include <...>) </li><br />
<br />
=== Consulte outras pessoas ===<br />
<br />
Se mesmo depois de conferir todas as opções da pagina o erro ainda persistir, consulte um monitor ou um colega mais experiente. Muitas vezes o programador está tão imerso em seu próprio código que não consegue ver um erro simples bem na sua frente.<br />
<br />
É muito comum se frustrar com os erros do seu código, e isso não some com o tempo, porem, quando mais se pratica mais fácil fica de se identificar e corrigir esses erros de formas muito mais fáceis e rápidas.</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Erros_Comuns&diff=16298Erros Comuns2020-07-30T18:08:33Z<p>Maprestes: </p>
<hr />
<div><br />
Nesse tópico abordaremos quais são os erros mais comuns que os estudantes podem estar cometendo na hora de escrever seu código e enviar para a avaliação. Então se estiver tendo algum problema em uma dessas duas etapas talvez esse tópico possa te ajudar!<br />
<br />
== Observações gerais ==<br />
<br />
A saída deve apresentar estritamente o que foi solicitado, qualquer texto, espaço ou quebra de linha a mais (ou a menos) resultará em uma mensagem de erro.<br />
<br />
Os intervalos dos dados de entrada e saída, definidos no enunciado de um problema, servem para que as variáveis sejam corretamente dimensionadas. Esses intervalos não precisam ser testados, os valores de entrada dos conjuntos de teste estarão de acordo com essa especificação.<br />
<br />
== Por que o URI não aceita minha solução? ==<br />
<br />
Dentre os erros mais comuns, baseado nos problemas “Iniciante” estão:<br />
<br />
=== Wrong Answer (Resposta errada) ===<br />
<br />
<li> Impressão de mensagens fora da especificação (pedir entrada, sem o formato do exemplo) </li><br />
<br />
<pre><br />
cout << “Digite a distância: ”;<br />
</pre><br />
<br />
<li> Cálculo incorreto, cálculo sem precisão. No enunciado, é explicitado o tipo (e intervalo) dos dados de entrada e de saída. Um problema frequente é a precisão, pois alguns valores são muito maiores do que os exemplos do enunciado. Se o seu problema estiver tendo um percentual baixo de Wrong Answer (20% ou menos), tente aumentar a capacidade das variáveis (de int para long int, de float para double). </li><br />
<br />
<li> Sinal de igualdade para atribuição (expressão lógica com sintaxe incorreta) </li><br />
<br />
Código errado:<br />
<pre><br />
if(i = 0){<br />
//trecho de código<br />
}<br />
</pre><br />
<br />
Código certo:<br />
<pre><br />
if(i == 0){<br />
//trecho de código<br />
}<br />
</pre><br />
<br />
<li> Condição incorreta (atribuição e não igualdade, várias condições separadas por vírgula) ou estrutura de seleção mal escrita (vários if's sem operador lógico) </li><br />
<br />
//TABELA<br />
<br />
=== Presentation error ===<br />
<br />
Formatação dos dados de saída<br />
<br />
<li>Falta de quebrar linha no final da apresentação</li><br />
Exemplo:<br />
Código errado<br />
<br />
<pre><br />
//Em C<br />
printf("Olá");<br />
//Em C++<br />
cout << "Olá";<br />
//Em Python<br />
print('Olá'); <br />
</pre><br />
Código certo<br />
<pre><br />
//Em C<br />
printf("Olá\n");<br />
//Em C++<br />
cout << "Olá" << endl;<br />
//Em Python<br />
print('Olá\n');<br />
</pre><br />
<br />
<li>Falta de espaço</li><br />
<br />
//TABELA<br />
<br />
<br />
=== Compilation error ===<br />
<br />
<li> Linguagem errada selecionada na hora de submeter </li><br />
<br />
<li> Vírgula para demarcar casa decimal </li><br />
<br />
<li> Sem ; no fim da linha </li><br />
<br />
<li> Sem ; no fim da linha </li><br />
<br />
<li> Colocar ; no fim de um if </li><br />
<br />
<li> Troca de << por >> em cin/cout (C++) </li><br />
<br />
<li> Falta ou excesso de parênteses </li><br />
<br />
<li> Nomes de variáveis incorretos </li><br />
<br />
<li> Ausência de chaves (ao copiar o código para colar na janela de submissão, a chave não foi selecionada) </li><br />
<br />
<li> Ausência de bibliotecas utilizadas (#include <...>) </li></div>Mapresteshttps://wiki.unicentro.br/index.php?title=Erros_Comuns&diff=16297Erros Comuns2020-07-30T18:05:43Z<p>Maprestes: </p>
<hr />
<div><br />
Nesse tópico abordaremos quais são os erros mais comuns que os estudantes podem estar cometendo na hora de escrever seu código e enviar para a avaliação. Então se estiver tendo algum problema em uma dessas duas etapas talvez esse tópico possa te ajudar!<br />
<br />
== Observações gerais ==<br />
<br />
A saída deve apresentar estritamente o que foi solicitado, qualquer texto, espaço ou quebra de linha a mais (ou a menos) resultará em uma mensagem de erro.<br />
<br />
Os intervalos dos dados de entrada e saída, definidos no enunciado de um problema, servem para que as variáveis sejam corretamente dimensionadas. Esses intervalos não precisam ser testados, os valores de entrada dos conjuntos de teste estarão de acordo com essa especificação.<br />
<br />
== Por que o URI não aceita minha solução? ==<br />
<br />
Dentre os erros mais comuns, baseado nos problemas “Iniciante” estão:<br />
<br />
=== Wrong Answer (Resposta errada) ===<br />
<br />
<li> Impressão de mensagens fora da especificação (pedir entrada, sem o formato do exemplo) </li><br />
<br />
<pre><br />
cout << “Digite a distância: ”;<br />
</pre><br />
<br />
<li> Cálculo incorreto, cálculo sem precisão. No enunciado, é explicitado o tipo (e intervalo) dos dados de entrada e de saída. Um problema frequente é a precisão, pois alguns valores são muito maiores do que os exemplos do enunciado. Se o seu problema estiver tendo um percentual baixo de Wrong Answer (20% ou menos), tente aumentar a capacidade das variáveis (de int para long int, de float para double). </li><br />
<br />
<li> Sinal de igualdade para atribuição (expressão lógica com sintaxe incorreta) </li><br />
<br />
Código errado:<br />
<pre><br />
if(i = 0){<br />
//trecho de código<br />
}<br />
</pre><br />
<br />
Código certo:<br />
<pre><br />
if(i == 0){<br />
//trecho de código<br />
}<br />
</pre><br />
<br />
<li> Condição incorreta (atribuição e não igualdade, várias condições separadas por vírgula) ou estrutura de seleção mal escrita (vários if's sem operador lógico) </li><br />
<br />
//TABELA<br />
<br />
=== Presentation error ===<br />
<br />
Formatação dos dados de saída<br />
<br />
<li>Falta de quebrar linha no final da apresentação</li><br />
Exemplo:<br />
Código errado<br />
<br />
<pre><br />
//Em C<br />
printf("Olá");<br />
//Em C++<br />
cout << "Olá";<br />
//Em Python<br />
print('Olá'); <br />
</pre><br />
Código certo<br />
<pre><br />
//Em C<br />
printf("Olá\n");<br />
//Em C++<br />
cout << "Olá" << endl;<br />
//Em Python<br />
print('Olá\n');<br />
</pre><br />
<br />
<li>Falta de espaço</li><br />
<br />
//TABELA<br />
<br />
<br />
=== Compilation error ===<br />
<br />
<li> Linguagem errada selecionada na hora de submeter. </li><br />
<br />
<li> Vírgula para demarcar casa decimal. </li><br />
<br />
<li> Sem ; no fim da linha. </li><br />
<br />
<li> Sem ; no fim da linha. </li><br />
<br />
<li> Colocar ; no fim de um if. </li></div>Mapresteshttps://wiki.unicentro.br/index.php?title=Erros_Comuns&diff=16296Erros Comuns2020-07-30T18:00:36Z<p>Maprestes: </p>
<hr />
<div><br />
Nesse tópico abordaremos quais são os erros mais comuns que os estudantes podem estar cometendo na hora de escrever seu código e enviar para a avaliação. Então se estiver tendo algum problema em uma dessas duas etapas talvez esse tópico possa te ajudar!<br />
<br />
== Observações gerais ==<br />
<br />
A saída deve apresentar estritamente o que foi solicitado, qualquer texto, espaço ou quebra de linha a mais (ou a menos) resultará em uma mensagem de erro.<br />
<br />
Os intervalos dos dados de entrada e saída, definidos no enunciado de um problema, servem para que as variáveis sejam corretamente dimensionadas. Esses intervalos não precisam ser testados, os valores de entrada dos conjuntos de teste estarão de acordo com essa especificação.<br />
<br />
== Por que o URI não aceita minha solução? ==<br />
<br />
Dentre os erros mais comuns, baseado nos problemas “Iniciante” estão:<br />
<br />
=== Wrong Answer (Resposta errada) ===<br />
<br />
<li> Impressão de mensagens fora da especificação (pedir entrada, sem o formato do exemplo) </li><br />
<br />
<pre><br />
cout << “Digite a distância: ”;<br />
</pre><br />
<br />
<li> Cálculo incorreto, cálculo sem precisão. No enunciado, é explicitado o tipo (e intervalo) dos dados de entrada e de saída. Um problema frequente é a precisão, pois alguns valores são muito maiores do que os exemplos do enunciado. Se o seu problema estiver tendo um percentual baixo de Wrong Answer (20% ou menos), tente aumentar a capacidade das variáveis (de int para long int, de float para double). </li><br />
<br />
<li> Sinal de igualdade para atribuição (expressão lógica com sintaxe incorreta) </li><br />
<br />
Código errado:<br />
<pre><br />
if(i = 0){<br />
//trecho de código<br />
}<br />
</pre><br />
<br />
Código certo:<br />
<pre><br />
if(i == 0){<br />
//trecho de código<br />
}<br />
</pre><br />
<br />
<li> Condição incorreta (atribuição e não igualdade, várias condições separadas por vírgula) ou estrutura de seleção mal escrita (vários if's sem operador lógico) </li><br />
<br />
//TABELA<br />
<br />
=== Presentation error ===<br />
<br />
Formatação dos dados de saída<br />
<br />
<li>Falta de quebrar linha no final da apresentação</li><br />
Exemplo:<br />
Código errado<br />
<br />
<pre><br />
//Em C<br />
printf("Olá");<br />
//Em C++<br />
cout << "Olá";<br />
//Em Python<br />
print('Olá'); <br />
</pre><br />
Código certo<br />
<pre><br />
//Em C<br />
printf("Olá\n");<br />
//Em C++<br />
cout << "Olá" << endl;<br />
//Em Python<br />
print('Olá\n');<br />
</pre><br />
<br />
<li>Falta de espaço</li><br />
<br />
//TABELA<br />
<br />
<br />
=== Compilation error ===</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Erros_Comuns&diff=16295Erros Comuns2020-07-30T17:36:08Z<p>Maprestes: </p>
<hr />
<div><br />
Nesse tópico abordaremos quais são os erros mais comuns que os estudantes podem estar cometendo na hora de escrever seu código e enviar para a avaliação. Então se estiver tendo algum problema em uma dessas duas etapas talvez esse tópico possa te ajudar!<br />
<br />
== Observações gerais ==<br />
<br />
A saída deve apresentar estritamente o que foi solicitado, qualquer texto, espaço ou quebra de linha a mais (ou a menos) resultará em uma mensagem de erro.<br />
<br />
Os intervalos dos dados de entrada e saída, definidos no enunciado de um problema, servem para que as variáveis sejam corretamente dimensionadas. Esses intervalos não precisam ser testados, os valores de entrada dos conjuntos de teste estarão de acordo com essa especificação.<br />
<br />
== Por que o URI não aceita minha solução? ==<br />
<br />
Dentre os erros mais comuns, baseado nos problemas “Iniciante” estão:<br />
<br />
=== Wrong Answer (Resposta errada) ===<br />
<br />
<li> Impressão de mensagens fora da especificação (pedir entrada, sem o formato do exemplo) </li><br />
<br />
<pre><br />
cout << “Digite a distância: ”;<br />
</pre><br />
<br />
<li> Cálculo incorreto, cálculo sem precisão. No enunciado, é explicitado o tipo (e intervalo) dos dados de entrada e de saída. Um problema frequente é a precisão, pois alguns valores são muito maiores do que os exemplos do enunciado. Se o seu problema estiver tendo um percentual baixo de Wrong Answer (20% ou menos), tente aumentar a capacidade das variáveis (de int para long int, de float para double). </li><br />
<br />
<li> Sinal de igualdade para atribuição (expressão lógica com sintaxe incorreta) </li><br />
<br />
Código errado:<br />
<pre><br />
if(i = 0){<br />
//trecho de código<br />
}<br />
</pre><br />
<br />
Código certo:<br />
<pre><br />
if(i == 0){<br />
//trecho de código<br />
}<br />
</pre><br />
<br />
<li> Condição incorreta (atribuição e não igualdade, várias condições separadas por vírgula) ou estrutura de seleção mal escrita (vários if's sem operador lógico) </li></div>Mapresteshttps://wiki.unicentro.br/index.php?title=Erros_Comuns&diff=16294Erros Comuns2020-07-28T22:33:58Z<p>Maprestes: </p>
<hr />
<div>=== Erros mais comuns ===<br />
<br />
Nesse tópico abordaremos quais são os erros mais comuns que os estudantes podem estar cometendo na hora de escrever seu código e enviar para a avaliação. Então se estiver tendo algum problema em uma dessas duas etapas talvez esse tópico possa te ajudar!<br />
<br />
== Observações gerais ==<br />
<br />
A saída deve apresentar estritamente o que foi solicitado, qualquer texto, espaço ou quebra de linha a mais (ou a menos) resultará em uma mensagem de erro.<br />
<br />
Os intervalos dos dados de entrada e saída, definidos no enunciado de um problema, servem para que as variáveis sejam corretamente dimensionadas. Esses intervalos não precisam ser testados, os valores de entrada dos conjuntos de teste estarão de acordo com essa especificação.<br />
<br />
== Por que o URI não aceita minha solução? ==<br />
<br />
Dentre os erros mais comuns, baseado nos problemas “Iniciante” estão:<br />
<br />
=== Wrong Answer (Resposta errada) ===<br />
<br />
<li> Impressão de mensagens fora da especificação (pedir entrada, sem o formato do exemplo) </li><br />
<br />
<pre><br />
cout << “Digite a distância: ”;<br />
</pre><br />
<br />
<li> Cálculo incorreto, cálculo sem precisão. No enunciado, é explicitado o tipo (e intervalo) dos dados de entrada e de saída. Um problema frequente é a precisão, pois alguns valores são muito maiores do que os exemplos do enunciado. Se o seu problema estiver tendo um percentual baixo de Wrong Answer (20% ou menos), tente aumentar a capacidade das variáveis (de int para long int, de float para double). </li><br />
<br />
<li> Sinal de igualdade para atribuição (expressão lógica com sintaxe incorreta) </li><br />
<br />
Código errado:<br />
<pre><br />
if(i = 0){<br />
//trecho de código<br />
}<br />
</pre><br />
<br />
Código certo:<br />
<pre><br />
if(i == 0){<br />
//trecho de código<br />
}<br />
</pre><br />
<br />
<li> Condição incorreta (atribuição e não igualdade, várias condições separadas por vírgula) ou estrutura de seleção mal escrita (vários if's sem operador lógico) </li></div>Mapresteshttps://wiki.unicentro.br/index.php?title=Erros_Comuns&diff=16293Erros Comuns2020-07-28T22:29:59Z<p>Maprestes: </p>
<hr />
<div>=== Erros mais comuns ===<br />
<br />
Nesse tópico abordaremos quais são os erros mais comuns que os estudantes podem estar cometendo na hora de escrever seu código e enviar para a avaliação. Então se estiver tendo algum problema em uma dessas duas etapas talvez esse tópico possa te ajudar!<br />
<br />
== Observações gerais ==<br />
<br />
A saída deve apresentar estritamente o que foi solicitado, qualquer texto, espaço ou quebra de linha a mais (ou a menos) resultará em uma mensagem de erro.<br />
<br />
Os intervalos dos dados de entrada e saída, definidos no enunciado de um problema, servem para que as variáveis sejam corretamente dimensionadas. Esses intervalos não precisam ser testados, os valores de entrada dos conjuntos de teste estarão de acordo com essa especificação.<br />
<br />
== Por que o URI não aceita minha solução? ==<br />
<br />
Dentre os erros mais comuns, baseado nos problemas “Iniciante” estão:<br />
<br />
=== Wrong Answer (Resposta errada) ===<br />
<br />
<li> Impressão de mensagens fora da especificação (pedir entrada, sem o formato do exemplo) </li><br />
<br />
<br />
<br />
<pre><br />
cout << “Digite a distância: ”;<br />
</pre><br />
<br />
- Cálculo incorreto, cálculo sem precisão. No enunciado, é explicitado o tipo (e intervalo) dos dados de entrada e de saída. Um problema frequente é a precisão, pois alguns valores são muito maiores do que os exemplos do enunciado. Se o seu problema estiver tendo um percentual baixo de Wrong Answer (20% ou menos), tente aumentar a capacidade das variáveis (de int para long int, de float para double).<br />
<br />
- Sinal de igualdade para atribuição (expressão lógica com sintaxe incorreta)<br />
<br />
- Condição incorreta (atribuição e não igualdade, várias condições separadas por vírgula) ou estrutura de seleção mal escrita (vários ifs sem operador lógico)</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Erros_Comuns&diff=16292Erros Comuns2020-07-28T22:29:39Z<p>Maprestes: </p>
<hr />
<div>=== Erros mais comuns ===<br />
<br />
Nesse tópico abordaremos quais são os erros mais comuns que os estudantes podem estar cometendo na hora de escrever seu código e enviar para a avaliação. Então se estiver tendo algum problema em uma dessas duas etapas talvez esse tópico possa te ajudar!<br />
<br />
== Observações gerais ==<br />
<br />
A saída deve apresentar estritamente o que foi solicitado, qualquer texto, espaço ou quebra de linha a mais (ou a menos) resultará em uma mensagem de erro.<br />
<br />
Os intervalos dos dados de entrada e saída, definidos no enunciado de um problema, servem para que as variáveis sejam corretamente dimensionadas. Esses intervalos não precisam ser testados, os valores de entrada dos conjuntos de teste estarão de acordo com essa especificação.<br />
<br />
== Por que o URI não aceita minha solução? ==<br />
<br />
Dentre os erros mais comuns, baseado nos problemas “Iniciante” estão:<br />
<br />
<ul>=== Wrong Answer (Resposta errada) ===<br />
<br />
<li> Impressão de mensagens fora da especificação (pedir entrada, sem o formato do exemplo) </li><br />
<br />
<ul><br />
<br />
<pre><br />
cout << “Digite a distância: ”;<br />
</pre><br />
<br />
- Cálculo incorreto, cálculo sem precisão. No enunciado, é explicitado o tipo (e intervalo) dos dados de entrada e de saída. Um problema frequente é a precisão, pois alguns valores são muito maiores do que os exemplos do enunciado. Se o seu problema estiver tendo um percentual baixo de Wrong Answer (20% ou menos), tente aumentar a capacidade das variáveis (de int para long int, de float para double).<br />
<br />
- Sinal de igualdade para atribuição (expressão lógica com sintaxe incorreta)<br />
<br />
- Condição incorreta (atribuição e não igualdade, várias condições separadas por vírgula) ou estrutura de seleção mal escrita (vários ifs sem operador lógico)</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Erros_Comuns&diff=16291Erros Comuns2020-07-28T22:26:00Z<p>Maprestes: Criou página com '=== Erros mais comuns === Nesse tópico abordaremos quais são os erros mais comuns que os estudantes podem estar cometendo na hora de escrever seu código e enviar para a av...'</p>
<hr />
<div>=== Erros mais comuns ===<br />
<br />
Nesse tópico abordaremos quais são os erros mais comuns que os estudantes podem estar cometendo na hora de escrever seu código e enviar para a avaliação. Então se estiver tendo algum problema em uma dessas duas etapas talvez esse tópico possa te ajudar!<br />
<br />
== Observações gerais ==<br />
<br />
A saída deve apresentar estritamente o que foi solicitado, qualquer texto, espaço ou quebra de linha a mais (ou a menos) resultará em uma mensagem de erro.<br />
<br />
Os intervalos dos dados de entrada e saída, definidos no enunciado de um problema, servem para que as variáveis sejam corretamente dimensionadas. Esses intervalos não precisam ser testados, os valores de entrada dos conjuntos de teste estarão de acordo com essa especificação.<br />
<br />
== Por que o URI não aceita minha solução? ==<br />
<br />
Dentre os erros mais comuns, baseado nos problemas “Iniciante” estão:<br />
<br />
=== Wrong Answer (Resposta errada) ===<br />
<br />
- Impressão de mensagens fora da especificação (pedir entrada, sem o formato do exemplo)<br />
<br />
<pre><br />
cout << “Digite a distância: ”;<br />
</pre><br />
<br />
- Cálculo incorreto, cálculo sem precisão. No enunciado, é explicitado o tipo (e intervalo) dos dados de entrada e de saída. Um problema frequente é a precisão, pois alguns valores são muito maiores do que os exemplos do enunciado. Se o seu problema estiver tendo um percentual baixo de Wrong Answer (20% ou menos), tente aumentar a capacidade das variáveis (de int para long int, de float para double).<br />
<br />
- Sinal de igualdade para atribuição (expressão lógica com sintaxe incorreta)<br />
<br />
- Condição incorreta (atribuição e não igualdade, várias condições separadas por vírgula) ou estrutura de seleção mal escrita (vários ifs sem operador lógico)</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Sistemas_autom%C3%A1ticos_de_avalia%C3%A7%C3%A3o&diff=16290Sistemas automáticos de avaliação2020-07-28T22:23:04Z<p>Maprestes: </p>
<hr />
<div>== Sistemas automáticos de avaliação ==<br />
<br />
Durante esse projeto haverá diversas atividades sugeridas para fixar e colocar em prática os conteúdos aqui estudados. Tanto para a leitura quanto para a avaliação da resolução das atividades serão utilizado dois sites: o [https://www.urionlinejudge.com.br/ Uri] e o site da [https://olimpiada.ic.unicamp.br/ OBI]<br />
<br />
<br />
==[https://www.urionlinejudge.com.br/ Uri]==<br />
A URI Online Judge é um projeto desenvolvido pelo departamento de ciência da computação da universidade URI. Esse portal apresenta um repositório com diversos problemas com diversos níveis de dificuldades para serem resolvidos por meio da programação.<br />
<br />
Antes de iniciar as atividades, é necessário se cadastrar no site.<br />
<br />
=== Anatomia de um problema URI ===<br />
[[Arquivo: Uri_anatomia.png ]]<br />
<br />
====1 - Numero====<br />
Esse numero é o numero referente ao problema, é ele quem identifica qual é o problema na hora de enviar a resolução para avaliação. Você também consegue acessar a pagina referente ao problema com esse numero nesse formato.<br />
<pre><br />
https://www.urionlinejudge.com.br/judge/pt/problems/view/NUMERO/<br />
</pre><br />
Por exemplo:<br />
<pre><br />
//Pagina da URI referente ao problema "Soma Simples - 1003"<br />
https://www.urionlinejudge.com.br/judge/pt/problems/view/1003/<br />
</pre><br />
<br />
==== 2 - Nome ====<br />
Essa área é reservada ao nome do problema.<br />
<br />
==== 3 - Autor ====<br />
Esse área é reservada aos dados de quem postou o problema.<br />
<br />
==== 4 - Tempo Limite====<br />
<br />
Ao realizar a correção do seu código, o próprio sistema irá inserir os dados e analisar os resultados obtidos. Por mais que seu código responda corretamente, os problemas tem um "tempo limite" de execução, então se seu código processar e responder mais lentamente que o limite estabelecido no problema o código será considerado incorreto.<br />
Porem esse não é um problema que quem está iniciando deve se preocupar, pois seu código raramente irá encontrar esse problema. <br />
<br />
==== 5 - Contexto ====<br />
<br />
Essa área é onde há a contextualização do problema, geralmente uma história ou explicação lúdica de pra que o seu sistema está sendo feito.<br />
<br />
==== 6 - Entrada ====<br />
<br />
Área responsável por explicar quais serão as entradas do seu programa, o tipo e o formato que seu código deve ler. Se o seu código não ler os dados como essa área indica o sistema não conseguirá inserir os dados corretamente, o que levará a falha na avaliação.<br />
São pouquíssimos os problemas que não exigem entradas.<br />
<br />
==== 7 - Saída ====<br />
<br />
Área responsável por explicar qual será a saída do seu programa e como deverá ser formatada. Por mais que seu sistema esteja processando os dados corretamente é preciso apresentar os dados *exatamente* como estão sendo definidos, com o exato numero de espaços e símbolos que estão sendo indicados. <br />
Lembre-se que quem está avaliando é um outro código, então se a saída do seu código não estiver formatado da forma que o problema pede o código avaliador não conseguirá entender.<br />
<br />
==== 8 - Exemplos ====<br />
<br />
Essa área é responsável por mostrar alguns exemplos de entradas e saídas referentes a aquelas entradas.<br />
Também funciona como um tira duvidas quanto a formatação da entrada e saída do programa<br />
<br />
<br />
==== Dicas ====<br />
<br />
A área de entrada (6) e saída (7) são as mais importantes e que mais necessitam de atenção pois são elas que descrevem a parte prática de como deve funcionar e o que seu código deve responder. Então preste o dobro de atenção nessas duas áreas.<br />
<br />
Um dos erros mais comuns é o "Presentation error" ou "Erro de apresentação", significa que o sistema de avaliação não entendeu as saídas do seu código, então sempre verifique se a saída do seu código está formatada como indicado. Se a formatação estiver correta e mesmo assim o sistema continuar indicando esse erro, se seu código quebra a linha depois de apresentar.<br />
Por exemplo:<br />
<br />
Códigos sem quebrar a linha.<br />
<br />
Pascal<br />
<pre><br />
write("um");<br />
write("dois");<br />
write("três");<br />
<br />
saída do código:<br />
umdoistrês<br />
</pre><br />
<br />
<pre><br />
<br />
printf("um");<br />
printf("dois");<br />
printf("três");<br />
<br />
saída do código:<br />
umdoistrês<br />
</pre><br />
<br />
Códigos quebrando a linha.<br />
<br />
Pascal<br />
<pre><br />
writeln("um");<br />
writeln("dois");<br />
writeln("três");<br />
<br />
saída do código:<br />
um<br />
dois<br />
três<br />
</pre><br />
<br />
<pre><br />
<br />
printf("um\n");<br />
printf("dois\n");<br />
printf("três\n");<br />
<br />
saída do código:<br />
um<br />
dois<br />
três<br />
</pre><br />
<br />
No caso do pascal a função "writeln" quebra a linha após apresentar a informação. Já na linguagem C usemos o "\n" após a informação dentro da função. Verifique qual a melhor forma de fazer isso na sua linguagem escolhida.<br />
<br />
<br />
=== Enviando o código para avaliação ===<br />
<br />
No site da URI, logo ao lado da apresentação do problema, existe uma area para enviar seu código para a avaliação.<br />
<br />
[[Arquivo: Uri_envio.png ]]<br />
<br />
==== 1 - Identificação ====<br />
Nesse campo há a identificação do problema que o código solucionará.<br />
<br />
==== 2 - Linguagem ====<br />
Nesse campo você deve selecionar em qual linguagem você escreveu o código que irá enviar para analise.<br />
<br />
==== 3 - Código ====<br />
Aqui você deve colar o código que escreveu para resolver o problema, incluindo as bibliotecas utilizadas.<br />
Não é recomendado escrever o código diretamente nessa área pois você pode perde-lo. Recomenda-se um editor onde você pode salvar e testar os seus códigos antes de enviar.<br />
<br />
==== 4 - Enviar ====<br />
Após as etapas acima é só enviar e verificar o resultado do teste.</div>Mapresteshttps://wiki.unicentro.br/index.php?title=TL_PC&diff=16289TL PC2020-07-28T21:59:16Z<p>Maprestes: /* Conteúdos */</p>
<hr />
<div>[[Arquivo: Treinamento_Logo_Desc.png|700px||right| <br />
<br />
<font size="2"><br />
<br />
</font><br />
<br />
]]<br />
<br />
<br />
== O Projeto ==<br />
<br />
<br />
<br />
<br><br />
O enfoque do projeto é proporcionar treinamento para alunos do ensino técnico que possuem maior interesse em programação, sobretudo, que participam da [https://olimpiada.ic.unicamp.br Olimpíada Brasileira de Informática (OBI)].<br />
<br />
<br />
== Sobre a Olimpíada Brasileira de Informática ==<br />
<br />
O objetivo da [https://olimpiada.ic.unicamp.br Olimpíada Brasileira de Informática (OBI)] é despertar nos alunos o interesse por uma ciência importante na formação básica hoje em dia (no caso, ciência da computação), através de uma atividade que envolve desafio, engenhosidade e uma saudável dose de competição. A organização da OBI está cargo do Instituto de Computação da UNICAMP.<br />
<br />
[[Olimpíada_Brasileira_de_Informática| Leia mais.]]<br />
<br />
<br><br />
<br />
== Conteúdos ==<br />
<br />
* [[Formato_dos_problemas| Formato dos problemas ]] <br />
<br />
* [[Sistemas_automáticos_de_avaliação| Sistemas automáticos de avaliação ]] <br />
<br />
* [[Erros_Comuns| Erros comuns ]] <br />
<br />
* [[Entrada_e_saída_de_dados| Entrada/Saída de Dados]]<br />
<br />
* [[Operadores_Logicos| Operadores Lógicos]]<br />
<br />
* [[Estruturas_de_Seleção| Estruturas de Seleção]]<br />
<br />
* [[Estruturas_de_Repetição| Estruturas de Repetição]]<br />
<br />
* [[Vetores| Vetores]]<br />
<br />
<br><br />
<br />
== Equipe de execução ==<br />
<br />
'''Coordenação:'''<br />
* Ana Elisa T. P. da Palma<br />
* Mauro Miazaki<br />
<br />
'''Monitores:'''<br />
* Alexandro Luis da Rocha Junior<br />
* Erick Ascencio da Silva<br />
* Moises Alonso Prestes</div>Mapresteshttps://wiki.unicentro.br/index.php?title=TL_PC&diff=16288TL PC2020-07-28T21:58:57Z<p>Maprestes: /* Conteúdos */</p>
<hr />
<div>[[Arquivo: Treinamento_Logo_Desc.png|700px||right| <br />
<br />
<font size="2"><br />
<br />
</font><br />
<br />
]]<br />
<br />
<br />
== O Projeto ==<br />
<br />
<br />
<br />
<br><br />
O enfoque do projeto é proporcionar treinamento para alunos do ensino técnico que possuem maior interesse em programação, sobretudo, que participam da [https://olimpiada.ic.unicamp.br Olimpíada Brasileira de Informática (OBI)].<br />
<br />
<br />
== Sobre a Olimpíada Brasileira de Informática ==<br />
<br />
O objetivo da [https://olimpiada.ic.unicamp.br Olimpíada Brasileira de Informática (OBI)] é despertar nos alunos o interesse por uma ciência importante na formação básica hoje em dia (no caso, ciência da computação), através de uma atividade que envolve desafio, engenhosidade e uma saudável dose de competição. A organização da OBI está cargo do Instituto de Computação da UNICAMP.<br />
<br />
[[Olimpíada_Brasileira_de_Informática| Leia mais.]]<br />
<br />
<br><br />
<br />
== Conteúdos ==<br />
<br />
* [[Formato_dos_problemas| Formato dos problemas ]] <br />
<br />
* [[Sistemas_automáticos_de_avaliação| Sistemas automáticos de avaliação ]] <br />
<br />
* [[Erros_Mais_Comuns| Erros mas comuns ]] <br />
<br />
* [[Entrada_e_saída_de_dados| Entrada/Saída de Dados]]<br />
<br />
* [[Operadores_Logicos| Operadores Lógicos]]<br />
<br />
* [[Estruturas_de_Seleção| Estruturas de Seleção]]<br />
<br />
* [[Estruturas_de_Repetição| Estruturas de Repetição]]<br />
<br />
* [[Vetores| Vetores]]<br />
<br />
<br><br />
<br />
== Equipe de execução ==<br />
<br />
'''Coordenação:'''<br />
* Ana Elisa T. P. da Palma<br />
* Mauro Miazaki<br />
<br />
'''Monitores:'''<br />
* Alexandro Luis da Rocha Junior<br />
* Erick Ascencio da Silva<br />
* Moises Alonso Prestes</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Sistemas_autom%C3%A1ticos_de_avalia%C3%A7%C3%A3o&diff=16287Sistemas automáticos de avaliação2020-06-29T16:50:05Z<p>Maprestes: </p>
<hr />
<div>=== Sistemas automáticos de avaliação ===<br />
<br />
Durante esse projeto haverá diversas atividades sugeridas para fixar e colocar em prática os conteúdos aqui estudados. Tanto para a leitura quanto para a avaliação da resolução das atividades serão utilizado dois sites: o [https://www.urionlinejudge.com.br/ Uri] e o site da [https://olimpiada.ic.unicamp.br/ OBI]<br />
<br />
<br />
==[https://www.urionlinejudge.com.br/ Uri]==<br />
A URI Online Judge é um projeto desenvolvido pelo departamento de ciência da computação da universidade URI. Esse portal apresenta um repositório com diversos problemas com diversos níveis de dificuldades para serem resolvidos por meio da programação.<br />
<br />
Antes de iniciar as atividades, é necessário se cadastrar no site.<br />
<br />
=== Anatomia de um problema URI ===<br />
[[Arquivo: Uri_anatomia.png ]]<br />
<br />
====1 - Numero====<br />
Esse numero é o numero referente ao problema, é ele quem identifica qual é o problema na hora de enviar a resolução para avaliação. Você também consegue acessar a pagina referente ao problema com esse numero nesse formato.<br />
<pre><br />
https://www.urionlinejudge.com.br/judge/pt/problems/view/NUMERO/<br />
</pre><br />
Por exemplo:<br />
<pre><br />
//Pagina da URI referente ao problema "Soma Simples - 1003"<br />
https://www.urionlinejudge.com.br/judge/pt/problems/view/1003/<br />
</pre><br />
<br />
==== 2 - Nome ====<br />
Essa área é reservada ao nome do problema.<br />
<br />
==== 3 - Autor ====<br />
Esse área é reservada aos dados de quem postou o problema.<br />
<br />
==== 4 - Tempo Limite====<br />
<br />
Ao realizar a correção do seu código, o próprio sistema irá inserir os dados e analisar os resultados obtidos. Por mais que seu código responda corretamente, os problemas tem um "tempo limite" de execução, então se seu código processar e responder mais lentamente que o limite estabelecido no problema o código será considerado incorreto.<br />
Porem esse não é um problema que quem está iniciando deve se preocupar, pois seu código raramente irá encontrar esse problema. <br />
<br />
==== 5 - Contexto ====<br />
<br />
Essa área é onde há a contextualização do problema, geralmente uma história ou explicação lúdica de pra que o seu sistema está sendo feito.<br />
<br />
==== 6 - Entrada ====<br />
<br />
Área responsável por explicar quais serão as entradas do seu programa, o tipo e o formato que seu código deve ler. Se o seu código não ler os dados como essa área indica o sistema não conseguirá inserir os dados corretamente, o que levará a falha na avaliação.<br />
São pouquíssimos os problemas que não exigem entradas.<br />
<br />
==== 7 - Saída ====<br />
<br />
Área responsável por explicar qual será a saída do seu programa e como deverá ser formatada. Por mais que seu sistema esteja processando os dados corretamente é preciso apresentar os dados *exatamente* como estão sendo definidos, com o exato numero de espaços e símbolos que estão sendo indicados. <br />
Lembre-se que quem está avaliando é um outro código, então se a saída do seu código não estiver formatado da forma que o problema pede o código avaliador não conseguirá entender.<br />
<br />
==== 8 - Exemplos ====<br />
<br />
Essa área é responsável por mostrar alguns exemplos de entradas e saídas referentes a aquelas entradas.<br />
Também funciona como um tira duvidas quanto a formatação da entrada e saída do programa<br />
<br />
<br />
==== Dicas ====<br />
<br />
A área de entrada (6) e saída (7) são as mais importantes e que mais necessitam de atenção pois são elas que descrevem a parte prática de como deve funcionar e o que seu código deve responder. Então preste o dobro de atenção nessas duas áreas.<br />
<br />
Um dos erros mais comuns é o "Presentation error" ou "Erro de apresentação", significa que o sistema de avaliação não entendeu as saídas do seu código, então sempre verifique se a saída do seu código está formatada como indicado. Se a formatação estiver correta e mesmo assim o sistema continuar indicando esse erro, se seu código quebra a linha depois de apresentar.<br />
Por exemplo:<br />
<br />
Códigos sem quebrar a linha.<br />
<br />
Pascal<br />
<pre><br />
write("um");<br />
write("dois");<br />
write("três");<br />
<br />
saída do código:<br />
umdoistrês<br />
</pre><br />
<br />
<pre><br />
<br />
printf("um");<br />
printf("dois");<br />
printf("três");<br />
<br />
saída do código:<br />
umdoistrês<br />
</pre><br />
<br />
Códigos quebrando a linha.<br />
<br />
Pascal<br />
<pre><br />
writeln("um");<br />
writeln("dois");<br />
writeln("três");<br />
<br />
saída do código:<br />
um<br />
dois<br />
três<br />
</pre><br />
<br />
<pre><br />
<br />
printf("um\n");<br />
printf("dois\n");<br />
printf("três\n");<br />
<br />
saída do código:<br />
um<br />
dois<br />
três<br />
</pre><br />
<br />
No caso do pascal a função "writeln" quebra a linha após apresentar a informação. Já na linguagem C usemos o "\n" após a informação dentro da função. Verifique qual a melhor forma de fazer isso na sua linguagem escolhida.<br />
<br />
<br />
=== Enviando o código para avaliação ===<br />
<br />
No site da URI, logo ao lado da apresentação do problema, existe uma area para enviar seu código para a avaliação.<br />
<br />
[[Arquivo: Uri_envio.png ]]<br />
<br />
==== 1 - Identificação ====<br />
Nesse campo há a identificação do problema que o código solucionará.<br />
<br />
==== 2 - Linguagem ====<br />
Nesse campo você deve selecionar em qual linguagem você escreveu o código que irá enviar para analise.<br />
<br />
==== 3 - Código ====<br />
Aqui você deve colar o código que escreveu para resolver o problema, incluindo as bibliotecas utilizadas.<br />
Não é recomendado escrever o código diretamente nessa área pois você pode perde-lo. Recomenda-se um editor onde você pode salvar e testar os seus códigos antes de enviar.<br />
<br />
==== 4 - Enviar ====<br />
Após as etapas acima é só enviar e verificar o resultado do teste.</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Arquivo:Uri_envio.png&diff=16286Arquivo:Uri envio.png2020-06-29T16:35:20Z<p>Maprestes: </p>
<hr />
<div></div>Mapresteshttps://wiki.unicentro.br/index.php?title=Sistemas_autom%C3%A1ticos_de_avalia%C3%A7%C3%A3o&diff=16285Sistemas automáticos de avaliação2020-06-29T16:33:18Z<p>Maprestes: </p>
<hr />
<div>=== Sistemas automáticos de avaliação ===<br />
<br />
Durante esse projeto haverá diversas atividades sugeridas para fixar e colocar em prática os conteúdos aqui estudados. Tanto para a leitura quanto para a avaliação da resolução das atividades serão utilizado dois sites: o [https://www.urionlinejudge.com.br/ Uri] e o site da [https://olimpiada.ic.unicamp.br/ OBI]<br />
<br />
<br />
==[https://www.urionlinejudge.com.br/ Uri]==<br />
A URI Online Judge é um projeto desenvolvido pelo departamento de ciência da computação da universidade URI. Esse portal apresenta um repositório com diversos problemas com diversos níveis de dificuldades para serem resolvidos por meio da programação.<br />
<br />
=== Anatomia de um problema URI ===<br />
[[Arquivo: Uri_anatomia.png ]]<br />
<br />
====1 - Numero====<br />
Esse numero é o numero referente ao problema, é ele quem identifica qual é o problema na hora de enviar a resolução para avaliação. Você também consegue acessar a pagina referente ao problema com esse numero nesse formato.<br />
<pre><br />
https://www.urionlinejudge.com.br/judge/pt/problems/view/NUMERO/<br />
</pre><br />
Por exemplo:<br />
<pre><br />
//Pagina da URI referente ao problema "Soma Simples - 1003"<br />
https://www.urionlinejudge.com.br/judge/pt/problems/view/1003/<br />
</pre><br />
<br />
==== 2 - Nome ====<br />
Essa área é reservada ao nome do problema.<br />
<br />
==== 3 - Autor ====<br />
Esse área é reservada aos dados de quem postou o problema.<br />
<br />
==== 4 - Tempo Limite====<br />
<br />
Ao realizar a correção do seu código, o próprio sistema irá inserir os dados e analisar os resultados obtidos. Por mais que seu código responda corretamente, os problemas tem um "tempo limite" de execução, então se seu código processar e responder mais lentamente que o limite estabelecido no problema o código será considerado incorreto.<br />
Porem esse não é um problema que quem está iniciando deve se preocupar, pois seu código raramente irá encontrar esse problema. <br />
<br />
==== 5 - Contexto ====<br />
<br />
Essa área é onde há a contextualização do problema, geralmente uma história ou explicação lúdica de pra que o seu sistema está sendo feito.<br />
<br />
==== 6 - Entrada ====<br />
<br />
Área responsável por explicar quais serão as entradas do seu programa, o tipo e o formato que seu código deve ler. Se o seu código não ler os dados como essa área indica o sistema não conseguirá inserir os dados corretamente, o que levará a falha na avaliação.<br />
São pouquíssimos os problemas que não exigem entradas.<br />
<br />
==== 7 - Saída ====<br />
<br />
Área responsável por explicar qual será a saída do seu programa e como deverá ser formatada. Por mais que seu sistema esteja processando os dados corretamente é preciso apresentar os dados *exatamente* como estão sendo definidos, com o exato numero de espaços e símbolos que estão sendo indicados. <br />
Lembre-se que quem está avaliando é um outro código, então se a saída do seu código não estiver formatado da forma que o problema pede o código avaliador não conseguirá entender.<br />
<br />
==== 8 - Exemplos ====<br />
<br />
Essa área é responsável por mostrar alguns exemplos de entradas e saídas referentes a aquelas entradas.<br />
Também funciona como um tira duvidas quanto a formatação da entrada e saída do programa<br />
<br />
<br />
==== Dicas ====<br />
<br />
A área de entrada (6) e saída (7) são as mais importantes e que mais necessitam de atenção pois são elas que descrevem a parte prática de como deve funcionar e o que seu código deve responder. Então preste o dobro de atenção nessas duas áreas.<br />
<br />
Um dos erros mais comuns é o "Presentation error" ou "Erro de apresentação", significa que o sistema de avaliação não entendeu as saídas do seu código, então sempre verifique se a saída do seu código está formatada como indicado. Se a formatação estiver correta e mesmo assim o sistema continuar indicando esse erro, se seu código quebra a linha depois de apresentar.<br />
Por exemplo:<br />
<br />
Códigos sem quebrar a linha.<br />
<br />
Pascal<br />
<pre><br />
write("um");<br />
write("dois");<br />
write("três");<br />
<br />
saída do código:<br />
umdoistrês<br />
</pre><br />
<br />
<pre><br />
<br />
printf("um");<br />
printf("dois");<br />
printf("três");<br />
<br />
saída do código:<br />
umdoistrês<br />
</pre><br />
<br />
Códigos quebrando a linha.<br />
<br />
Pascal<br />
<pre><br />
writeln("um");<br />
writeln("dois");<br />
writeln("três");<br />
<br />
saída do código:<br />
um<br />
dois<br />
três<br />
</pre><br />
<br />
<pre><br />
<br />
printf("um\n");<br />
printf("dois\n");<br />
printf("três\n");<br />
<br />
saída do código:<br />
um<br />
dois<br />
três<br />
</pre><br />
<br />
No caso do pascal a função "writeln" quebra a linha após apresentar a informação. Já na linguagem C usemos o "\n" após a informação dentro da função. Verifique qual a melhor forma de fazer isso na sua linguagem escolhida.<br />
<br />
<br />
=== Enviando o código para avaliação ===<br />
<br />
No site da URI, logo ao lado da apresentação do problema, existe uma area para enviar seu código para a avaliação.</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Sistemas_autom%C3%A1ticos_de_avalia%C3%A7%C3%A3o&diff=16284Sistemas automáticos de avaliação2020-06-29T16:24:12Z<p>Maprestes: </p>
<hr />
<div>=== Sistemas automáticos de avaliação ===<br />
<br />
Durante esse projeto haverá diversas atividades sugeridas para fixar e colocar em prática os conteúdos aqui estudados. Tanto para a leitura quanto para a avaliação da resolução das atividades serão utilizado dois sites: o [https://www.urionlinejudge.com.br/ Uri] e o site da [https://olimpiada.ic.unicamp.br/ OBI]<br />
<br />
<br />
==[https://www.urionlinejudge.com.br/ Uri]==<br />
A URI Online Judge é um projeto desenvolvido pelo departamento de ciência da computação da universidade URI. Esse portal apresenta um repositório com diversos problemas com diversos níveis de dificuldades para serem resolvidos por meio da programação.<br />
<br />
=== Anatomia de um problema URI ===<br />
[[Arquivo: Uri_anatomia.png ]]<br />
<br />
====1 - Numero====<br />
Esse numero é o numero referente ao problema, é ele quem identifica qual é o problema na hora de enviar a resolução para avaliação. Você também consegue acessar a pagina referente ao problema com esse numero nesse formato.<br />
<pre><br />
https://www.urionlinejudge.com.br/judge/pt/problems/view/NUMERO/<br />
</pre><br />
Por exemplo:<br />
<pre><br />
//Pagina da URI referente ao problema "Soma Simples - 1003"<br />
https://www.urionlinejudge.com.br/judge/pt/problems/view/1003/<br />
</pre><br />
<br />
==== 2 - Nome ====<br />
Essa área é reservada ao nome do problema.<br />
<br />
==== 3 - Autor ====<br />
Esse área é reservada aos dados de quem postou o problema.<br />
<br />
==== 4 - Tempo Limite====<br />
<br />
Ao realizar a correção do seu código, o próprio sistema irá inserir os dados e analisar os resultados obtidos. Por mais que seu código responda corretamente, os problemas tem um "tempo limite" de execução, então se seu código processar e responder mais lentamente que o limite estabelecido no problema o código será considerado incorreto.<br />
Porem esse não é um problema que quem está iniciando deve se preocupar, pois seu código raramente irá encontrar esse problema. <br />
<br />
==== 5 - Contexto ====<br />
<br />
Essa área é onde há a contextualização do problema, geralmente uma história ou explicação lúdica de pra que o seu sistema está sendo feito.<br />
<br />
==== 6 - Entrada ====<br />
<br />
Área responsável por explicar quais serão as entradas do seu programa, o tipo e o formato que seu código deve ler. Se o seu código não ler os dados como essa área indica o sistema não conseguirá inserir os dados corretamente, o que levará a falha na avaliação.<br />
São pouquíssimos os problemas que não exigem entradas.<br />
<br />
==== 7 - Saída ====<br />
<br />
Área responsável por explicar qual será a saída do seu programa e como deverá ser formatada. Por mais que seu sistema esteja processando os dados corretamente é preciso apresentar os dados *exatamente* como estão sendo definidos, com o exato numero de espaços e símbolos que estão sendo indicados. <br />
Lembre-se que quem está avaliando é um outro código, então se a saída do seu código não estiver formatado da forma que o problema pede o código avaliador não conseguirá entender.<br />
<br />
==== 8 - Exemplos ====<br />
<br />
Essa área é responsável por mostrar alguns exemplos de entradas e saídas referentes a aquelas entradas.<br />
Também funciona como um tira duvidas quanto a formatação da entrada e saída do programa<br />
<br />
<br />
==== Dicas ====<br />
<br />
A área de entrada (6) e saída (7) são as mais importantes e que mais necessitam de atenção pois são elas que descrevem a parte prática de como deve funcionar e o que seu código deve responder. Então preste o dobro de atenção nessas duas áreas.<br />
<br />
Um dos erros mais comuns é o "Presentation error" ou "Erro de apresentação", significa que o sistema de avaliação não entendeu as saídas do seu código, então sempre verifique se a saída do seu código está formatada como indicado. Se a formatação estiver correta e mesmo assim o sistema continuar indicando esse erro, se seu código quebra a linha depois de apresentar.<br />
Por exemplo:<br />
<br />
Códigos sem quebrar a linha.<br />
<br />
Pascal<br />
<pre><br />
write("um");<br />
write("dois");<br />
write("três");<br />
<br />
saída do código:<br />
umdoistrês<br />
</pre><br />
<br />
<pre><br />
<br />
printf("um");<br />
printf("dois");<br />
printf("três");<br />
<br />
saída do código:<br />
umdoistrês<br />
</pre><br />
<br />
Códigos quebrando a linha.<br />
<br />
Pascal<br />
<pre><br />
writeln("um");<br />
writeln("dois");<br />
writeln("três");<br />
<br />
saída do código:<br />
um<br />
dois<br />
três<br />
</pre><br />
<br />
<pre><br />
<br />
printf("um\n");<br />
printf("dois\n");<br />
printf("três\n");<br />
<br />
saída do código:<br />
um<br />
dois<br />
três<br />
</pre><br />
<br />
No caso do pascal a função "writeln" quebra a linha após apresentar a informação. Já na linguagem C usemos o "\n" após a informação dentro da função. Verifique qual a melhor forma de fazer isso na sua linguagem escolhida.</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Sistemas_autom%C3%A1ticos_de_avalia%C3%A7%C3%A3o&diff=16283Sistemas automáticos de avaliação2020-06-29T15:48:18Z<p>Maprestes: </p>
<hr />
<div>=== Sistemas automáticos de avaliação ===<br />
<br />
Durante esse projeto haverá diversas atividades sugeridas para fixar e colocar em prática os conteúdos aqui estudados. Tanto para a leitura quanto para a avaliação da resolução das atividades serão utilizado dois sites: o [https://www.urionlinejudge.com.br/ Uri] e o site da [https://olimpiada.ic.unicamp.br/ OBI]<br />
<br />
<br />
==[https://www.urionlinejudge.com.br/ Uri]==<br />
A URI Online Judge é um projeto desenvolvido pelo departamento de ciência da computação da universidade URI. Esse portal apresenta um repositório com diversos problemas com diversos níveis de dificuldades para serem resolvidos por meio da programação.<br />
<br />
=== Anatomia de um problema URI ===<br />
[[Arquivo: Uri_anatomia.png ]]<br />
<br />
====1 - Numero====<br />
Esse numero é o numero referente ao problema, é ele quem identifica qual é o problema na hora de enviar a resolução para avaliação. Você também consegue acessar a pagina referente ao problema com esse numero nesse formato.<br />
<pre><br />
https://www.urionlinejudge.com.br/judge/pt/problems/view/NUMERO/<br />
</pre><br />
Por exemplo:<br />
<pre><br />
//Pagina da URI referente ao problema "Soma Simples - 1003"<br />
https://www.urionlinejudge.com.br/judge/pt/problems/view/1003/<br />
</pre><br />
<br />
==== 2 - Nome ====<br />
Essa área é reservada ao nome do problema.<br />
<br />
==== 3 - Autor ====<br />
Esse área é reservada aos dados de quem postou o problema.<br />
<br />
==== 4 - Tempo Limite====<br />
<br />
Ao realizar a correção do seu código, o próprio sistema irá inserir os dados e analisar os resultados obtidos. Por mais que seu código responda corretamente, os problemas tem um "tempo limite" de execução, então se seu código processar e responder mais lentamente que o limite estabelecido no problema o código será considerado incorreto.<br />
Porem esse não é um problema que quem está iniciando deve se preocupar, pois seu código raramente irá encontrar esse problema. <br />
<br />
==== 5 - Contexto ====<br />
<br />
Essa área é onde há a contextualização do problema, geralmente uma história ou explicação lúdica de pra que o seu sistema está sendo feito.<br />
<br />
==== 6 - Entrada ====<br />
<br />
Área responsável por explicar quais serão as entradas do seu programa, o tipo e o formato que seu código deve ler. Se o seu código não ler os dados como essa área indica o sistema não conseguirá inserir os dados corretamente, o que levará a falha na avaliação.<br />
São pouquíssimos os problemas que não exigem entradas.<br />
<br />
==== 7 - Saída ====<br />
<br />
Área responsável por explicar quais será a saída do seu programa,</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Sistemas_autom%C3%A1ticos_de_avalia%C3%A7%C3%A3o&diff=16282Sistemas automáticos de avaliação2020-06-29T15:30:59Z<p>Maprestes: </p>
<hr />
<div>=== Sistemas automáticos de avaliação ===<br />
<br />
Durante esse projeto haverá diversas atividades sugeridas para fixar e colocar em prática os conteúdos aqui estudados. Tanto para a leitura quanto para a avaliação da resolução das atividades serão utilizado dois sites: o [https://www.urionlinejudge.com.br/ Uri] e o site da [https://olimpiada.ic.unicamp.br/ OBI]<br />
<br />
<br />
==[https://www.urionlinejudge.com.br/ Uri]==<br />
A URI Online Judge é um projeto desenvolvido pelo departamento de ciência da computação da universidade URI. Esse portal apresenta um repositório com diversos problemas com diversos níveis de dificuldades para serem resolvidos por meio da programação.<br />
<br />
=== Anatomia de um problema URI ===<br />
[[Arquivo: Uri_anatomia.png ]]<br />
<br />
====1 - Numero====<br />
Esse numero é o numero referente ao problema, é ele quem identifica qual é o problema na hora de enviar a resolução para avaliação. Você também consegue acessar a pagina referente ao problema com esse numero nesse formato <br />
<pre><br />
https://www.urionlinejudge.com.br/judge/pt/problems/view/NUMERO/<br />
</pre><br />
Por exemplo:<br />
<pre><br />
//Pagina da URI referente ao problema "Soma Simples - 1003"<br />
https://www.urionlinejudge.com.br/judge/pt/problems/view/1003/<br />
</pre><br />
<br />
==== 2 -</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Sistemas_autom%C3%A1ticos_de_avalia%C3%A7%C3%A3o&diff=16281Sistemas automáticos de avaliação2020-06-29T15:26:31Z<p>Maprestes: </p>
<hr />
<div>=== Sistemas automáticos de avaliação ===<br />
<br />
Durante esse projeto haverá diversas atividades sugeridas para fixar e colocar em prática os conteúdos aqui estudados. Tanto para a leitura quanto para a avaliação da resolução das atividades serão utilizado dois sites: o [https://www.urionlinejudge.com.br/ Uri] e o site da [https://olimpiada.ic.unicamp.br/ OBI]<br />
<br />
<br />
==[https://www.urionlinejudge.com.br/ Uri]==<br />
A URI Online Judge é um projeto desenvolvido pelo departamento de ciência da computação da universidade URI. Esse portal apresenta um repositório com diversos problemas com diversos níveis de dificuldades para serem resolvidos por meio da programação.<br />
<br />
=== Anatomia de um problema URI ===<br />
[[Arquivo: Uri_anatomia.png ]]<br />
<br />
====1 - ====</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Sistemas_autom%C3%A1ticos_de_avalia%C3%A7%C3%A3o&diff=16280Sistemas automáticos de avaliação2020-06-29T15:25:49Z<p>Maprestes: </p>
<hr />
<div>=== Sistemas automáticos de avaliação ===<br />
<br />
Durante esse projeto haverá diversas atividades sugeridas para fixar e colocar em prática os conteúdos aqui estudados. Tanto para a leitura quanto para a avaliação da resolução das atividades serão utilizado dois sites: o [https://www.urionlinejudge.com.br/ Uri] e o site da [https://olimpiada.ic.unicamp.br/ OBI]<br />
<br />
<br />
==[https://www.urionlinejudge.com.br/ Uri]==<br />
A URI Online Judge é um projeto desenvolvido pelo departamento de ciência da computação da universidade URI. Esse portal apresenta um repositório com diversos problemas com diversos níveis de dificuldades para serem resolvidos por meio da programação.<br />
<br />
== Anatomia de um problema URI ==<br />
[[Arquivo: Uri_anatomia.png ]]<br />
<br />
=1 - =</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Sistemas_autom%C3%A1ticos_de_avalia%C3%A7%C3%A3o&diff=16279Sistemas automáticos de avaliação2020-06-29T15:25:15Z<p>Maprestes: </p>
<hr />
<div>=== Sistemas automáticos de avaliação ===<br />
<br />
Durante esse projeto haverá diversas atividades sugeridas para fixar e colocar em prática os conteúdos aqui estudados. Tanto para a leitura quanto para a avaliação da resolução das atividades serão utilizado dois sites: o [https://www.urionlinejudge.com.br/ Uri] e o site da [https://olimpiada.ic.unicamp.br/ OBI]<br />
<br />
<br />
==[https://www.urionlinejudge.com.br/ Uri]==<br />
[[Arquivo: Uri_anatomia.png ]]<br />
A URI Online Judge é um projeto desenvolvido pelo departamento de ciência da computação da universidade URI. Esse portal apresenta um repositório com diversos problemas com diversos níveis de dificuldades para serem resolvidos por meio da programação.<br />
<br />
== Anatomia de um problema URI ==</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Arquivo:Uri_anatomia.png&diff=16278Arquivo:Uri anatomia.png2020-06-29T15:24:10Z<p>Maprestes: </p>
<hr />
<div></div>Mapresteshttps://wiki.unicentro.br/index.php?title=Sistemas_autom%C3%A1ticos_de_avalia%C3%A7%C3%A3o&diff=16277Sistemas automáticos de avaliação2020-06-29T14:53:29Z<p>Maprestes: </p>
<hr />
<div>=== Sistemas automáticos de avaliação ===<br />
<br />
Durante esse projeto haverá diversas atividades sugeridas para fixar e colocar em prática os conteúdos aqui estudados. Tanto para a leitura quanto para a avaliação da resolução das atividades serão utilizado dois sites: o [https://www.urionlinejudge.com.br/ Uri] e o site da [https://olimpiada.ic.unicamp.br/ OBI]<br />
<br />
<br />
==[https://www.urionlinejudge.com.br/ Uri]==<br />
<br />
A URI Online Judge é um projeto desenvolvido pelo departamento de ciência da computação da universidade URI. Esse portal apresenta um repositório com diversos problemas com diversos níveis de dificuldades para serem resolvidos por meio da programação.<br />
<br />
== Anatomia de um problema URI ==</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Sistemas_autom%C3%A1ticos_de_avalia%C3%A7%C3%A3o&diff=16276Sistemas automáticos de avaliação2020-06-29T14:53:01Z<p>Maprestes: </p>
<hr />
<div>=== Sistemas automáticos de avaliação ===<br />
<br />
Durante esse projeto haverá diversas atividades sugeridas para fixar e colocar em prática os conteúdos aqui estudados. Tanto para a leitura quanto para a avaliação da resolução das atividades serão utilizado dois sites: o [https://www.urionlinejudge.com.br/ Uri] e o site da [https://olimpiada.ic.unicamp.br/ OBI]<br />
<br />
<br />
==[https://www.urionlinejudge.com.br/ Uri]==<br />
<br />
A URI Online Judge é um projeto desenvolvido pelo departamento de ciência da computação da universidade URI. Esse portal apresenta um repositório com diversos problemas com diversos níveis de dificuldades para serem resolvidos por meio da programação.</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Sistemas_autom%C3%A1ticos_de_avalia%C3%A7%C3%A3o&diff=16275Sistemas automáticos de avaliação2020-06-29T13:26:50Z<p>Maprestes: /* Sistemas automáticos de avaliação */</p>
<hr />
<div>=== Sistemas automáticos de avaliação ===<br />
<br />
Durante esse projeto haverá diversas atividades sugeridas para fixar e colocar em prática os conteúdos aqui estudados. Tanto para a leitura quanto para a avaliação da resolução das atividades serão utilizado dois sites: o [https://www.urionlinejudge.com.br/ Uri] e o site da [https://olimpiada.ic.unicamp.br/ Obi]</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Sistemas_autom%C3%A1ticos_de_avalia%C3%A7%C3%A3o&diff=16274Sistemas automáticos de avaliação2020-06-29T13:26:36Z<p>Maprestes: Criou página com '=== Sistemas automáticos de avaliação === Durante esse projeto haverá diversas atividades sugeridas para fixar e colocar em prática os conteúdos aqui estudados. Tanto p...'</p>
<hr />
<div>=== Sistemas automáticos de avaliação ===<br />
<br />
Durante esse projeto haverá diversas atividades sugeridas para fixar e colocar em prática os conteúdos aqui estudados. Tanto para a leitura quanto para a avaliação da resolução das atividades serão utilizado dois sites: o [[https://www.urionlinejudge.com.br/ Uri]] e o site da [https://olimpiada.ic.unicamp.br/ Obi]</div>Mapresteshttps://wiki.unicentro.br/index.php?title=TL_PC&diff=16273TL PC2020-06-29T13:15:36Z<p>Maprestes: /* Conteúdos */</p>
<hr />
<div>[[Arquivo: Treinamento_Logo_Desc.png|700px||right| <br />
<br />
<font size="2"><br />
<br />
</font><br />
<br />
]]<br />
<br />
<br />
== O Projeto ==<br />
<br />
<br />
<br />
<br><br />
O enfoque do projeto é proporcionar treinamento para alunos do ensino técnico que possuem maior interesse em programação, sobretudo, que participam da [https://olimpiada.ic.unicamp.br Olimpíada Brasileira de Informática (OBI)].<br />
<br />
<br />
== Sobre a Olimpíada Brasileira de Informática ==<br />
<br />
O objetivo da [https://olimpiada.ic.unicamp.br Olimpíada Brasileira de Informática (OBI)] é despertar nos alunos o interesse por uma ciência importante na formação básica hoje em dia (no caso, ciência da computação), através de uma atividade que envolve desafio, engenhosidade e uma saudável dose de competição. A organização da OBI está cargo do Instituto de Computação da UNICAMP.<br />
<br />
[[Olimpíada_Brasileira_de_Informática| Leia mais.]]<br />
<br />
<br><br />
<br />
== Conteúdos ==<br />
<br />
* [[Formato_dos_problemas| Formato dos problemas ]] <br />
<br />
* [[Sistemas_automáticos_de_avaliação| Sistemas automáticos de avaliação ]] <br />
<br />
* [[Entrada_e_saída_de_dados| Entrada/Saída de Dados]]<br />
<br />
* [[Operadores_Logicos| Operadores Lógicos]]<br />
<br />
* [[Estruturas_de_Seleção| Estruturas de Seleção]]<br />
<br />
* [[Estruturas_de_Repetição| Estruturas de Repetição]]<br />
<br />
* [[Vetores| Vetores]]<br />
<br />
<br><br />
<br />
== Equipe de execução ==<br />
<br />
'''Coordenação:'''<br />
* Ana Elisa T. P. da Palma<br />
* Mauro Miazaki<br />
<br />
'''Monitores:'''<br />
* Alexandro Luis da Rocha Junior<br />
* Erick Ascencio da Silva<br />
* Moises Alonso Prestes</div>Mapresteshttps://wiki.unicentro.br/index.php?title=TL_PC&diff=16272TL PC2020-06-29T12:54:05Z<p>Maprestes: /* Conteúdos */</p>
<hr />
<div>[[Arquivo: Treinamento_Logo_Desc.png|700px||right| <br />
<br />
<font size="2"><br />
<br />
</font><br />
<br />
]]<br />
<br />
<br />
== O Projeto ==<br />
<br />
<br />
<br />
<br><br />
O enfoque do projeto é proporcionar treinamento para alunos do ensino técnico que possuem maior interesse em programação, sobretudo, que participam da [https://olimpiada.ic.unicamp.br Olimpíada Brasileira de Informática (OBI)].<br />
<br />
<br />
== Sobre a Olimpíada Brasileira de Informática ==<br />
<br />
O objetivo da [https://olimpiada.ic.unicamp.br Olimpíada Brasileira de Informática (OBI)] é despertar nos alunos o interesse por uma ciência importante na formação básica hoje em dia (no caso, ciência da computação), através de uma atividade que envolve desafio, engenhosidade e uma saudável dose de competição. A organização da OBI está cargo do Instituto de Computação da UNICAMP.<br />
<br />
[[Olimpíada_Brasileira_de_Informática| Leia mais.]]<br />
<br />
<br><br />
<br />
== Conteúdos ==<br />
<br />
* [[Formato_dos_problemas| Formato dos problemas ]] <br />
<br />
* [[Sistemas_de_avaliação_automática| Sistemas de avaliação automática ]] <br />
<br />
* [[Entrada_e_saída_de_dados| Entrada/Saída de Dados]]<br />
<br />
* [[Operadores_Logicos| Operadores Lógicos]]<br />
<br />
* [[Estruturas_de_Seleção| Estruturas de Seleção]]<br />
<br />
* [[Estruturas_de_Repetição| Estruturas de Repetição]]<br />
<br />
* [[Vetores| Vetores]]<br />
<br />
<br><br />
<br />
== Equipe de execução ==<br />
<br />
'''Coordenação:'''<br />
* Ana Elisa T. P. da Palma<br />
* Mauro Miazaki<br />
<br />
'''Monitores:'''<br />
* Alexandro Luis da Rocha Junior<br />
* Erick Ascencio da Silva<br />
* Moises Alonso Prestes</div>Mapresteshttps://wiki.unicentro.br/index.php?title=TL_PC&diff=16271TL PC2020-06-29T12:28:38Z<p>Maprestes: /* Conteúdos */</p>
<hr />
<div>[[Arquivo: Treinamento_Logo_Desc.png|700px||right| <br />
<br />
<font size="2"><br />
<br />
</font><br />
<br />
]]<br />
<br />
<br />
== O Projeto ==<br />
<br />
<br />
<br />
<br><br />
O enfoque do projeto é proporcionar treinamento para alunos do ensino técnico que possuem maior interesse em programação, sobretudo, que participam da [https://olimpiada.ic.unicamp.br Olimpíada Brasileira de Informática (OBI)].<br />
<br />
<br />
== Sobre a Olimpíada Brasileira de Informática ==<br />
<br />
O objetivo da [https://olimpiada.ic.unicamp.br Olimpíada Brasileira de Informática (OBI)] é despertar nos alunos o interesse por uma ciência importante na formação básica hoje em dia (no caso, ciência da computação), através de uma atividade que envolve desafio, engenhosidade e uma saudável dose de competição. A organização da OBI está cargo do Instituto de Computação da UNICAMP.<br />
<br />
[[Olimpíada_Brasileira_de_Informática| Leia mais.]]<br />
<br />
<br><br />
<br />
== Conteúdos ==<br />
<br />
* [[Formato_dos_problemas| Formato dos problemas ]] <br />
<br />
* [[Formato_dos_problemas| Sistemas de avaliação automática ]] <br />
<br />
* [[Entrada_e_saída_de_dados| Entrada/Saída de Dados]]<br />
<br />
* [[Operadores_Logicos| Operadores Lógicos]]<br />
<br />
* [[Estruturas_de_Seleção| Estruturas de Seleção]]<br />
<br />
* [[Estruturas_de_Repetição| Estruturas de Repetição]]<br />
<br />
* [[Vetores| Vetores]]<br />
<br />
<br><br />
<br />
== Equipe de execução ==<br />
<br />
'''Coordenação:'''<br />
* Ana Elisa T. P. da Palma<br />
* Mauro Miazaki<br />
<br />
'''Monitores:'''<br />
* Alexandro Luis da Rocha Junior<br />
* Erick Ascencio da Silva<br />
* Moises Alonso Prestes</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Operadores_Logicos&diff=16270Operadores Logicos2020-06-29T12:27:03Z<p>Maprestes: </p>
<hr />
<div>As estruturas de programação, como a [[Estruturas_de_Seleção | estrutura de seleção]] e a [[Estruturas_de_Repetição | estrutura de repetição]] podem mudar o comportamento de um código. Dependendo de como o código está montado essas estruturas permitem a execução (ou repetição) de parte do código apenas em determinadas situações. O que vai decidir se o código dentro daquela estrutura deve ser executado (como em estruturas de seleção) ou se deve ser repetido (como em estruturas de repetição) é seu parâmetro lógico.<br />
<br />
Os parâmetros lógicos podem ser verdadeiros ou falsos, se forem verdadeiros a condição é cumprida e o código dentro da estrutura é executado (ou repetido, dependendo da estrutura), se não, aquela área do código é ignorada ou redirecionada.<br />
<br />
Por exemplo:<br />
<br />
[[Estruturas_de_Seleção | Estrutura de seleção]]<br />
<pre><br />
SE chovendo ENTÃO<br />
ESCREVA("Melhor levar um guarda-chuva");<br />
<br />
</pre><br />
<br />
[[Estruturas_de_Repetição | Estrutura de repetição]]<br />
<pre><br />
ENQUANTO chovendo FAÇA<br />
ESCREVA("Não vou sair de casa, ainda está chovendo");<br />
<br />
ESCREVA("Finalmente parou de chover!");<br />
</pre><br />
<br />
Os exemplos acima possuem em seu parâmetro uma variável que pode ser verdadeira ou falsa, porem, os parâmetros lógicos também podem ser construídos como expressões aritméticas.<br />
<br />
Por exemplo:<br />
<pre><br />
SE idade MENOR QUE 18 ENTÃO<br />
ESCREVA("Você é menor de idade!");<br />
</pre><br />
<br />
<pre><br />
SE preço MAIOR OU IGUAL QUE 10 ENTÃO<br />
ESCREVA("Isso é bem caro!");<br />
</pre><br />
<br />
<pre><br />
SE minhaIdade DIFERENTE QUE suaIdade ENTÃO<br />
ESCREVA("Não temos a mesma idade!");<br />
</pre><br />
<br />
Apesar de toda flexibilidade no código que os parâmetros lógicos possibilitam, é fácil se perder usando-os e criando um código confuso e difícil de entender.<br />
Por exemplo:<br />
<br />
<pre><br />
SE(sol) ENTÃO<br />
SE (calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
</pre><br />
<br />
<pre><br />
SE(preço <= 10) ENTÃO<br />
ESCREVA("eu posso comprar isso")<br />
SE NÃO<br />
SE(dinheiro > 10) ENTÃO<br />
escreva("eu posso comprar isso")<br />
</pre><br />
<br />
Para isso possuímos operadores lógicos: <br />
<br />
== Operador 'E' ==<br />
<br />
O operador 'E', também chamado de conjunção, funciona como a palavra 'e', fornecendo a intercessão entre dois elementos. Para a condição ser cumprida os dois elementos precisam ser verdadeiros. <br />
Por exemplo: "Maria vai ao parque se estiver sol e calor", nesse exemplo Maria vai ao parque apenas se as duas condições forem cumpridas, se houver sol mas não estiver calor ou se não houver sol mas estiver calor Maria não vai ao parque.<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Sol <th>Calor<th>Ela vai ao parque?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Não<br />
<tr><th>Não<td>Sim<td>Não<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(sol E calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
SE NÃO<br />
ESCREVA("Maria não vai ao parque! :( ");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(sol && calor){<br />
printf("Maria vai ao parque! :) ");<br />
}else{<br />
printf("Maria não vai ao parque! :( ");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(sol && calor){<br />
cout << "Maria vai ao parque! :) ";<br />
}else{<br />
cout << "Maria não vai ao parque! :( ";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if sol and calor:<br />
print('Maria vai ao parque! :) ')<br />
else:<br />
print('Maria não vai ao parque! :( ')<br />
</pre><br />
<br />
==Operador 'OU'==<br />
<br />
<br />
Diferente do operador lógico 'E' que necessita que ambos os parâmetros lógicos sejam verdadeiros para a condição ser cumprida, o operador 'OU' precisa que apenas um deles seja verdadeiro. Esse operador lógico só será falso quando ambos os parâmetros lógicos forem falsos.<br />
<br />
<table border="1" cellpadding="2"><br />
<caption>A tarefa foi feita?</caption><br />
<tr><th> Eu fiz <th> Você fez <th> A tarefa foi feita?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Sim<br />
<tr><th>Não<td>Sim<td>Sim<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(euFiz OU voceFez) ENTÃO<br />
ESCREVA("A tarefa foi feita");<br />
SE NÃO<br />
ESCREVA("A tarefa não foi feita");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(euFiz || voceFez){<br />
printf("A tarefa foi feita");<br />
}else{<br />
printf("A tarefa não foi feita");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(euFiz || voceFez){<br />
cout << "A tarefa foi feita";<br />
}else{<br />
cout << "A tarefa não foi feita";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if euFiz or voceFez:<br />
print('A tarefa foi feita')<br />
else:<br />
print('A tarefa não foi feita')<br />
</pre><br />
<br />
<br />
==Operador 'NÃO'==<br />
Diferente dos outros operadores já citados esse operador necessita apenas de um parâmetro lógico para funcionar. A função desse operador é alterar a leitura do parâmetro lógico para seu valor inverso, se esse parâmetro possuir o valor 'verdadeiro', com esse operador, será se lido o valor 'falso', e se o parâmetro possuir o valor 'falso' será lido o valor 'verdadeiro'.<br />
Algumas das representações mais classicas do símbolo de negação são: ~, !, NOT, e ¬<br />
<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Valor <th> ~Valor<br />
<tr><th>Sim<td>Não<br />
<tr><th>Não<td>Sim<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(~sol) ENTÃO<br />
ESCREVA("Está escuro");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(!sol){<br />
printf("Está escuro");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(!sol){<br />
cout << "Está escuro";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if not sol:<br />
print('Está escuro')<br />
<br />
</pre><br />
<br />
<br />
==Combinação de operadores==<br />
Além de toda flexibilidade que os operadores lógicos nos trazem, existem uma outra propriedade que nos permite ir além, a combinação de operadores. Quando usamos um operador para retirar um valor de um ou dois parâmetros lógicos (port ex: está sol *e* calor) essa expressão retornará um parâmetro lógico, verdadeiro ou falso, com isso em mente podemos combinar operadores para analises mais complexas.<br />
<br />
<pre><br />
SE chovendo E !guardachuva ENTÃO<br />
ESCREVA("Não posso sair, vou me molhar")<br />
</pre><br />
<br />
<br />
<pre><br />
SE sol E calor E fimDeSemana ENTÃO<br />
ESCREVA("Hoje podemos ir à praia!")<br />
</pre><br />
<br />
<br />
<br><br />
<br />
<br />
=== Problemas ===<br />
<br />
* [https://www.urionlinejudge.com.br/judge/pt/problems/view/1794 1794 - Lavanderia]</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Operadores_Logicos&diff=16269Operadores Logicos2020-06-29T12:23:50Z<p>Maprestes: </p>
<hr />
<div>As estruturas de programação, como a [[Estruturas_de_Seleção | estrutura de seleção]] e a [[Estruturas_de_Repetição | estrutura de repetição]] podem mudar o comportamento de um código. Dependendo de como o código está montado essas estruturas permitem a execução (ou repetição) de parte do código apenas em determinadas situações. O que vai decidir se o código dentro daquela estrutura deve ser executado (como em estruturas de seleção) ou se deve ser repetido (como em estruturas de repetição) é seu parâmetro lógico.<br />
<br />
Os parâmetros lógicos podem ser verdadeiros ou falsos, se forem verdadeiros a condição é cumprida e o código dentro da estrutura é executado (ou repetido, dependendo da estrutura), se não, aquela área do código é ignorada ou redirecionada.<br />
<br />
Por exemplo:<br />
<br />
[[Estruturas_de_Seleção | Estrutura de seleção]]<br />
<pre><br />
SE chovendo ENTÃO<br />
ESCREVA("Melhor levar um guarda-chuva");<br />
<br />
</pre><br />
<br />
[[Estruturas_de_Repetição | Estrutura de repetição]]<br />
<pre><br />
ENQUANTO chovendo FAÇA<br />
ESCREVA("Não vou sair de casa, ainda está chovendo");<br />
<br />
ESCREVA("Finalmente parou de chover!");<br />
</pre><br />
<br />
Os exemplos acima possuem em seu parâmetro uma variável que pode ser verdadeira ou falsa, porem, os parâmetros lógicos também podem ser construídos como expressões aritméticas.<br />
<br />
Por exemplo:<br />
<pre><br />
SE idade MENOR QUE 18 ENTÃO<br />
ESCREVA("Você é menor de idade!");<br />
</pre><br />
<br />
<pre><br />
SE preço MAIOR OU IGUAL QUE 10 ENTÃO<br />
ESCREVA("Isso é bem caro!");<br />
</pre><br />
<br />
<pre><br />
SE minhaIdade DIFERENTE QUE suaIdade ENTÃO<br />
ESCREVA("Não temos a mesma idade!");<br />
</pre><br />
<br />
Apesar de toda flexibilidade no código que os parâmetros lógicos possibilitam, é fácil se perder usando-os e criando um código confuso e difícil de entender.<br />
Por exemplo:<br />
<br />
<pre><br />
SE(sol) ENTÃO<br />
SE (calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
</pre><br />
<br />
<pre><br />
SE(preço <= 10) ENTÃO<br />
ESCREVA("eu posso comprar isso")<br />
SE NÃO<br />
SE(dinheiro > 10) ENTÃO<br />
escreva("eu posso comprar isso")<br />
</pre><br />
<br />
Para isso possuímos operadores lógicos: <br />
<br />
== Operador 'E' ==<br />
<br />
O operador 'E', também chamado de conjunção, funciona como a palavra 'e', fornecendo a intercessão entre dois elementos. Para a condição ser cumprida os dois elementos precisam ser verdadeiros. <br />
Por exemplo: "Maria vai ao parque se estiver sol e calor", nesse exemplo Maria vai ao parque apenas se as duas condições forem cumpridas, se houver sol mas não estiver calor ou se não houver sol mas estiver calor Maria não vai ao parque.<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Sol <th>Calor<th>Ela vai ao parque?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Não<br />
<tr><th>Não<td>Sim<td>Não<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(sol E calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
SE NÃO<br />
ESCREVA("Maria não vai ao parque! :( ");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(sol && calor){<br />
printf("Maria vai ao parque! :) ");<br />
}else{<br />
printf("Maria não vai ao parque! :( ");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(sol && calor){<br />
cout << "Maria vai ao parque! :) ";<br />
}else{<br />
cout << "Maria não vai ao parque! :( ";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if sol and calor:<br />
print('Maria vai ao parque! :) ')<br />
else:<br />
print('Maria não vai ao parque! :( ')<br />
</pre><br />
<br />
==Operador 'OU'==<br />
<br />
<br />
Diferente do operador lógico 'E' que necessita que ambos os parâmetros lógicos sejam verdadeiros para a condição ser cumprida, o operador 'OU' precisa que apenas um deles seja verdadeiro. Esse operador lógico só será falso quando ambos os parâmetros lógicos forem falsos.<br />
<br />
<table border="1" cellpadding="2"><br />
<caption>A tarefa foi feita?</caption><br />
<tr><th> Eu fiz <th> Você fez <th> A tarefa foi feita?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Sim<br />
<tr><th>Não<td>Sim<td>Sim<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(euFiz OU voceFez) ENTÃO<br />
ESCREVA("A tarefa foi feita");<br />
SE NÃO<br />
ESCREVA("A tarefa não foi feita");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(euFiz || voceFez){<br />
printf("A tarefa foi feita");<br />
}else{<br />
printf("A tarefa não foi feita");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(euFiz || voceFez){<br />
cout << "A tarefa foi feita";<br />
}else{<br />
cout << "A tarefa não foi feita";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if euFiz or voceFez:<br />
print('A tarefa foi feita')<br />
else:<br />
print('A tarefa não foi feita')<br />
</pre><br />
<br />
<br />
==Operador 'NÃO'==<br />
Diferente dos outros operadores já citados esse operador necessita apenas de um parâmetro lógico para funcionar. A função desse operador é alterar a leitura do parâmetro lógico para seu valor inverso, se esse parâmetro possuir o valor 'verdadeiro', com esse operador, será se lido o valor 'falso', e se o parâmetro possuir o valor 'falso' será lido o valor 'verdadeiro'.<br />
Algumas das representações mais classicas do símbolo de negação são: ~, !, NOT, e ¬<br />
<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Valor <th> ~Valor<br />
<tr><th>Sim<td>Não<br />
<tr><th>Não<td>Sim<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(~sol) ENTÃO<br />
ESCREVA("Está escuro");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(!sol){<br />
printf("Está escuro");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(!sol){<br />
cout << "Está escuro";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if not sol:<br />
print('Está escuro')<br />
<br />
</pre><br />
<br />
<br />
==Combinação de operadores==<br />
Além de toda flexibilidade que os operadores lógicos nos trazem, existem uma outra propriedade que nos permite ir além, a combinação de operadores. Quando usamos um operador para retirar um valor de um ou dois parâmetros lógicos (port ex: está sol *e* calor) essa expressão retornará um parâmetro lógico, verdadeiro ou falso, com isso em mente podemos combinar operadores para analises mais complexas.<br />
<br />
<pre><br />
SE chovendo E !guardachuva ENTÃO<br />
ESCREVA("Não posso sair, vou me molhar")<br />
</pre><br />
<br />
<br />
<pre><br />
SE sol E calor E fimDeSemana ENTÃO<br />
ESCREVA("Hoje podemos ir à praia!")<br />
</pre></div>Mapresteshttps://wiki.unicentro.br/index.php?title=Vetores&diff=16268Vetores2020-06-21T22:42:51Z<p>Maprestes: </p>
<hr />
<div>=== Vetores ===<br />
Vetor (array uni-dimensional) é uma estrutura simples que armazena vários valores do mesmo tipo em um espaço de memória. Assista a videoaula sobre este tipo de estrutura [https://www.youtube.com/watch?v=B6MUlVNzWQQ&feature=youtu.be aqui].<br />
<br />
Sintaxe:<br />
<pre><br />
Pseudocódigo | Pascal | Linguagem C ou C++ <br />
| | <br />
reais: conjunto[50] de real; | reais: array[1..50] of real; | float reais[50]; <br />
inteiros: conjunto[50] de inteiro; | inteiros: array[1..50] de integer; | int inteiros[50];<br />
letras: conjunto[50] de Caractere; | letras: conjunto[1..50] de Char; | char letras[50];<br />
<br />
</pre> <br />
<br />
Exemplo:<br><br />
Preencha uma array com o alfabeto.<br><br />
char '''alfabeto''': conjunto[26];<br />
<pre><br />
Pseudocódigo | Pascal | Linguagem C ou C++ <br />
| | <br />
alfabeto[0] = 'a'; | alfabeto[0] := 'a'; | alfabeto[0] = 'a';<br />
alfabeto[1] = 'b'; | alfabeto[1] := 'b'; | alfabeto[1] = 'b';<br />
alfabeto[2] = 'c'; | alfabeto[2] := 'c'; | alfabeto[2] = 'c';<br />
[...] | [...] | [...]<br />
alfabeto[23] = 'x'; | alfabeto[23] := 'x'; | alfabeto[23] = 'x';<br />
alfabeto[24] = 'y'; | alfabeto[24] := 'y'; | alfabeto[24] = 'y';<br />
alfabeto[25] = 'z'; | alfabeto[25] := 'z'; | alfabeto[25] = 'z';<br />
<br />
</pre> <br />
<br />
'''Observe que, apesar do vetor possuir 26 espaços, contamos até o 25. Isso se deve ao fato da maioria das linguagens de programação começarem como o primeiro índice em 0 e não em 1, então um vetor com 5 elementos iria o indice 0 ao 4.'''<br />
<br />
=== Exemplo em C++ ===<br />
==== [https://olimpiada.ic.unicamp.br/pratique/p2/2017/f1/botas/ Botas Trocadas] ====<br />
<pre><br />
<br />
#include <iostream><br />
<br />
using namespace std;<br />
<br />
int main(){<br />
int tamanho = 0;<br />
cin >> tamanho;<br />
<br />
int numeroBota[tamanho];<br />
char peBota[tamanho];<br />
<br />
for(int i = 0; i < tamanho; i++){<br />
cin >> numeroBota[i];<br />
cin >> peBota[i];<br />
}<br />
<br />
<br />
int pares = 0;<br />
for(int i = 0; i < tamanho; i++){<br />
if(numeroBota[i] > 0){<br />
for(int j = i+1; j<tamanho;j++){<br />
if(numeroBota[i] == numeroBota[j] && peBota[i] != peBota[j]){<br />
pares++;<br />
numeroBota[i] = -1;<br />
numeroBota[j] = -1;<br />
peBota[i] = '';<br />
peBota[j] = '';<br />
}<br />
}<br />
}<br />
}<br />
<br />
cout << pares << endl; <br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
=== Problemas ===<br />
<br />
* [https://olimpiada.ic.unicamp.br/pratique/p2/2017/f1/botas/ Botas trocadas]<br />
* [https://www.urionlinejudge.com.br/judge/pt/problems/view/1171 Frequência de números - 1171]<br />
* [https://www.urionlinejudge.com.br/judge/pt/problems/view/1172 Substituição em Vetor I - 1172]<br />
* [https://www.urionlinejudge.com.br/judge/pt/problems/view/1173 Preenchimento de Vetor I - 1173]<br />
* [https://www.urionlinejudge.com.br/judge/pt/problems/view/1175 Troca em Vetor I - 1175]<br />
<br />
<br />
Quer mais?<br />
<br />
* [https://www.urionlinejudge.com.br/judge/pt/problems/view/1176 Fibonacci em Vetor - 1176]<br />
* [https://www.urionlinejudge.com.br/judge/pt/problems/view/1178 Preenchimento de Vetor III - 1178]<br />
* [https://www.urionlinejudge.com.br/judge/pt/problems/view/1245 Botas Perdidas - 1245]<br />
* [https://www.urionlinejudge.com.br/judge/pt/problems/view/2449 Fechadura - 2449]</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Vetores&diff=16267Vetores2020-06-21T22:40:38Z<p>Maprestes: </p>
<hr />
<div>=== Vetores ===<br />
Vetor (array uni-dimensional) é uma estrutura simples que armazena vários valores do mesmo tipo em um espaço de memória. Assista a videoaula sobre este tipo de estrutura [https://www.youtube.com/watch?v=B6MUlVNzWQQ&feature=youtu.be aqui].<br />
<br />
Sintaxe:<br />
<pre><br />
Pseudocódigo | Pascal | Linguagem C ou C++ <br />
| | <br />
reais: conjunto[50] de real; | reais: array[1..50] of real; | float reais[50]; <br />
inteiros: conjunto[50] de inteiro; | inteiros: array[1..50] de integer; | int inteiros[50];<br />
letras: conjunto[50] de Caractere; | letras: conjunto[1..50] de Char; | char letras[50];<br />
<br />
</pre> <br />
<br />
Exemplo:<br><br />
Preencha uma array com o alfabeto.<br><br />
char '''alfabeto''': conjunto[26];<br />
<pre><br />
Pseudocódigo | Pascal | Linguagem C ou C++ <br />
| | <br />
alfabeto[0] = 'a'; | alfabeto[0] := 'a'; | alfabeto[0] = 'a';<br />
alfabeto[1] = 'b'; | alfabeto[1] := 'b'; | alfabeto[1] = 'b';<br />
alfabeto[2] = 'c'; | alfabeto[2] := 'c'; | alfabeto[2] = 'c';<br />
[...] | [...] | [...]<br />
alfabeto[23] = 'x'; | alfabeto[23] := 'x'; | alfabeto[23] = 'x';<br />
alfabeto[24] = 'y'; | alfabeto[24] := 'y'; | alfabeto[24] = 'y';<br />
alfabeto[25] = 'z'; | alfabeto[25] := 'z'; | alfabeto[25] = 'z';<br />
<br />
</pre> <br />
<br />
'''Observe que, apesar do vetor possuir 26 espaços, contamos até o 25. Isso se deve ao fato da maioria das linguagens de programação começarem como o primeiro índice em 0 e não em 1, então um vetor com 5 elementos iria o indice 0 ao 4.'''<br />
<br />
=== Exemplo em C++ ===<br />
==== [https://olimpiada.ic.unicamp.br/pratique/p2/2017/f1/botas/ Botas Trocadas] ====<br />
<pre><br />
<br />
#include <iostream><br />
<br />
using namespace std;<br />
<br />
int main(){<br />
int tamanho = 0;<br />
cin >> tamanho;<br />
<br />
int numeroBota[tamanho];<br />
char peBota[tamanho];<br />
<br />
for(int i = 0; i < tamanho; i++){<br />
cin >> numeroBota[i];<br />
cin >> peBota[i];<br />
}<br />
<br />
<br />
int pares = 0;<br />
for(int i = 0; i < tamanho; i++){<br />
if(numeroBota[i] > 0){<br />
for(int j = i+1; j<tamanho;j++){<br />
if(numeroBota[i] == numeroBota[j] && peBota[i] != peBota[j]){<br />
pares++;<br />
numeroBota[i] = -1;<br />
numeroBota[j] = -1;<br />
peBota[i] = '';<br />
peBota[j] = '';<br />
}<br />
}<br />
}<br />
}<br />
<br />
cout << pares << endl; <br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
=== Problemas ===<br />
<br />
* [https://olimpiada.ic.unicamp.br/pratique/p2/2017/f1/botas/ Botas trocadas]<br />
* [https://www.urionlinejudge.com.br/judge/pt/problems/view/1171 Frequência de números - 1171]<br />
* [https://www.urionlinejudge.com.br/judge/pt/problems/view/1172 Substituição em Vetor I - 1172]<br />
* [https://www.urionlinejudge.com.br/judge/pt/problems/view/1173 Preenchimento de Vetor I - 1173]<br />
* [https://www.urionlinejudge.com.br/judge/pt/problems/view/1175 Troca em Vetor I - 1175]<br />
* [https://www.urionlinejudge.com.br/judge/pt/problems/view/1172 Substituição em Vetor I - 1172]</div>Mapresteshttps://wiki.unicentro.br/index.php?title=Operadores_Logicos&diff=16266Operadores Logicos2020-06-21T22:37:18Z<p>Maprestes: </p>
<hr />
<div>Operadores lógicos, como operadores ariméticos<br />
<br />
As estruturas de programação, como a [[Estruturas_de_Seleção | estrutura de seleção]] e a [[Estruturas_de_Repetição | estrutura de repetição]] podem mudar o comportamento de um código. Dependendo de como o código está montado essas estruturas permitem a execução (ou repetição) de parte do código apenas em determinadas situações. O que vai decidir se o código dentro daquela estrutura deve ser executado (como em estruturas de seleção) ou se deve ser repetido 1 ou 10 vezes (como em estruturas de repetição) é seu parâmetro lógico.<br />
<br />
Os parâmetros lógicos podem ser verdadeiros ou falsos, se forem verdadeiros a condição é cumprida e o código dentro da estrutura é executado (ou repetido, dependendo da estrutura), se não, aquela area do código é ignorada ou redirecionada.<br />
<br />
Por exemplo:<br />
<br />
[[Estruturas_de_Seleção | Estrutura de seleção]]<br />
<pre><br />
SE chovendo ENTÃO<br />
ESCREVA("Melhor levar um guarda-chuva");<br />
<br />
</pre><br />
<br />
[[Estruturas_de_Repetição | Estrutura de repetição]]<br />
<pre><br />
ENQUANTO chovendo FAÇA<br />
ESCREVA("Não vou sair de casa, ainda está chovendo");<br />
<br />
ESCREVA("Finalmente parou de chover!");<br />
</pre><br />
<br />
Os exemplos acima possuem em seu parâmetro uma variável que pode ser verdadeira ou falsa, porem, os parâmetros lógicos também podem ser construidos como expressões aritméticas.<br />
<br />
Por exemplo:<br />
<pre><br />
SE idade MENOR QUE 18 ENTÃO<br />
ESCREVA("Você é menor de idade!");<br />
</pre><br />
<br />
<pre><br />
SE preço MAIOR OU IGUAL QUE 10 ENTÃO<br />
ESCREVA("Isso é bem caro!");<br />
</pre><br />
<br />
<pre><br />
SE minhaIdade DIFERENTE QUE suaIdade ENTÃO<br />
ESCREVA("Não temos a mesma idade!");<br />
</pre><br />
<br />
Apesar de toda flexibilidade no código que os parâmetros lógicos possibilitam, é fácil se perder usando-os e criando um código confuso e difícil de entender.<br />
Por exemplo:<br />
<br />
<pre><br />
SE(sol) ENTÃO<br />
SE (calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
</pre><br />
<br />
<pre><br />
SE(preço <= 10) ENTÃO<br />
ESCREVA("eu posso comprar isso")<br />
SE NÃO<br />
SE(dinheiro > 10) ENTÃO<br />
escreva("eu posso comprar isso")<br />
</pre><br />
<br />
Para isso possuímos operadores lógicos: <br />
<br />
== Operador 'E' ==<br />
<br />
//Explicar necessidade do operadores E<br />
O operador 'E', também chamado de conjunção, funciona como a palavra 'e', fornecendo a intercessão entre dois elementos. Para a condição ser cumprida os dois elementos precisam ser verdadeiros. <br />
Por exemplo: "Maria vai ao parque se estiver sol e calor", nesse exemplo Maria vai ao parque apenas se as duas condições forem cumpridas, se houver sol mas não estiver calor ou se não houver sol mas estiver calor Maria não vai ao parque.<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Sol <th>Calor<th>Ela vai ao parque?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Não<br />
<tr><th>Não<td>Sim<td>Não<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(sol E calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
SE NÃO<br />
ESCREVA("Maria não vai ao parque! :( ");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(sol && calor){<br />
printf("Maria vai ao parque! :) ");<br />
}else{<br />
printf("Maria não vai ao parque! :( ");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(sol && calor){<br />
cout << "Maria vai ao parque! :) ";<br />
}else{<br />
cout << "Maria não vai ao parque! :( ";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if sol and calor:<br />
print('Maria vai ao parque! :) ')<br />
else:<br />
print('Maria não vai ao parque! :( ')<br />
</pre><br />
<br />
==Operador 'OU'==<br />
<br />
//Explicar necessidade do operadores OU<br />
<br />
Diferente do operador lógico 'E' que necessita que ambos os parâmetros lógicos sejam verdadeiros para a condição ser cumprida, o operador 'OU' precisa que apenas um deles seja verdadeiro. Esse operador lógico só será falso quando ambos os parâmetros lógicos forem falsos.<br />
<br />
<table border="1" cellpadding="2"><br />
<caption>A tarefa foi feita?</caption><br />
<tr><th> Eu fiz <th> Você fez <th> A tarefa foi feita?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Sim<br />
<tr><th>Não<td>Sim<td>Sim<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(euFiz OU voceFez) ENTÃO<br />
ESCREVA("A tarefa foi feita");<br />
SE NÃO<br />
ESCREVA("A tarefa não foi feita");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(euFiz || voceFez){<br />
printf("A tarefa foi feita");<br />
}else{<br />
printf("A tarefa não foi feita");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(euFiz || voceFez){<br />
cout << "A tarefa foi feita";<br />
}else{<br />
cout << "A tarefa não foi feita";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if euFiz or voceFez:<br />
print('A tarefa foi feita')<br />
else:<br />
print('A tarefa não foi feita')<br />
</pre><br />
<br />
<br />
==Operador 'NÃO'==<br />
//Explicar necessidade do operadores NÃO<br />
Diferente dos outros operadores já citados esse operador necessita apenas de um parâmetro lógico para funcionar. A função desse operador é alterar a leitura do parâmetro lógico para seu valor inverso, se esse parâmetro possuir o valor 'verdadeiro', com esse operador, será se lido o valor 'falso', e se o parâmetro possuir o valor 'falso' será lido o valor 'verdadeiro'.<br />
Algumas das representações mais classicas do símbolo de negação são: ~, !, NOT, e ¬<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Valor <th> ~Valor<br />
<tr><th>Sim<td>Não<br />
<tr><th>Não<td>Sim<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(~sol) ENTÃO<br />
ESCREVA("Está escuro");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(!sol){<br />
printf("Está escuro");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(!sol){<br />
cout << "Está escuro";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if not sol:<br />
print('Está escuro')<br />
<br />
</pre><br />
<br />
<br />
==Combinação de operadores==<br />
Além de toda flexibilidade que os operadores lógicos nos trazem, existem uma outra propriedade que nos permite ir além, a combinação de operadores. Quando usamos um operador para retirar um valor de um ou dois parâmetros lógicos (port ex: está sol *e* calor) essa expressão retornará um parâmetro lógico, verdadeiro ou falso, com isso em mente podemos combinar operadores para analises mais complexas.<br />
<br />
<pre><br />
SE chovendo E !guardachuva ENTÃO<br />
ESCREVA("Não posso sair, vou me molhar")<br />
</pre><br />
<br />
<br />
<pre><br />
SE sol E calor E fimDeSemana ENTÃO<br />
ESCREVA("Hoje podemos ir à praia!")<br />
</pre></div>Mapresteshttps://wiki.unicentro.br/index.php?title=Operadores_Logicos&diff=16265Operadores Logicos2020-06-21T22:37:01Z<p>Maprestes: </p>
<hr />
<div>Operadores lógicos, como operadores ariméticos<br />
<br />
As estruturas de programação, como a [[Estruturas_de_Seleção | estrutura de seleção]] e a [[Estruturas_de_Repetição | estrutura de repetição]] podem mudar o comportamento de um código. Dependendo de como o código está montado essas estruturas permitem a execução (ou repetição) de parte do código apenas em determinadas situações. O que vai decidir se o código dentro daquela estrutura deve ser executado (como em estruturas de seleção) ou se deve ser repetido 1 ou 10 vezes (como em estruturas de repetição) é seu parâmetro lógico.<br />
<br />
Os parâmetros lógicos podem ser verdadeiros ou falsos, se forem verdadeiros a condição é cumprida e o código dentro da estrutura é executado (ou repetido, dependendo da estrutura), se não, aquela area do código é ignorada ou redirecionada.<br />
<br />
Por exemplo:<br />
<br />
[[Estruturas_de_Seleção || Estrutura de seleção]]<br />
<pre><br />
SE chovendo ENTÃO<br />
ESCREVA("Melhor levar um guarda-chuva");<br />
<br />
</pre><br />
<br />
[[Estruturas_de_Repetição | Estrutura de repetição]]<br />
<pre><br />
ENQUANTO chovendo FAÇA<br />
ESCREVA("Não vou sair de casa, ainda está chovendo");<br />
<br />
ESCREVA("Finalmente parou de chover!");<br />
</pre><br />
<br />
Os exemplos acima possuem em seu parâmetro uma variável que pode ser verdadeira ou falsa, porem, os parâmetros lógicos também podem ser construidos como expressões aritméticas.<br />
<br />
Por exemplo:<br />
<pre><br />
SE idade MENOR QUE 18 ENTÃO<br />
ESCREVA("Você é menor de idade!");<br />
</pre><br />
<br />
<pre><br />
SE preço MAIOR OU IGUAL QUE 10 ENTÃO<br />
ESCREVA("Isso é bem caro!");<br />
</pre><br />
<br />
<pre><br />
SE minhaIdade DIFERENTE QUE suaIdade ENTÃO<br />
ESCREVA("Não temos a mesma idade!");<br />
</pre><br />
<br />
Apesar de toda flexibilidade no código que os parâmetros lógicos possibilitam, é fácil se perder usando-os e criando um código confuso e difícil de entender.<br />
Por exemplo:<br />
<br />
<pre><br />
SE(sol) ENTÃO<br />
SE (calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
</pre><br />
<br />
<pre><br />
SE(preço <= 10) ENTÃO<br />
ESCREVA("eu posso comprar isso")<br />
SE NÃO<br />
SE(dinheiro > 10) ENTÃO<br />
escreva("eu posso comprar isso")<br />
</pre><br />
<br />
Para isso possuímos operadores lógicos: <br />
<br />
== Operador 'E' ==<br />
<br />
//Explicar necessidade do operadores E<br />
O operador 'E', também chamado de conjunção, funciona como a palavra 'e', fornecendo a intercessão entre dois elementos. Para a condição ser cumprida os dois elementos precisam ser verdadeiros. <br />
Por exemplo: "Maria vai ao parque se estiver sol e calor", nesse exemplo Maria vai ao parque apenas se as duas condições forem cumpridas, se houver sol mas não estiver calor ou se não houver sol mas estiver calor Maria não vai ao parque.<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Sol <th>Calor<th>Ela vai ao parque?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Não<br />
<tr><th>Não<td>Sim<td>Não<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(sol E calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
SE NÃO<br />
ESCREVA("Maria não vai ao parque! :( ");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(sol && calor){<br />
printf("Maria vai ao parque! :) ");<br />
}else{<br />
printf("Maria não vai ao parque! :( ");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(sol && calor){<br />
cout << "Maria vai ao parque! :) ";<br />
}else{<br />
cout << "Maria não vai ao parque! :( ";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if sol and calor:<br />
print('Maria vai ao parque! :) ')<br />
else:<br />
print('Maria não vai ao parque! :( ')<br />
</pre><br />
<br />
==Operador 'OU'==<br />
<br />
//Explicar necessidade do operadores OU<br />
<br />
Diferente do operador lógico 'E' que necessita que ambos os parâmetros lógicos sejam verdadeiros para a condição ser cumprida, o operador 'OU' precisa que apenas um deles seja verdadeiro. Esse operador lógico só será falso quando ambos os parâmetros lógicos forem falsos.<br />
<br />
<table border="1" cellpadding="2"><br />
<caption>A tarefa foi feita?</caption><br />
<tr><th> Eu fiz <th> Você fez <th> A tarefa foi feita?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Sim<br />
<tr><th>Não<td>Sim<td>Sim<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(euFiz OU voceFez) ENTÃO<br />
ESCREVA("A tarefa foi feita");<br />
SE NÃO<br />
ESCREVA("A tarefa não foi feita");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(euFiz || voceFez){<br />
printf("A tarefa foi feita");<br />
}else{<br />
printf("A tarefa não foi feita");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(euFiz || voceFez){<br />
cout << "A tarefa foi feita";<br />
}else{<br />
cout << "A tarefa não foi feita";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if euFiz or voceFez:<br />
print('A tarefa foi feita')<br />
else:<br />
print('A tarefa não foi feita')<br />
</pre><br />
<br />
<br />
==Operador 'NÃO'==<br />
//Explicar necessidade do operadores NÃO<br />
Diferente dos outros operadores já citados esse operador necessita apenas de um parâmetro lógico para funcionar. A função desse operador é alterar a leitura do parâmetro lógico para seu valor inverso, se esse parâmetro possuir o valor 'verdadeiro', com esse operador, será se lido o valor 'falso', e se o parâmetro possuir o valor 'falso' será lido o valor 'verdadeiro'.<br />
Algumas das representações mais classicas do símbolo de negação são: ~, !, NOT, e ¬<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Valor <th> ~Valor<br />
<tr><th>Sim<td>Não<br />
<tr><th>Não<td>Sim<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(~sol) ENTÃO<br />
ESCREVA("Está escuro");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(!sol){<br />
printf("Está escuro");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(!sol){<br />
cout << "Está escuro";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if not sol:<br />
print('Está escuro')<br />
<br />
</pre><br />
<br />
<br />
==Combinação de operadores==<br />
Além de toda flexibilidade que os operadores lógicos nos trazem, existem uma outra propriedade que nos permite ir além, a combinação de operadores. Quando usamos um operador para retirar um valor de um ou dois parâmetros lógicos (port ex: está sol *e* calor) essa expressão retornará um parâmetro lógico, verdadeiro ou falso, com isso em mente podemos combinar operadores para analises mais complexas.<br />
<br />
<pre><br />
SE chovendo E !guardachuva ENTÃO<br />
ESCREVA("Não posso sair, vou me molhar")<br />
</pre><br />
<br />
<br />
<pre><br />
SE sol E calor E fimDeSemana ENTÃO<br />
ESCREVA("Hoje podemos ir à praia!")<br />
</pre></div>Mapresteshttps://wiki.unicentro.br/index.php?title=Operadores_Logicos&diff=16264Operadores Logicos2020-06-21T22:35:53Z<p>Maprestes: </p>
<hr />
<div>Operadores lógicos, como operadores ariméticos<br />
<br />
As estruturas de programação, como a [Estruturas_de_Seleção | estrutura de seleção] e a [Estruturas_de_Repetição | estrutura de repetição] podem mudar o comportamento de um código. Dependendo de como o código está montado essas estruturas permitem a execução (ou repetição) de parte do código apenas em determinadas situações. O que vai decidir se o código dentro daquela estrutura deve ser executado (como em estruturas de seleção) ou se deve ser repetido 1 ou 10 vezes (como em estruturas de repetição) é seu parâmetro lógico.<br />
<br />
Os parâmetros lógicos podem ser verdadeiros ou falsos, se forem verdadeiros a condição é cumprida e o código dentro da estrutura é executado (ou repetido, dependendo da estrutura), se não, aquela area do código é ignorada ou redirecionada.<br />
<br />
Por exemplo:<br />
<br />
[Estruturas_de_Seleção || Estrutura de seleção]<br />
<pre><br />
SE chovendo ENTÃO<br />
ESCREVA("Melhor levar um guarda-chuva");<br />
<br />
</pre><br />
<br />
[Estruturas_de_Repetição | Estrutura de repetição]<br />
<pre><br />
ENQUANTO chovendo FAÇA<br />
ESCREVA("Não vou sair de casa, ainda está chovendo");<br />
<br />
ESCREVA("Finalmente parou de chover!");<br />
</pre><br />
<br />
Os exemplos acima possuem em seu parâmetro uma variável que pode ser verdadeira ou falsa, porem, os parâmetros lógicos também podem ser construidos como expressões aritméticas.<br />
<br />
Por exemplo:<br />
<pre><br />
SE idade MENOR QUE 18 ENTÃO<br />
ESCREVA("Você é menor de idade!");<br />
</pre><br />
<br />
<pre><br />
SE preço MAIOR OU IGUAL QUE 10 ENTÃO<br />
ESCREVA("Isso é bem caro!");<br />
</pre><br />
<br />
<pre><br />
SE minhaIdade DIFERENTE QUE suaIdade ENTÃO<br />
ESCREVA("Não temos a mesma idade!");<br />
</pre><br />
<br />
Apesar de toda flexibilidade no código que os parâmetros lógicos possibilitam, é fácil se perder usando-os e criando um código confuso e difícil de entender.<br />
Por exemplo:<br />
<br />
<pre><br />
SE(sol) ENTÃO<br />
SE (calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
</pre><br />
<br />
<pre><br />
SE(preço <= 10) ENTÃO<br />
ESCREVA("eu posso comprar isso")<br />
SE NÃO<br />
SE(dinheiro > 10) ENTÃO<br />
escreva("eu posso comprar isso")<br />
</pre><br />
<br />
Para isso possuímos operadores lógicos: <br />
<br />
== Operador 'E' ==<br />
<br />
//Explicar necessidade do operadores E<br />
O operador 'E', também chamado de conjunção, funciona como a palavra 'e', fornecendo a intercessão entre dois elementos. Para a condição ser cumprida os dois elementos precisam ser verdadeiros. <br />
Por exemplo: "Maria vai ao parque se estiver sol e calor", nesse exemplo Maria vai ao parque apenas se as duas condições forem cumpridas, se houver sol mas não estiver calor ou se não houver sol mas estiver calor Maria não vai ao parque.<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Sol <th>Calor<th>Ela vai ao parque?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Não<br />
<tr><th>Não<td>Sim<td>Não<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(sol E calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
SE NÃO<br />
ESCREVA("Maria não vai ao parque! :( ");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(sol && calor){<br />
printf("Maria vai ao parque! :) ");<br />
}else{<br />
printf("Maria não vai ao parque! :( ");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(sol && calor){<br />
cout << "Maria vai ao parque! :) ";<br />
}else{<br />
cout << "Maria não vai ao parque! :( ";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if sol and calor:<br />
print('Maria vai ao parque! :) ')<br />
else:<br />
print('Maria não vai ao parque! :( ')<br />
</pre><br />
<br />
==Operador 'OU'==<br />
<br />
//Explicar necessidade do operadores OU<br />
<br />
Diferente do operador lógico 'E' que necessita que ambos os parâmetros lógicos sejam verdadeiros para a condição ser cumprida, o operador 'OU' precisa que apenas um deles seja verdadeiro. Esse operador lógico só será falso quando ambos os parâmetros lógicos forem falsos.<br />
<br />
<table border="1" cellpadding="2"><br />
<caption>A tarefa foi feita?</caption><br />
<tr><th> Eu fiz <th> Você fez <th> A tarefa foi feita?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Sim<br />
<tr><th>Não<td>Sim<td>Sim<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(euFiz OU voceFez) ENTÃO<br />
ESCREVA("A tarefa foi feita");<br />
SE NÃO<br />
ESCREVA("A tarefa não foi feita");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(euFiz || voceFez){<br />
printf("A tarefa foi feita");<br />
}else{<br />
printf("A tarefa não foi feita");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(euFiz || voceFez){<br />
cout << "A tarefa foi feita";<br />
}else{<br />
cout << "A tarefa não foi feita";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if euFiz or voceFez:<br />
print('A tarefa foi feita')<br />
else:<br />
print('A tarefa não foi feita')<br />
</pre><br />
<br />
<br />
==Operador 'NÃO'==<br />
//Explicar necessidade do operadores NÃO<br />
Diferente dos outros operadores já citados esse operador necessita apenas de um parâmetro lógico para funcionar. A função desse operador é alterar a leitura do parâmetro lógico para seu valor inverso, se esse parâmetro possuir o valor 'verdadeiro', com esse operador, será se lido o valor 'falso', e se o parâmetro possuir o valor 'falso' será lido o valor 'verdadeiro'.<br />
Algumas das representações mais classicas do símbolo de negação são: ~, !, NOT, e ¬<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Valor <th> ~Valor<br />
<tr><th>Sim<td>Não<br />
<tr><th>Não<td>Sim<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(~sol) ENTÃO<br />
ESCREVA("Está escuro");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(!sol){<br />
printf("Está escuro");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(!sol){<br />
cout << "Está escuro";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if not sol:<br />
print('Está escuro')<br />
<br />
</pre><br />
<br />
<br />
==Combinação de operadores==<br />
Além de toda flexibilidade que os operadores lógicos nos trazem, existem uma outra propriedade que nos permite ir além, a combinação de operadores. Quando usamos um operador para retirar um valor de um ou dois parâmetros lógicos (port ex: está sol *e* calor) essa expressão retornará um parâmetro lógico, verdadeiro ou falso, com isso em mente podemos combinar operadores para analises mais complexas.<br />
<br />
<pre><br />
SE chovendo E !guardachuva ENTÃO<br />
ESCREVA("Não posso sair, vou me molhar")<br />
</pre><br />
<br />
<br />
<pre><br />
SE sol E calor E fimDeSemana ENTÃO<br />
ESCREVA("Hoje podemos ir à praia!")<br />
</pre></div>Mapresteshttps://wiki.unicentro.br/index.php?title=Operadores_Logicos&diff=16263Operadores Logicos2020-06-21T22:26:49Z<p>Maprestes: </p>
<hr />
<div>Operadores lógicos, como operadores ariméticos<br />
<br />
As estruturas de programação, como a [Estruturas_de_Seleção | estrutura de seleção] e a [Estruturas_de_Repetição | estrutura de repetição] podem mudar o comportamento de um código. Dependendo de como o código está montado essas estruturas permitem a execução (ou repetição) de parte do código apenas em determinadas situações. O que vai decidir se o código dentro daquela estrutura deve ser executado (como em estruturas de seleção) ou se deve ser repetido 1 ou 10 vezes (como em estruturas de repetição) é seu parâmetro lógico.<br />
<br />
Os parâmetros lógicos podem ser verdadeiros ou falsos, se forem verdadeiros a condição é cumprida e o código dentro da estrutura é executado (ou repetido, dependendo da estrutura), se não, aquela area do código é ignorada ou redirecionada.<br />
<br />
Por exemplo:<br />
<br />
[Estruturas_de_Seleção || Estrutura de seleção]<br />
<pre><br />
SE chovendo ENTÃO<br />
ESCREVA("Melhor levar um guarda-chuva");<br />
<br />
</pre><br />
<br />
[Estruturas_de_Repetição | Estrutura de repetição]<br />
<pre><br />
ENQUANTO chovendo FAÇA<br />
ESCREVA("Não vou sair de casa, ainda está chovendo");<br />
<br />
ESCREVA("Finalmente parou de chover!");<br />
</pre><br />
<br />
Os exemplos acima possuem em seu parâmetro uma variável que pode ser verdadeira ou falsa, porem, os parâmetros lógicos também podem ser construidos como expressões aritméticas.<br />
<br />
Por exemplo:<br />
<pre><br />
SE idade MENOR QUE 18 ENTÃO<br />
ESCREVA("Você é menor de idade!");<br />
</pre><br />
<br />
<pre><br />
SE preço MAIOR OU IGUAL QUE 10 ENTÃO<br />
ESCREVA("Isso é bem caro!");<br />
</pre><br />
<br />
<pre><br />
SE minhaIdade DIFERENTE QUE suaIdade ENTÃO<br />
ESCREVA("Não temos a mesma idade!");<br />
</pre><br />
<br />
Apesar de toda flexibilidade no código que os parâmetros lógicos possibilitam, é fácil se perder usando-os e criando um código confuso e difícil de entender.<br />
Por exemplo:<br />
<br />
<pre><br />
SE(sol) ENTÃO<br />
SE (calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
</pre><br />
<br />
<pre><br />
SE(preço <= 10) ENTÃO<br />
ESCREVA("eu posso comprar isso")<br />
SE NÃO<br />
SE(dinheiro > 10) ENTÃO<br />
escreva("eu posso comprar isso")<br />
</pre><br />
<br />
Para isso possuímos operadores lógicos: <br />
<br />
== Operador 'E' ==<br />
<br />
//Explicar necessidade do operadores E<br />
O operador 'E', também chamado de conjunção, funciona como a palavra 'e', fornecendo a intercessão entre dois elementos. Para a condição ser cumprida os dois elementos precisam ser verdadeiros. <br />
Por exemplo: "Maria vai ao parque se estiver sol e calor", nesse exemplo Maria vai ao parque apenas se as duas condições forem cumpridas, se houver sol mas não estiver calor ou se não houver sol mas estiver calor Maria não vai ao parque.<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Sol <th>Calor<th>Ela vai ao parque?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Não<br />
<tr><th>Não<td>Sim<td>Não<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(sol E calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
SE NÃO<br />
ESCREVA("Maria não vai ao parque! :( ");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(sol && calor){<br />
printf("Maria vai ao parque! :) ");<br />
}else{<br />
printf("Maria não vai ao parque! :( ");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(sol && calor){<br />
cout << "Maria vai ao parque! :) ";<br />
}else{<br />
cout << "Maria não vai ao parque! :( ";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if sol and calor:<br />
print('Maria vai ao parque! :) ')<br />
else:<br />
print('Maria não vai ao parque! :( ')<br />
</pre><br />
<br />
==Operador 'OU'==<br />
<br />
//Explicar necessidade do operadores OU<br />
<br />
Diferente do operador lógico 'E' que necessita que ambos os parâmetros lógicos sejam verdadeiros para a condição ser cumprida, o operador 'OU' precisa que apenas um deles seja verdadeiro. Esse operador lógico só será falso quando ambos os parâmetros lógicos forem falsos.<br />
<br />
<table border="1" cellpadding="2"><br />
<caption>A tarefa foi feita?</caption><br />
<tr><th> Eu fiz <th> Você fez <th> A tarefa foi feita?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Sim<br />
<tr><th>Não<td>Sim<td>Sim<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(euFiz OU voceFez) ENTÃO<br />
ESCREVA("A tarefa foi feita");<br />
SE NÃO<br />
ESCREVA("A tarefa não foi feita");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(euFiz || voceFez){<br />
printf("A tarefa foi feita");<br />
}else{<br />
printf("A tarefa não foi feita");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(euFiz || voceFez){<br />
cout << "A tarefa foi feita";<br />
}else{<br />
cout << "A tarefa não foi feita";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if euFiz or voceFez:<br />
print('A tarefa foi feita')<br />
else:<br />
print('A tarefa não foi feita')<br />
</pre><br />
<br />
<br />
==Operador 'NÃO'==<br />
//Explicar necessidade do operadores NÃO<br />
Diferente dos outros operadores já citados esse operador necessita apenas de um parâmetro lógico para funcionar. A função desse operador é alterar a leitura do parâmetro lógico para seu valor inverso, se esse parâmetro possuir o valor 'verdadeiro', com esse operador, será se lido o valor 'falso', e se o parâmetro possuir o valor 'falso' será lido o valor 'verdadeiro'.<br />
Algumas das representações mais classicas do símbolo de negação são: ~, !, NOT, e ¬<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Valor <th> ~Valor<br />
<tr><th>Sim<td>Não<br />
<tr><th>Não<td>Sim<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(NÃO sol) ENTÃO<br />
ESCREVA("Está escuro");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(!sol){<br />
printf("Está escuro");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(!sol){<br />
cout << "Está escuro";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if not sol:<br />
print('Está escuro')<br />
<br />
</pre></div>Mapresteshttps://wiki.unicentro.br/index.php?title=Operadores_Logicos&diff=16262Operadores Logicos2020-06-21T22:09:08Z<p>Maprestes: </p>
<hr />
<div>Operadores lógicos, como operadores ariméticos<br />
<br />
As estruturas de programação, como a [Estruturas_de_Seleção | estrutura de seleção] e a [Estruturas_de_Repetição | estrutura de repetição] podem mudar o comportamento de um código. Dependendo de como o código está montado essas estruturas permitem a execução (ou repetição) de parte do código apenas em determinadas situações. O que vai decidir se o código dentro daquela estrutura deve ser executado (como em estruturas de seleção) ou se deve ser repetido 1 ou 10 vezes (como em estruturas de repetição) é seu parâmetro lógico.<br />
<br />
Os parâmetros lógicos podem ser verdadeiros ou falsos, se forem verdadeiros a condição é cumprida e o código dentro da estrutura é executado (ou repetido, dependendo da estrutura), se não, aquela area do código é ignorada ou redirecionada.<br />
<br />
Por exemplo:<br />
<br />
[Estruturas_de_Seleção || Estrutura de seleção]<br />
<pre><br />
SE chovendo ENTÃO<br />
ESCREVA("Melhor levar um guarda-chuva");<br />
<br />
</pre><br />
<br />
[Estruturas_de_Repetição | Estrutura de repetição]<br />
<pre><br />
ENQUANTO chovendo FAÇA<br />
ESCREVA("Não vou sair de casa, ainda está chovendo");<br />
<br />
ESCREVA("Finalmente parou de chover!");<br />
</pre><br />
<br />
Os exemplos acima possuem em seu parâmetro uma variável que pode ser verdadeira ou falsa, porem, os parâmetros lógicos também podem ser construidos como expressões aritméticas.<br />
<br />
Por exemplo:<br />
<pre><br />
SE idade MENOR QUE 18 ENTÃO<br />
ESCREVA("Você é menor de idade!");<br />
</pre><br />
<br />
<pre><br />
SE preço MAIOR OU IGUAL QUE 10 ENTÃO<br />
ESCREVA("Isso é bem caro!");<br />
</pre><br />
<br />
Apesar de toda flexibilidade no código que os parâmetros lógicos possibilitam, é fácil se perder usando-os e criando um código confuso e difícil de entender.<br />
Por exemplo:<br />
<br />
<pre><br />
SE(sol) ENTÃO<br />
SE (calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
</pre><br />
<br />
<pre><br />
SE(preço <= 10) ENTÃO<br />
ESCREVA("eu posso comprar isso")<br />
SE NÃO<br />
SE(dinheiro > 10) ENTÃO<br />
escreva("eu posso comprar isso")<br />
</pre><br />
<br />
Para isso possuímos operadores lógicos: <br />
<br />
== Operador 'E' ==<br />
<br />
//Explicar necessidade do operadores E<br />
O operador 'E', também chamado de conjunção, funciona como a palavra 'e', fornecendo a intercessão entre dois elementos. Para a condição ser cumprida os dois elementos precisam ser verdadeiros. <br />
Por exemplo: "Maria vai ao parque se estiver sol e calor", nesse exemplo Maria vai ao parque apenas se as duas condições forem cumpridas, se houver sol mas não estiver calor ou se não houver sol mas estiver calor Maria não vai ao parque.<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Sol <th>Calor<th>Ela vai ao parque?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Não<br />
<tr><th>Não<td>Sim<td>Não<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(sol E calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
SE NÃO<br />
ESCREVA("Maria não vai ao parque! :( ");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(sol && calor){<br />
printf("Maria vai ao parque! :) ");<br />
}else{<br />
printf("Maria não vai ao parque! :( ");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(sol && calor){<br />
cout << "Maria vai ao parque! :) ";<br />
}else{<br />
cout << "Maria não vai ao parque! :( ";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if sol and calor:<br />
print('Maria vai ao parque! :) ')<br />
else:<br />
print('Maria não vai ao parque! :( ')<br />
</pre><br />
<br />
==Operador 'OU'==<br />
<br />
//Explicar necessidade do operadores OU<br />
<br />
Diferente do operador lógico 'E' que necessita que ambos os parâmetros lógicos sejam verdadeiros para a condição ser cumprida, o operador 'OU' precisa que apenas um deles seja verdadeiro. Esse operador lógico só será falso quando ambos os parâmetros lógicos forem falsos.<br />
<br />
<table border="1" cellpadding="2"><br />
<caption>A tarefa foi feita?</caption><br />
<tr><th> Eu fiz <th> Você fez <th> A tarefa foi feita?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Sim<br />
<tr><th>Não<td>Sim<td>Sim<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(euFiz OU voceFez) ENTÃO<br />
ESCREVA("A tarefa foi feita");<br />
SE NÃO<br />
ESCREVA("A tarefa não foi feita");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(euFiz || voceFez){<br />
printf("A tarefa foi feita");<br />
}else{<br />
printf("A tarefa não foi feita");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(euFiz || voceFez){<br />
cout << "A tarefa foi feita";<br />
}else{<br />
cout << "A tarefa não foi feita";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if euFiz or voceFez:<br />
print('A tarefa foi feita')<br />
else:<br />
print('A tarefa não foi feita')<br />
</pre><br />
<br />
<br />
==Operador 'NÃO'==<br />
//Explicar necessidade do operadores NÃO<br />
Diferente dos outros operadores já citados esse operador necessita apenas de um parâmetro lógico para funcionar. A função desse operador é alterar a leitura do parâmetro lógico para seu valor inverso, se esse parâmetro possuir o valor 'verdadeiro', com esse operador, será se lido o valor 'falso', e se o parâmetro possuir o valor 'falso' será lido o valor 'verdadeiro'.<br />
Algumas das representações mais classicas do símbolo de negação são: ~, !, NOT, e ¬<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Valor <th> ~Valor<br />
<tr><th>Sim<td>Não<br />
<tr><th>Não<td>Sim<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(NÃO sol) ENTÃO<br />
ESCREVA("Está escuro");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(!sol){<br />
printf("Está escuro");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(!sol){<br />
cout << "Está escuro";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if not sol:<br />
print('Está escuro')<br />
<br />
</pre></div>Mapresteshttps://wiki.unicentro.br/index.php?title=Operadores_Logicos&diff=16261Operadores Logicos2020-06-21T22:04:44Z<p>Maprestes: </p>
<hr />
<div>Operadores lógicos, como operadores ariméticos<br />
<br />
As estruturas de programação, como a [Estruturas_de_Seleção | estrutura de seleção] e a [Estruturas_de_Repetição | estrutura de repetição] podem mudar o comportamento de um código. Dependendo de como o código está montado essas estruturas permitem a execução (ou repetição) de parte do código apenas em determinadas situações. O que vai decidir se o código dentro daquela estrutura deve ser executado (como em estruturas de seleção) ou se deve ser repetido 1 ou 10 vezes (como em estruturas de repetição) é seu parâmetro lógico.<br />
<br />
Os parâmetros lógicos podem ser verdadeiros ou falsos, se forem verdadeiros a condição é cumprida e o código dentro da estrutura é executado (ou repetido, dependendo da estrutura), se não, aquela area do código é ignorada ou redirecionada.<br />
<br />
Por exemplo:<br />
<br />
[Estruturas_de_Seleção || Estrutura de seleção]<br />
<pre><br />
SE chovendo ENTÃO<br />
ESCREVA("Melhor levar um guarda-chuva");<br />
<br />
</pre><br />
<br />
[Estruturas_de_Repetição | Estrutura de repetição]<br />
<pre><br />
ENQUANTO chovendo FAÇA<br />
ESCREVA("Não vou sair de casa, ainda está chovendo");<br />
<br />
ESCREVA("Finalmente parou de chover!");<br />
</pre><br />
<br />
Os exemplos acima possuem em seu parâmetro uma variável que pode ser verdadeira ou falsa, porem, os parâmetros lógicos também podem ser construidos como expressões aritméticas.<br />
<br />
Por exemplo:<br />
<pre><br />
SE idade MENOR QUE 18 ENTÃO<br />
ESCREVA("Você é menor de idade!");<br />
</pre><br />
<br />
<pre><br />
SE preço MAIOR OU IGUAL QUE 10 ENTÃO<br />
ESCREVA("Isso é bem caro!");<br />
</pre><br />
<br />
Apesar de toda flexibilidade no código que os parâmetros lógicos possibilitam, é fácil se perder usando-os e criando um código confuso e difícil de entender.<br />
Por exemplo:<br />
<br />
<pre><br />
SE(sol) ENTÃO<br />
SE (calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
</pre><br />
<br />
<pre><br />
SE(preço <= 10) ENTÃO<br />
ESCREVA("eu posso comprar isso")<br />
SE NÃO<br />
SE(dinheiro > 10) ENTÃO<br />
escreva("eu posso comprar isso")<br />
</pre><br />
<br />
Para isso possuímos operadores lógicos: <br />
<br />
== Operador 'E' ==<br />
<br />
//Explicar necessidade do operadores E<br />
O operador 'E', também chamado de conjunção, funciona como a palavra 'e', fornecendo a intercessão entre dois elementos. Para a condição ser cumprida os dois elementos precisam ser verdadeiros. <br />
Por exemplo: "Maria vai ao parque se estiver sol e calor", nesse exemplo Maria vai ao parque apenas se as duas condições forem cumpridas, se houver sol mas não estiver calor ou se não houver sol mas estiver calor Maria não vai ao parque.<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Sol <th>Calor<th>Ela vai ao parque?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Não<br />
<tr><th>Não<td>Sim<td>Não<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(sol E calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
SE NÃO<br />
ESCREVA("Maria não vai ao parque! :( ");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(sol && calor){<br />
printf("Maria vai ao parque! :) ");<br />
}else{<br />
printf("Maria não vai ao parque! :( ");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(sol && calor){<br />
cout << "Maria vai ao parque! :) ";<br />
}else{<br />
cout << "Maria não vai ao parque! :( ";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if sol and calor:<br />
print('Maria vai ao parque! :) ')<br />
else:<br />
print('Maria não vai ao parque! :( ')<br />
</pre><br />
<br />
==Operador 'OU'==<br />
<br />
//Explicar necessidade do operadores OU<br />
<br />
Diferente do operador lógico 'E' que necessita que ambos os parâmetros lógicos sejam verdadeiros para a condição ser cumprida, o operador 'OU' precisa que apenas um deles seja verdadeiro. Esse operador lógico só será falso quando ambos os parâmetros lógicos forem falsos.<br />
<br />
<table border="1" cellpadding="2"><br />
<caption>A tarefa foi feita?</caption><br />
<tr><th> Eu fiz <th> Você fez <th> A tarefa foi feita?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Sim<br />
<tr><th>Não<td>Sim<td>Sim<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(euFiz OU voceFez) ENTÃO<br />
ESCREVA("A tarefa foi feita");<br />
SE NÃO<br />
ESCREVA("A tarefa não foi feita");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(euFiz || voceFez){<br />
printf("A tarefa foi feita");<br />
}else{<br />
printf("A tarefa não foi feita");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(euFiz || voceFez){<br />
cout << "A tarefa foi feita";<br />
}else{<br />
cout << "A tarefa não foi feita";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if euFiz or voceFez:<br />
print('A tarefa foi feita')<br />
else:<br />
print('A tarefa não foi feita')<br />
</pre><br />
<br />
<br />
==Operador 'NÃO'==<br />
//Explicar necessidade do operadores NÃO<br />
Diferente dos outros operadores já citados esse operador necessita apenas de um parâmetro lógico para funcionar. A função desse operador é alterar a leitura do parâmetro lógico para seu valor inverso, se esse parâmetro possuir o valor 'verdadeiro', com esse operador, será se lido o valor 'falso', e se o parâmetro possuir o valor 'falso' será lido o valor 'verdadeiro'.<br />
Algumas das representações mais classicas do símbolo de negação são: ~, !, NOT, e ¬<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Valor <th> ~Valor<br />
<tr><th>Sim<td>Não<br />
<tr><th>Não<td>Sim<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(NÃO sol) ENTÃO<br />
ESCREVA("Está escuro");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(!sol){<br />
printf("Está escuro");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(!sol){<br />
cout << "Está escuro";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if NOT sol:<br />
print('Está escuro')<br />
<br />
</pre></div>Mapresteshttps://wiki.unicentro.br/index.php?title=Operadores_Logicos&diff=16260Operadores Logicos2020-06-21T21:51:48Z<p>Maprestes: </p>
<hr />
<div>Operadores lógicos, como operadores ariméticos<br />
<br />
As estruturas de programação, como a [Estruturas_de_Seleção | estrutura de seleção] e a [Estruturas_de_Repetição | estrutura de repetição] podem mudar o comportamento de um código. Dependendo de como o código está montado essas estruturas permitem a execução (ou repetição) de parte do código apenas em determinadas situações. O que vai decidir se o código dentro daquela estrutura deve ser executado (como em estruturas de seleção) ou se deve ser repetido 1 ou 10 vezes (como em estruturas de repetição) é seu parâmetro lógico.<br />
<br />
Os parâmetros lógicos podem ser verdadeiros ou falsos, se forem verdadeiros a condição é cumprida e o código dentro da estrutura é executado (ou repetido, dependendo da estrutura), se não, aquela area do código é ignorada ou redirecionada.<br />
<br />
Por exemplo:<br />
<br />
[Estruturas_de_Seleção || Estrutura de seleção]<br />
<pre><br />
SE chovendo ENTÃO<br />
ESCREVA("Melhor levar um guarda-chuva");<br />
<br />
</pre><br />
<br />
[Estruturas_de_Repetição | Estrutura de repetição]<br />
<pre><br />
ENQUANTO chovendo FAÇA<br />
ESCREVA("Não vou sair de casa, ainda está chovendo");<br />
<br />
ESCREVA("Finalmente parou de chover!");<br />
</pre><br />
<br />
Os exemplos acima possuem em seu parâmetro uma variável que pode ser verdadeira ou falsa, porem, os parâmetros lógicos também podem ser construidos como expressões aritméticas.<br />
<br />
Por exemplo:<br />
<pre><br />
SE idade MENOR QUE 18 ENTÃO<br />
ESCREVA("Você é menor de idade!");<br />
</pre><br />
<br />
<pre><br />
SE preço MAIOR OU IGUAL QUE 10 ENTÃO<br />
ESCREVA("Isso é bem caro!");<br />
</pre><br />
<br />
Apesar de toda flexibilidade no código que os parâmetros lógicos possibilitam, é fácil se perder usando-os e criando um código confuso e difícil de entender.<br />
Por exemplo:<br />
<br />
<pre><br />
SE(sol) ENTÃO<br />
SE (calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
</pre><br />
<br />
<pre><br />
SE(preço <= 10) ENTÃO<br />
ESCREVA("eu posso comprar isso")<br />
SE NÃO<br />
SE(dinheiro > 10) ENTÃO<br />
escreva("eu posso comprar isso")<br />
</pre><br />
<br />
Para isso possuímos operadores lógicos: <br />
<br />
== Operador 'E' ==<br />
<br />
//Explicar necessidade do operadores E<br />
O operador 'E', também chamado de conjunção, funciona como a palavra 'e', fornecendo a intercessão entre dois elementos. Para a condição ser cumprida os dois elementos precisam ser verdadeiros. <br />
Por exemplo: "Maria vai ao parque se estiver sol e calor", nesse exemplo Maria vai ao parque apenas se as duas condições forem cumpridas, se houver sol mas não estiver calor ou se não houver sol mas estiver calor Maria não vai ao parque.<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Sol <th>Calor<th>Ela vai ao parque?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Não<br />
<tr><th>Não<td>Sim<td>Não<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(sol E calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
SE NÃO<br />
ESCREVA("Maria não vai ao parque! :( ");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(sol && calor){<br />
printf("Maria vai ao parque! :) ");<br />
}else{<br />
printf("Maria não vai ao parque! :( ");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(sol && calor){<br />
cout << "Maria vai ao parque! :) ";<br />
}else{<br />
cout << "Maria não vai ao parque! :( ";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if sol and calor:<br />
print('Maria vai ao parque! :) ')<br />
else:<br />
print('Maria não vai ao parque! :( ')<br />
</pre><br />
<br />
==Operador 'OU'==<br />
<br />
//Explicar necessidade do operadores OU<br />
<br />
Diferente do operador lógico 'E' que necessita que ambos os parâmetros lógicos sejam verdadeiros para a condição ser cumprida, o operador 'OU' precisa que apenas um deles seja verdadeiro. Esse operador lógico só será falso quando ambos os parâmetros lógicos forem falsos.<br />
<br />
<table border="1" cellpadding="2"><br />
<caption>A tarefa foi feita?</caption><br />
<tr><th> Eu fiz <th> Você fez <th> A tarefa foi feita?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Sim<br />
<tr><th>Não<td>Sim<td>Sim<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(euFiz OU voceFez) ENTÃO<br />
ESCREVA("A tarefa foi feita");<br />
SE NÃO<br />
ESCREVA("A tarefa não foi feita");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(euFiz || voceFez){<br />
printf("A tarefa foi feita");<br />
}else{<br />
printf("A tarefa não foi feita");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(euFiz || voceFez){<br />
cout << "A tarefa foi feita";<br />
}else{<br />
cout << "A tarefa não foi feita";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if euFiz or voceFez:<br />
print('A tarefa foi feita')<br />
else:<br />
print('A tarefa não foi feita')<br />
</pre><br />
<br />
<br />
==Operador 'NÃO'==<br />
//Explicar necessidade do operadores NÃO<br />
Diferente dos outros operadores já citados esse operador necessita apenas de um parâmetro lógico para funcionar. A função desse operador é alterar a leitura do parâmetro lógico para seu valor inverso, se esse parâmetro possuir o valor 'verdadeiro', com esse operador, será se lido o valor 'falso', e se o parâmetro possuir o valor 'falso' será lido o valor 'verdadeiro'.<br />
Algumas das representações mais classicas do símbolo de negação são: ~, !, NOT, e ¬<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Valor <th> ~Valor<br />
<tr><th>Sim<td>Não<br />
<tr><th>Não<td>Sim<br />
<br />
<pre><br />
//resolver um exemplo nas linguagens C, c++, python, e pseudo código<br />
</pre></div>Mapresteshttps://wiki.unicentro.br/index.php?title=Operadores_Logicos&diff=16259Operadores Logicos2020-06-21T21:30:41Z<p>Maprestes: </p>
<hr />
<div>Operadores lógicos, como operadores ariméticos<br />
<br />
As estruturas de programação, como a [Estruturas_de_Seleção | estrutura de seleção] e a [Estruturas_de_Repetição | estrutura de repetição] podem mudar o comportamento de um código. Dependendo de como o código está montado essas estruturas permitem a execução (ou repetição) de parte do código apenas em determinadas situações. O que vai decidir se o código dentro daquela estrutura deve ser executado (como em estruturas de seleção) ou se deve ser repetido 1 ou 10 vezes (como em estruturas de repetição) é seu parâmetro lógico.<br />
<br />
Os parâmetros lógicos podem ser verdadeiros ou falsos, se forem verdadeiros a condição é cumprida e o código dentro da estrutura é executado (ou repetido, dependendo da estrutura), se não, aquela area do código é ignorada ou redirecionada.<br />
<br />
Por exemplo:<br />
<br />
[Estruturas_de_Seleção || Estrutura de seleção]<br />
<pre><br />
SE chovendo ENTÃO<br />
ESCREVA("Melhor levar um guarda-chuva");<br />
<br />
</pre><br />
<br />
[Estruturas_de_Repetição | Estrutura de repetição]<br />
<pre><br />
ENQUANTO chovendo FAÇA<br />
ESCREVA("Não vou sair de casa, ainda está chovendo");<br />
<br />
ESCREVA("Finalmente parou de chover!");<br />
</pre><br />
<br />
Os exemplos acima possuem em seu parâmetro uma variável que pode ser verdadeira ou falsa, porem, os parâmetros lógicos também podem ser construidos como expressões aritméticas.<br />
<br />
Por exemplo:<br />
<pre><br />
SE idade MENOR QUE 18 ENTÃO<br />
ESCREVA("Você é menor de idade!");<br />
</pre><br />
<br />
<pre><br />
SE preço MAIOR OU IGUAL QUE 10 ENTÃO<br />
ESCREVA("Isso é bem caro!");<br />
</pre><br />
<br />
Apesar de toda flexibilidade no código que os parâmetros lógicos possibilitam, é fácil se perder usando-os e criando um código confuso e difícil de entender.<br />
Por exemplo:<br />
<br />
<pre><br />
SE(sol) ENTÃO<br />
SE (calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
</pre><br />
<br />
<pre><br />
SE(preço <= 10) ENTÃO<br />
ESCREVA("eu posso comprar isso")<br />
SE NÃO<br />
SE(dinheiro > 10) ENTÃO<br />
escreva("eu posso comprar isso")<br />
</pre><br />
<br />
Para isso possuímos operadores lógicos: <br />
<br />
== Operador 'E' ==<br />
<br />
//Explicar necessidade do operadores E<br />
O operador 'E', também chamado de conjunção, funciona como a palavra 'e', fornecendo a intercessão entre dois elementos. Para a condição ser cumprida os dois elementos precisam ser verdadeiros. <br />
Por exemplo: "Maria vai ao parque se estiver sol e calor", nesse exemplo Maria vai ao parque apenas se as duas condições forem cumpridas, se houver sol mas não estiver calor ou se não houver sol mas estiver calor Maria não vai ao parque.<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Sol <th>Calor<th>Ela vai ao parque?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Não<br />
<tr><th>Não<td>Sim<td>Não<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(sol E calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
SE NÃO<br />
ESCREVA("Maria não vai ao parque! :( ");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(sol && calor){<br />
printf("Maria vai ao parque! :) ");<br />
}else{<br />
printf("Maria não vai ao parque! :( ");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(sol && calor){<br />
cout << "Maria vai ao parque! :) ";<br />
}else{<br />
cout << "Maria não vai ao parque! :( ";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if sol and calor:<br />
print('Maria vai ao parque! :) ')<br />
else:<br />
print('Maria não vai ao parque! :( ')<br />
</pre><br />
<br />
==Operador 'OU'==<br />
<br />
//Explicar necessidade do operadores OU<br />
<br />
Diferente do operador lógico 'E' que necessita que ambos os parâmetros lógicos sejam verdadeiros para a condição ser cumprida, o operador 'OU' precisa que apenas um deles seja verdadeiro. Esse operador lógico só será falso quando ambos os parâmetros lógicos forem falsos.<br />
<br />
<table border="1" cellpadding="2"><br />
<caption>A tarefa foi feita?</caption><br />
<tr><th> Eu fiz <th> Você fez <th> A tarefa foi feita?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Sim<br />
<tr><th>Não<td>Sim<td>Sim<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(euFiz OU voceFez) ENTÃO<br />
ESCREVA("A tarefa foi feita");<br />
SE NÃO<br />
ESCREVA("A tarefa não foi feita");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(euFiz || voceFez){<br />
printf("A tarefa foi feita");<br />
}else{<br />
printf("A tarefa não foi feita");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(euFiz || voceFez){<br />
cout << "A tarefa foi feita";<br />
}else{<br />
cout << "A tarefa não foi feita";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if euFiz or voceFez:<br />
print('A tarefa foi feita')<br />
else:<br />
print('A tarefa não foi feita')<br />
</pre><br />
<br />
<br />
==Operador 'NÃO'==<br />
//Explicar necessidade do operadores NÃO<br />
Diferente dos outros operadores já citados esse operador necessita apenas de um parâmetro lógico para funcionar. A função desse operador é alterar a leitura do parâmetro lógico para seu valor inverso, se esse parâmetro possuir o valor 'verdadeiro', com esse operador, será se lido o valor 'falso', e se o parâmetro possuir o valor 'falso' será lido o valor 'verdadeiro'.<br />
<br />
<br />
<pre><br />
//resolver um exemplo nas linguagens C, c++, python, e pseudo código<br />
</pre></div>Mapresteshttps://wiki.unicentro.br/index.php?title=Operadores_Logicos&diff=16258Operadores Logicos2020-06-20T21:29:40Z<p>Maprestes: </p>
<hr />
<div>Operadores lógicos, como operadores ariméticos<br />
<br />
As estruturas de programação, como a [Estruturas_de_Seleção | estrutura de seleção] e a [Estruturas_de_Repetição | estrutura de repetição] podem mudar o comportamento de um código, dependendo de como o código está montado essas estruturas permitem a execução (ou repetição) de parte do código apenas em determinadas situações.O que vai decidir se o código dentro daquela estrutura deve ser executado (como em estruturas de seleção) ou se deve ser repetido 1 ou 10 vezes (como em estruturas de repetição) é seu parâmetro lógico.<br />
<br />
Os parâmetros lógicos podem ser verdadeiros ou falsos, se forem verdadeiros a condição é cumprida e o código dentro da estrutura é executado (ou repetido, dependendo da estrutura), se não, aquela area do código é ignorado ou redirecionada.<br />
<br />
Por exemplo:<br />
<br />
[Estruturas_de_Seleção || Estrutura de seleção]<br />
<pre><br />
SE chovendo ENTÃO<br />
ESCREVA("Melhor levar um guarda-chuva");<br />
<br />
</pre><br />
<br />
[Estruturas_de_Repetição | Estrutura de repetição]<br />
<pre><br />
ENQUANTO chovendo FAÇA<br />
ESCREVA("Não vou sair de casa, ainda está chovendo");<br />
<br />
ESCREVA("Finalmente parou de chover!");<br />
</pre><br />
<br />
Os exemplos acima possuem em seu parâmetro uma variável que pode ser verdadeira ou falsa, porem, os parâmetros lógicos também podem ser construidos como expressões aritméticas.<br />
<br />
Por exemplo:<br />
<pre><br />
SE idade MENOR QUE 18 ENTÃO<br />
ESCREVA("Você é menor de idade!");<br />
</pre><br />
<br />
<pre><br />
SE preço MAIOR OU IGUAL QUE 10 ENTÃO<br />
ESCREVA("Isso é bem caro!");<br />
</pre><br />
<br />
Apesar de toda flexibilidade no código que os parâmetros lógicos possibilitam, é fácil se perder usando-os e criando um código confuso e difícil de entender.<br />
Por exemplo:<br />
<br />
<pre><br />
SE(sol) ENTÃO<br />
SE (calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
</pre><br />
<br />
<pre><br />
SE(preço <= 10) ENTÃO<br />
ESCREVA("eu posso comprar isso")<br />
SE NÃO<br />
SE(dinheiro > 10) ENTÃO<br />
escreva("eu posso comprar isso")<br />
</pre><br />
<br />
Para isso possuímos operadores lógicos: <br />
<br />
== Operador 'E' ==<br />
<br />
//Explicar necessidade do operadores E<br />
O operador 'E', também chamado de conjunção, funciona como a palavra 'e', fornecendo a intercessão entre dois elementos. Para a condição ser cumprida os dois elementos precisam ser verdadeiros. <br />
Por exemplo: "Maria vai ao parque se estiver sol e calor", nesse exemplo Maria vai ao parque apenas se as duas condições forem cumpridas, se houver sol mas não estiver calor ou se não houver sol mas estiver calor Maria não vai ao parque.<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Sol <th>Calor<th>Ela vai ao parque?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Não<br />
<tr><th>Não<td>Sim<td>Não<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(sol E calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
SE NÃO<br />
ESCREVA("Maria não vai ao parque! :( ");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(sol && calor){<br />
printf("Maria vai ao parque! :) ");<br />
}else{<br />
printf("Maria não vai ao parque! :( ");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(sol && calor){<br />
cout << "Maria vai ao parque! :) ";<br />
}else{<br />
cout << "Maria não vai ao parque! :( ";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if sol and calor:<br />
print('Maria vai ao parque! :) ')<br />
else:<br />
print('Maria não vai ao parque! :( ')<br />
</pre><br />
<br />
==Operador 'OU'==<br />
<br />
//Explicar necessidade do operadores OU<br />
<br />
Diferente do operador lógico 'E' que necessita que ambos os parâmetros lógicos sejam verdadeiros para a condição ser cumprida, o operador 'OU' precisa que apenas um deles seja verdadeiro. Esse operador lógico só será falso quando ambos os parâmetros lógicos forem falsos.<br />
<br />
<table border="1" cellpadding="2"><br />
<caption>A tarefa foi feita?</caption><br />
<tr><th> Eu fiz <th> Você fez <th> A tarefa foi feita?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Sim<br />
<tr><th>Não<td>Sim<td>Sim<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(euFiz OU voceFez) ENTÃO<br />
ESCREVA("A tarefa foi feita");<br />
SE NÃO<br />
ESCREVA("A tarefa não foi feita");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(euFiz || voceFez){<br />
printf("A tarefa foi feita");<br />
}else{<br />
printf("A tarefa não foi feita");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(euFiz || voceFez){<br />
cout << "A tarefa foi feita";<br />
}else{<br />
cout << "A tarefa não foi feita";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if euFiz or voceFez:<br />
print('A tarefa foi feita')<br />
else:<br />
print('A tarefa não foi feita')<br />
</pre><br />
<br />
<br />
==Operador 'NÃO'==<br />
//Explicar necessidade do operadores NÃO<br />
<br />
<pre><br />
//resolver um exemplo nas linguagens C, c++, python, e pseudo código<br />
</pre></div>Mapresteshttps://wiki.unicentro.br/index.php?title=Operadores_Logicos&diff=16257Operadores Logicos2020-06-20T21:25:42Z<p>Maprestes: </p>
<hr />
<div>Operadores lógicos, como operadores ariméticos<br />
<br />
As estruturas de programação, como a [Estruturas_de_Seleção | estrutura de seleção] e a [Estruturas_de_Repetição | estrutura de repetição] podem mudar o comportamento de um código, dependendo de como o código está montado essas estruturas permitem a execução (ou repetição) de parte do código apenas em determinadas situações.O que vai decidir se o código dentro daquela estrutura deve ser executado (como em estruturas de seleção) ou se deve ser repetido 1 ou 10 vezes (como em estruturas de repetição) é seu parâmetro lógico.<br />
<br />
Os parâmetros lógicos podem ser verdadeiros ou falsos, se forem verdadeiros a condição é cumprida e o código dentro da estrutura é executado (ou repetido, dependendo da estrutura), se não, aquela area do código é ignorado ou redirecionada.<br />
<br />
Por exemplo:<br />
<br />
[Estruturas_de_Seleção || Estrutura de seleção]<br />
<pre><br />
SE chovendo ENTÃO<br />
ESCREVA("Melhor levar um guarda-chuva");<br />
<br />
</pre><br />
<br />
[Estruturas_de_Repetição | Estrutura de repetição]<br />
<pre><br />
ENQUANTO chovendo FAÇA<br />
ESCREVA("Não vou sair de casa, ainda está chovendo");<br />
<br />
ESCREVA("Finalmente parou de chover!");<br />
</pre><br />
<br />
Os exemplos acima possuem em seu parâmetro uma variável que pode ser verdadeira ou falsa, porem, os parâmetros lógicos também podem ser construidos como expressões aritméticas.<br />
<br />
Por exemplo:<br />
<pre><br />
SE idade MENOR QUE 18 ENTÃO<br />
ESCREVA("Você é menor de idade!");<br />
</pre><br />
<br />
<pre><br />
SE preço MAIOR OU IGUAL QUE 10 ENTÃO<br />
ESCREVA("Isso é bem caro!");<br />
</pre><br />
<br />
Apesar de toda flexibilidade no código que os parâmetros lógicos possibilitam, é fácil se perder usando-os e criando um código confuso e difícil de entender.<br />
Por exemplo:<br />
<br />
<pre><br />
SE(sol) ENTÃO<br />
SE (calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
</pre><br />
<br />
<pre><br />
SE(preço <= 10) ENTÃO<br />
ESCREVA("eu posso comprar isso")<br />
SE NÃO<br />
SE(dinheiro > 10) ENTÃO<br />
escreva("eu posso comprar isso")<br />
</pre><br />
<br />
Para isso possuímos operadores lógicos: <br />
<br />
== Operador 'E' ==<br />
<br />
//Explicar necessidade do operadores E<br />
O operador 'E', também chamado de conjunção, funciona como a palavra 'e', fornecendo a intercessão entre dois elementos. Para a condição ser cumprida os dois elementos precisam ser verdadeiros. <br />
Por exemplo: "Maria vai ao parque se estiver sol e calor", nesse exemplo Maria vai ao parque apenas se as duas condições forem cumpridas, se houver sol mas não estiver calor ou se não houver sol mas estiver calor Maria não vai ao parque.<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Sol <th>Calor<th>Ela vai ao parque?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Não<br />
<tr><th>Não<td>Sim<td>Não<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(sol E calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
SE NÃO<br />
ESCREVA("Maria não vai ao parque! :( ");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(sol && calor){<br />
printf("Maria vai ao parque! :) ");<br />
}else{<br />
printf("Maria não vai ao parque! :( ");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(sol && calor){<br />
cout << "Maria vai ao parque! :) ";<br />
}else{<br />
cout << "Maria não vai ao parque! :( ";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if sol and calor:<br />
print('Maria vai ao parque! :) ')<br />
else:<br />
print('Maria não vai ao parque! :( ')<br />
</pre><br />
<br />
==Operador 'OU'==<br />
<br />
//Explicar necessidade do operadores OU<br />
<br />
Diferente do operador lógico 'E' que necessita que ambos os parâmetros lógicos sejam verdadeiros para a condição ser cumprida, o operador 'OU' precisa que apenas um deles seja verdadeiro. Esse operador lógico só será falso quando ambos os parâmetros lógicos forem falsos.<br />
<br />
<table border="1" cellpadding="2"><br />
<caption>A tarefa foi feita?</caption><br />
<tr><th> Eu fiz <th> Você fez <th> A tarefa foi feita?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Sim<br />
<tr><th>Não<td>Sim<td>Sim<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(euFiz OU voceFez) ENTÃO<br />
ESCREVA("A tarefa foi feita");<br />
SE NÃO<br />
ESCREVA("A tarefa não foi feita");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(euFiz || voceFez){<br />
printf("A tarefa foi feita");<br />
}else{<br />
printf("A tarefa não foi feita");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(euFiz || voceFez){<br />
cout << "A tarefa foi feita";<br />
}else{<br />
cout << "A tarefa não foi feita";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if sol or calor:<br />
print('A tarefa foi feita')<br />
else:<br />
print('A tarefa não foi feita')<br />
</pre><br />
<br />
<br />
==Operador 'NÃO'==<br />
//Explicar necessidade do operadores NÃO<br />
<br />
<pre><br />
//resolver um exemplo nas linguagens C, c++, python, e pseudo código<br />
</pre></div>Mapresteshttps://wiki.unicentro.br/index.php?title=Operadores_Logicos&diff=16256Operadores Logicos2020-06-20T21:08:40Z<p>Maprestes: /* Operador 'OU' */</p>
<hr />
<div>Operadores lógicos, como operadores ariméticos<br />
<br />
As estruturas de programação, como a [Estruturas_de_Seleção | estrutura de seleção] e a [Estruturas_de_Repetição | estrutura de repetição] podem mudar o comportamento de um código, dependendo de como o código está montado essas estruturas permitem a execução (ou repetição) de parte do código apenas em determinadas situações.O que vai decidir se o código dentro daquela estrutura deve ser executado (como em estruturas de seleção) ou se deve ser repetido 1 ou 10 vezes (como em estruturas de repetição) é seu parâmetro lógico.<br />
<br />
Os parâmetros lógicos podem ser verdadeiros ou falsos, se forem verdadeiros a condição é cumprida e o código dentro da estrutura é executado (ou repetido, dependendo da estrutura), se não, aquela area do código é ignorado ou redirecionada.<br />
<br />
Por exemplo:<br />
<br />
[Estruturas_de_Seleção || Estrutura de seleção]<br />
<pre><br />
SE chovendo ENTÃO<br />
ESCREVA("Melhor levar um guarda-chuva");<br />
<br />
</pre><br />
<br />
[Estruturas_de_Repetição | Estrutura de repetição]<br />
<pre><br />
ENQUANTO chovendo FAÇA<br />
ESCREVA("Não vou sair de casa, ainda está chovendo");<br />
<br />
ESCREVA("Finalmente parou de chover!");<br />
</pre><br />
<br />
Os exemplos acima possuem em seu parâmetro uma variável que pode ser verdadeira ou falsa, porem, os parâmetros lógicos também podem ser construidos como expressões aritméticas.<br />
<br />
Por exemplo:<br />
<pre><br />
SE idade MENOR QUE 18 ENTÃO<br />
ESCREVA("Você é menor de idade!");<br />
</pre><br />
<br />
<pre><br />
SE preço MAIOR OU IGUAL QUE 10 ENTÃO<br />
ESCREVA("Isso é bem caro!");<br />
</pre><br />
<br />
Apesar de toda flexibilidade no código que os parâmetros lógicos possibilitam, é fácil se perder usando-os e criando um código confuso e difícil de entender.<br />
Por exemplo:<br />
<br />
<pre><br />
SE(sol) ENTÃO<br />
SE (calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
</pre><br />
<br />
<pre><br />
SE(preço <= 10) ENTÃO<br />
ESCREVA("eu posso comprar isso")<br />
SE NÃO<br />
SE(dinheiro > 10) ENTÃO<br />
escreva("eu posso comprar isso")<br />
</pre><br />
<br />
Para isso possuímos operadores lógicos: <br />
<br />
== Operador 'E' ==<br />
<br />
//Explicar necessidade do operadores E<br />
O operador 'E', também chamado de conjunção, funciona como a palavra 'e', fornecendo a intercessão entre dois elementos. Para a condição ser cumprida os dois elementos precisam ser verdadeiros. <br />
Por exemplo: "Maria vai ao parque se estiver sol e calor", nesse exemplo Maria vai ao parque apenas se as duas condições forem cumpridas, se houver sol mas não estiver calor ou se não houver sol mas estiver calor Maria não vai ao parque.<br />
<br />
//TABELA VERDADE<br />
<table border="1" cellpadding="2"><br />
<caption>Maria vai ao parque?</caption><br />
<tr><th> Sol <th>Calor<th>Ela vai ao parque?<br />
<tr><th>Sim<td>Sim<td>Sim<br />
<tr><th>Sim<td>Não<td>Não<br />
<tr><th>Não<td>Sim<td>Não<br />
<tr><th>Não<td>Não<td>Não<br />
</table><br />
<br />
<pre><br />
Pseudocódigo <br />
<br />
SE(sol E calor) ENTÃO<br />
ESCREVA("Maria vai ao parque! :) ");<br />
SE NÃO<br />
ESCREVA("Maria não vai ao parque! :( ");<br />
<br />
________________________<br />
<br />
Linguagem C<br />
<br />
if(sol && calor){<br />
printf("Maria vai ao parque! :) ");<br />
}else{<br />
printf("Maria não vai ao parque! :( ");<br />
}<br />
________________________<br />
<br />
C++<br />
<br />
if(sol && calor){<br />
cout << "Maria vai ao parque! :) ";<br />
}else{<br />
cout << "Maria não vai ao parque! :( ";<br />
}<br />
________________________<br />
<br />
Python<br />
<br />
if sol and calor:<br />
print('Maria vai ao parque! :) ')<br />
else:<br />
print('Maria não vai ao parque! :( ')<br />
</pre><br />
<br />
==Operador 'OU'==<br />
<br />
//Explicar necessidade do operadores OU<br />
<br />
Diferente do operador lógico 'E' que necessita que ambos os parâmetros lógicos sejam verdadeiros para a condição ser cumprida, o operador 'OU' precisa que apenas um deles seja verdadeiro. Esse operador lógico só será falso quando ambos os parâmetros lógicos forem falsos.<br />
<br />
<pre><br />
//resolver um exemplo nas linguagens C, c++, python, e pseudo código<br />
</pre><br />
<br />
==Operador 'NÃO'==<br />
<br />
//Explicar necessidade do operadores NÃO<br />
<br />
<pre><br />
//resolver um exemplo nas linguagens C, c++, python, e pseudo código<br />
</pre></div>Maprestes