Comentário por Rogério Júnior
Para ver o caderno de tarefas da primeira fase da Programação Nível Júnior da OBI 2016, clique aqui.
Plantação de morango
Conhecimento prévio necessário:
A entrada nos fornecerá os lados de dois retângulos, e pergunta qual dos dois tem a maior área. Vamos ler o comprimento e a largura do primeiro retângulo e salvar nos inteiros a1 e a2, respectivamente. Depois, iremos ler o comprimento e a largura do segundo retângulo e iremos salvar nos inteiros b1 e b2, respectivamente.
A área do primeiro retângulo é a1*a2, enquanto a área do segundo é b1*b2. Desse modo, se a área do primeiro for maior que a do segundo (“if(a1*a2>b1*b2)“) imprimimos o valor da área do primeiro (“printf(“%d\n”, a1*a2);“). Caso contrário (“else“) imprimo a área do segundo (“printf(“%d\n”, b1*b2);“).
Segue o código para melhor entendimento:
| // Plantação de Morango – F1PJ – OBI 2016 | |
| // Rogério Júnior | |
| // Complexidade: O(1) | |
| #include <cstdio> // scanf e printf | |
| int main(){ | |
| // declaro as variáveis que vou usar | |
| int a1, a2, b1, b2; | |
| // leio os valores dos lados dos retângulos | |
| scanf("%d %d %d %d", &a1, &a2, &b1, &b2); | |
| // se o primeiro retângulo tiver a maior área | |
| if(a1*a2>b1*b2){ | |
| // imprimo a área do primeiro retângulo | |
| printf("%d\n", a1*a2); | |
| } | |
| // caso contrário | |
| else{ | |
| // imprimo a área do segundo retângulo | |
| printf("%d\n", b1*b2); | |
| } | |
| // ao fim do programa, retorno 0 | |
| return 0; | |
| } |
Jogo de par ou ímpar
Conhecimento prévio necessário:
Vamos salvar os números fornecidos na entrada nos inteiros p, d1 e d2. Temos duas possibilidades: ou a soma dos números é par, ou é ímpar. Para que ela seja par, ela precisa deixar resto $$0$$ na divisão por dois. O operador de C++ que retorna resto na divisão é o %, ou seja (d1+d2)%2, retorna o resto da soma (d1+d2) na divisão por $$2$$.
Se a soma dos números for par, ou seja, deixa $$0$$ na divisão por $$2$$ (“if((d1+d2)%2==0)“), então ganha que pediu par. Se p for $$0$$ (“if(p==0)“), então Alice pediu par e vai ganhar, e devemos imprimir $$0$$ (“printf(“0\n”);“). Caso p seja diferente de $$0$$ (“else“), então Bob pediu par e ele irá ganhar (“printf(“1\n”)“).
Entretanto, caso a soma dos números não deixe resto $$0$$ na divisão por $$2$$ (“else“), então ela é ímpar e ganhará quem pediu ímpar. Se p for $$0$$ (“if(p==0)“), então Bob pediu ímpar e vai ganhar, e devemos imprimir $$1$$ (“printf(“1\n”);“). Caso p seja diferente de $$0$$ (“else“), então Alice pediu ímpar e ela irá ganhar (“printf(“0\n”)“).
Segue o código para melhor entendimento:
| // Jogo de par ou ímpar – F1PJ/F1P1 – OBI 2016 | |
| // Rogério Júnior | |
| // Complexidade: O(1) | |
| #include <cstdio> // scanf e printf | |
| int main(){ | |
| // declaro as variáveis que vou usar | |
| int p, d1, d2; | |
| // leio os valores de p, d1 e d2 | |
| scanf("%d %d %d", &p, &d1, &d2); | |
| // se a soma de d1 e d2 for par | |
| if((d1+d2)%2==0){ | |
| // então ganhará quem pediu par | |
| // se Alice pediu par | |
| if(p==0){ | |
| // então Alice ganha | |
| printf("0\n"); | |
| } | |
| // caso Alice não tenha pedido par | |
| else{ | |
| // então Bob ganha | |
| printf("1\n"); | |
| } | |
| } | |
| // se a soma de d1 e d2 não for par | |
| else{ | |
| // então quem pediu ímpar ganha | |
| // se Alice pediu par | |
| if(p==0){ | |
| // então Bob ganha | |
| printf("1\n"); | |
| } | |
| // se Alice não pediu par | |
| else{ | |
| // então Alice ganha | |
| printf("0\n"); | |
| } | |
| } | |
| // ao fim do programa, retorno 0 | |
| return 0; | |
| } |
Lâmpadas
Conhecimento prévio necessário:
Vamos usar os inteiros l1 e l2 para representar os estados das duas lâmpadas. Se l1 for $$1$$, então a lâmpada A está acesa. Se l1 for $$0$$, ela está apagada. De maneira análoga, a lâmpada B está acesa se l2 for $$1$$, e estará apagada de ele for $$0$$. Deste modo, como as duas lâmpadas começam apagadas, os dois inteiros começa com valor igual a zero.
Em seguida, vamos ler o valor de n, a quantidade de vezes que vamos apertar algum interruptor. Agora, usaremos um for para lermos cada um dos interruptores apertados. Para isso, vamos declarar o inteiro idx, que irá guardar qual interruptor foi apertado, então leremos o interruptor e guardaremos em idx.
Agora, dependendo de qual interruptor pressionamos, temos duas possibilidades: se for o primeiro interruptor (idx=$$1$$), então trocamos o estado da lâmpada A (se i1 for $$1$$, irá receber $$0$$, e se for $$0$$ receberá $$1$$ (“if(i1==1) i1=1; else i1=0;“)). Se, entretanto, o interruptor pressionado tiver sido o B, então trocamos o estado das duas lâmpadas, da mesma maneira que fizemos com a lâmpada A, no caso anterior.
Por fim, basta imprimirmos o valores em i1 e em i2. Segue o código para melhor entendimento:
| // Lâmpadas – F1PJ/F1P1 – OBI 2016 | |
| // Rogério Júnior | |
| // Complexidade: O(n) | |
| #include <cstdio> // scanf e printf | |
| int main(){ | |
| // declaro as variáveis que irei usar | |
| int i1=0, i2=0, n; | |
| // leio a quantidade de vezes que aperto um interruptor | |
| scanf("%d",&n); | |
| // para cada vez que apertamos um interruptor | |
| for(int i=0;i<n;i++){ | |
| // declaro idx | |
| int idx; | |
| // leio qual interruptor foi apertado e salvo em idx | |
| scanf("%d",&idx); | |
| // se apertei o interruptor 1 | |
| if(idx==1){ | |
| // troco o estado da lâmpada A | |
| // se ela estava acesa | |
| if(i1==1){ | |
| // então a apago | |
| i1=0; | |
| } | |
| // caso contrário, ela estava apagada | |
| else{ | |
| // então a acendo | |
| i1=1; | |
| } | |
| } | |
| // caso contrário, apertei o interruptor 2 | |
| else{ | |
| // troco o estado da lâmpada A | |
| // se ela estava acesa | |
| if(i1==1){ | |
| // então a apago | |
| i1=0; | |
| } | |
| // caso contrário, ela estava apagada | |
| else{ | |
| // então a acendo | |
| i1=1; | |
| } | |
| // troco o estado da lâmpada B | |
| // se ela estava acesa | |
| if(i2==1){ | |
| // então a apago | |
| i2=0; | |
| } | |
| // caso contrário, ela estava apagada | |
| else{ | |
| // então a acendo | |
| i2=1; | |
| } | |
| } | |
| } | |
| // por fim, imprimo os estados das lâmpadas | |
| printf("%d\n%d\n",i1,i2); | |
| return 0; | |
| } |
