diff --git a/_layouts/template.html b/_layouts/template.html
index 97462d9..d0a6ea0 100644
--- a/_layouts/template.html
+++ b/_layouts/template.html
@@ -15,6 +15,15 @@
+
+
+
+
+
+
+
+
{%- assign filtered_pages = site.pages | where: 'type', 'post' -%}
{%- assign filtered_pages_wiki = site.pages | where: 'type', 'wiki' -%}
diff --git a/assets/images/tabela_ASCII.png b/assets/images/tabela_ASCII.png
new file mode 100644
index 0000000..b132d22
Binary files /dev/null and b/assets/images/tabela_ASCII.png differ
diff --git a/treinamento/biblioteca.md b/treinamento/biblioteca.md
new file mode 100644
index 0000000..1c1990e
--- /dev/null
+++ b/treinamento/biblioteca.md
@@ -0,0 +1,46 @@
+---
+title: Bibliotecas
+layout: template
+button: Bibliotecas
+filename: biblioteca
+type: treinamento
+order: 11
+---
+
+# Biblioteca
+A Biblioteca é apenas um conjunto pronto de funções, elas podem ser disponibilizadas pelo compilador ou outra que você deseja. A mais usada é a própria **iostream**, mas existem muitas outras.
+
+## Importar uma biblioteca
+Para você usar uma biblioteca você precisa primeiro chama-la, para chamá-la em C é usado #include. Por Exemplo:
+
+
+
+## A diferença de importar usando <> e "":
+<> é usada para bibliotecas nativas do compilador, que já são "pré-instaladas", as aspas são usadas quando você quer importar uma biblioteca pessoal. Para você saber oque cada biblioteca faz entre na [documentacao](https://cplusplus.com/reference/), ou procure bibliotecas pela internet, baixe e as use normalmente
+
+A documentacao terá tudo oque voce precisa para usar uma biblioteca, por exemplo a **cmath**, podemos usar a função abs() e floor().
+
+
+
+ #include<iostream>
+ #include<cmath>
+
+ using namespace std;
+ int main(){
+ //Numero nao negativo
+ cout << abs(-54);
+ //Arredondamento para baixo
+ cout << floor(2.54);
+ }
+
+
\ No newline at end of file
diff --git a/treinamento/estruturas_repeticao.md b/treinamento/estruturas_repeticao.md
index b0e1a3a..561b3f2 100644
--- a/treinamento/estruturas_repeticao.md
+++ b/treinamento/estruturas_repeticao.md
@@ -4,7 +4,7 @@ layout: template
filename: estruturas_repeticao
button: Estrutura de repetição
type: treinamento
-order: 6
+order: 7
---
# Estrutura de repetição
@@ -199,6 +199,7 @@ esse incremento é definido na assinatura loop.
#### [1078 - Tabuada](https://www.beecrowd.com.br/judge/pt/problems/view/1078)
+
#include <stdio.h>
#include <stdlib.h>
@@ -212,6 +213,7 @@ int main(){
printf("%d x %d = %d\n",i,n,resultado);
}
}
+
### Problemas
diff --git a/treinamento/estruturas_selecao.md b/treinamento/estruturas_selecao.md
index 34b865b..4e557cc 100644
--- a/treinamento/estruturas_selecao.md
+++ b/treinamento/estruturas_selecao.md
@@ -4,7 +4,7 @@ layout: template
filename: estruturas_selecao
button: Estrutura de seleção
type: treinamento
-order: 4
+order: 5
---
# Estrutura de seleção
É uma estrutura de desvio do fluxo de controle presente em linguagens de programação que realiza diferentes computações ou ações dependendo se a seleção (ou condição) é verdadeira ou falsa. Assista a video aula sobre este tipo de estrutura [aqui](https://www.youtube.com/watch?v=sVkU_wXwO9s&ab_channel=COBI)
@@ -12,42 +12,50 @@ order: 4
## Sintaxe:
+
Pseudocódigo
-
Se (condição) Então
(bloco de código)
FimSe
-________________________
+
+
+
+
Pascal
-
if(condição) then
begin
(bloco de código)
end;
-________________________
+
+
+
+
Linguagem C
-
if(condição){
(bloco de código)
}
-________________________
+
+
+
+
Phyton
-
if condição:
(bloco de código)
-
-________________________
+
+
+
+
C++
-
if(condição){
(bloco de código)
}
-
+
+
Exemplo:
Verificar e apresentar se x é par ou impar.
@@ -55,17 +63,19 @@ Verificar e apresentar se x é par ou impar.
var ***x** : Inteiro.
-Pseudocódigo
-
+
+Pseudocódigo
Se (x mod 2 = 0) Então
escreva('PAR');
Senão
escreva('IMPAR');
FimSe
-________________________
-
-Pascal
+
+
+
+
+Pascal
if(condição) then
begin
write('PAR')
@@ -74,39 +84,46 @@ else
begin
write('IMPAR')
end;
+
+
### Problemas
diff --git a/treinamento/formatacao_casas.md b/treinamento/formatacao_casas.md
index ddace73..5050c84 100644
--- a/treinamento/formatacao_casas.md
+++ b/treinamento/formatacao_casas.md
@@ -4,7 +4,7 @@ layout: template
filename: Formatação de casas decimais
button: Formatação de casas decimais
type: treinamento
-order: 3
+order: 4
---
# Formatação de casas decimais
diff --git a/treinamento/funcoes.md b/treinamento/funcoes.md
new file mode 100644
index 0000000..5ee8bc6
--- /dev/null
+++ b/treinamento/funcoes.md
@@ -0,0 +1,179 @@
+---
+title: Funções
+layout: template
+filename: funcoes
+button: Funções
+type: treinamento
+order: 11
+---
+
+# Funções
+
+Imagine que você deseja executar um pedaço de código diversas vezes em diferentes lugares do código inteiro, então temos 2 opções:
+- Repetir o código diversas vezes, mas isso tem diversas desvantagens:
+ - Tornando o código grande
+ - Caso precise alterar essa parte do código é necessario mudar em todos os lugares que ele está.
+- Escrever apenas uma vez e chama-lo quando necessario.
+
+Por exemplo: Calcular o dobro de um valor
+
+
+
+ int x=2;
+ int total;
+ total = x*2;
+ cout << total;
+
+
+
+Com função:
+
+
+ #include<iostream>
+ using namespace std;
+ //Função dobro
+ int dobro(int x){
+ int total;
+ int total=x*2;
+ return total;
+ }
+
+ int main(){
+ int x=2;
+ int total = dobro(x);
+ cout << total;
+ }
+
+
+
+Note que a aparência de uma função já é algo que você está acostumado, pois **main** também é uma função. Todo programa em C e C++ inicia executando somente a função **main** as outras funções só serão executadas se o **main** desejar.
+
+## Entendendo a função **dobro**:
+
+
+ int dobro(int x){
+ int total;
+ int total=x*2;
+ return total;
+ }
+
+ /*
+ As funções podem retornar(devolverá para quem chamou) um valor(ou não).
+ Note que a função começa com um tipo, esse tipo declarará o tipo
+ de retorno que uma funcao retornara, como int, float, double,
+ char, string e entre outras.
+ */
+
+
+ /*
+ Dobro é o nome da função, similar ao nome de uma variavel, é como ela será chamada no main
+ */
+
+ /*
+ Depois do nome da função possui "()", eles são usados
+ para passar alguma variável para a função, isso ocorre pois
+ as funções são independentes da main, elas não possuem acesso
+ a nenhuma variável que a main possua, a não ser que você passe
+ isso para ela dentro dessa estrutura.
+ */
+
+ /*
+ Note que você precisa declarar o tipo da variável
+ que você irá passar para a função, para que ela saiba oque
+ esperar para armazenar a variável. Além do tipo você precisa
+ passar um nome, esse nome será como você irá chamar a variável
+ e não precisa ser igual a da main.
+ */
+
+ /*
+ Dentro da função dobro é igual ao main, você pode declarar qual
+ variável quiser, realizar loops, seleções e etc, a única diferença
+ é que você precisa retornar algo quando acabar a função, a main.
+ Após o return a função se encerra(mesmo que haja código abaixo
+ dele) e tudo que você declarou, fez e armazenou será perdido.
+ A única coisa guardada será o número devolvido para a main.
+ */
+
+ /*
+ O retorno será atribuído a variável total
+ */
+
+
+
+
+Note que o nome da variável passada para a função é
+independente do nome da variável na main, ou seja, os
+nomes podem ser diferentes. Então a função abaixo terá
+o mesmo resultado.
+
+
+ int dobro(int y){
+ int total;
+ int total=y*2;
+ return total;
+ }
+ int main(){
+ int x=2;
+ int total = dobro(x);
+ cout << total;
+ }
+
+
+
+É possível fazer de uma maneira mais direta.
+
+
+ int dobro(int y){
+ return y*2;
+ }
+ int main(){
+ int x=2;
+ cout << dobro(x);
+ }
+
+
+
+## Desacoplamento
+Essa é uma das vantagens de se usar função, o desacoplamento significa uma parte ser independente da outra, mesmo podendo se relacionar..
+
+
+ int dobro(int y){
+ int total;
+ y=y+1;
+ total=y*2;
+ y=y-1
+ return total;
+ }
+
+ int main(){
+ int x=2;
+ total = dobro(x);
+ cout << total;
+ }
+
+
+Nesse exemplo, eu posso mudar a função dobro da forma que eu quiser, mas não preciso necessariamente alterar a main, ou seja, dobro é independente da main. Pode parecer que se uma parte do código for executada somente uma vez, não é necessario fazer uma função. Em programação competitiva, onde a velocidade de resolução importa mais que a organização isso pode ser verdade, mas para a programação de software comercial isso não é verdade.
+
+
+## Parametro ou argumento
+
+
+ int dobro(int y){}
+ total = dobro(x);
+
+
+A variável y é chamado de parâmetro e a variável x é chamado de argumento, o parâmetro y é a variável que guardará o argumento x, como analogia poderíamos pensar na variável y como sendo a vaga em um estacionamento e o x sendo um carro, a vaga(parâmetro) sempre estará lá, sendo sempre o mesmo, por outro lado, o carro(argumento) pode ser totalmente diferente um do outro, mas para y isso não importa.
+
+
+
+# Return 0 no main
+Esse return é utilizado para retornar o estado final do programa, isso é útil caso outro programa tenha chamado esse programa em C e queira saber como ele terminou, return 0 é somente um padrão para concluído com sucesso, mas nao é obrigatório, a interpretação desse 0 depende somente do programa que chamou ele.
\ No newline at end of file
diff --git a/treinamento/operadores_logicos.md b/treinamento/operadores_logicos.md
index bdcd641..7e6ed70 100644
--- a/treinamento/operadores_logicos.md
+++ b/treinamento/operadores_logicos.md
@@ -4,58 +4,60 @@ layout: template
filename: operadores_logicos
button: Operadores lógicos
type: treinamento
-order: 5
+order: 6
---
# Operadores lógicos
As estruturas de programação, como a estrutura de seleção e a 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.
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.
## Por exemplo:
-[Estrutura de seleção](/treinamento/Estruturas_selecao)
+
SE chovendo ENTÃO
ESCREVA("Melhor levar um guarda-chuva");
-
+
-[Estrutura de repetição](/treinamento/Estruturas_repeticao)
+
ENQUANTO chovendo FAÇA
ESCREVA("Não vou sair de casa, ainda está chovendo");
ESCREVA("Finalmente parou de chover!");
+
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.
## Por exemplo:
+
SE idade MENOR QUE 18 ENTÃO
ESCREVA("Você é menor de idade!");
-
-
+
SE preço MAIOR OU IGUAL QUE 10 ENTÃO
ESCREVA("Isso é bem caro!");
-
-
+
SE minhaIdade DIFERENTE QUE suaIdade ENTÃO
ESCREVA("Não temos a mesma idade!");
+
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.
Por exemplo:
+
SE(sol) ENTÃO
SE (calor) ENTÃO
ESCREVA("Maria vai ao parque! :) ");
-
-
SE(preço <= 10) ENTÃO
+SE(preço <= 10) ENTÃO
ESCREVA("eu posso comprar isso")
-SE NÃO
+SENÃO
SE(dinheiro > 10) ENTÃO
escreva("eu posso comprar isso")
+
Para isso possuímos operadores lógicos:
@@ -77,7 +79,7 @@ Por exemplo: "Maria vai ao parque se estiver sol e calor", nesse exemplo Maria v
Maria vai ao parque?
-
Sol
Calor
Ela vai ao parque?
+
Sol
Calor
Ela vai ao parque?
Sim
Sim
Sim
Sim
Não
Não
Não
Sim
Não
@@ -85,39 +87,46 @@ Por exemplo: "Maria vai ao parque se estiver sol e calor", nesse exemplo Maria v
-
Pseudocódigo
-
+
+
+Pseudocódigo
SE(sol E calor) ENTÃO
ESCREVA("Maria vai ao parque! :) ");
SE NÃO
ESCREVA("Maria não vai ao parque! :( ");
+
+
-________
-
+
+
Linguagem C
-
if(sol && calor){
printf("Maria vai ao parque! :) ");
}else{
printf("Maria não vai ao parque! :( ");
}
-________
+
+
+
+
C++
-
if(sol && calor){
cout << "Maria vai ao parque! :) ";
}else{
cout << "Maria não vai ao parque! :( ";
}
-________
+
+
+
+
Python
-
if sol and calor:
print('Maria vai ao parque! :) ')
else:
print('Maria não vai ao parque! :( ')
+
Operador 'OU'
@@ -135,39 +144,46 @@ Diferente do operador lógico 'E' que necessita que ambos os parâmetros lógico
-
Pseudocódigo
-
+
+
+Pseudocódigo
SE(euFiz OU voceFez) ENTÃO
ESCREVA("A tarefa foi feita");
SE NÃO
ESCREVA("A tarefa não foi feita");
+
+
-________
-
+
+
Linguagem C
-
if(euFiz || voceFez){
printf("A tarefa foi feita");
}else{
printf("A tarefa não foi feita");
}
-________
+
+
+
+
C++
-
if(euFiz || voceFez){
cout << "A tarefa foi feita";
}else{
cout << "A tarefa não foi feita";
}
-________
+
+
+
+
Python
-
if euFiz or voceFez:
print('A tarefa foi feita')
else:
print('A tarefa não foi feita')
+
@@ -185,32 +201,38 @@ Algumas das representações mais classicas do símbolo de negação são: ~,
-
Pseudocódigo
-
+
+
+Pseudocódigo
SE(~sol) ENTÃO
ESCREVA("Está escuro");
+
+
@@ -219,12 +241,17 @@ if not sol:
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.
+
SE chovendo E !guardachuva ENTÃO
ESCREVA("Não posso sair, vou me molhar")
+
-
SE sol E calor E fimDeSemana ENTÃO
+
+
+SE sol E calor E fimDeSemana ENTÃO
ESCREVA("Hoje podemos ir à praia!")
+
Problemas
diff --git a/treinamento/string.md b/treinamento/string.md
new file mode 100644
index 0000000..72f63d7
--- /dev/null
+++ b/treinamento/string.md
@@ -0,0 +1,195 @@
+---
+title: String
+layout: template
+filename: string
+button: String
+type: treinamento
+order: 9
+---
+
+# String
+
+Strings são sequências de caracteres alfanuméricos (letras, números e/ou símbolos), tambem chamado de cadeia de caracteres. Na computação uma string é representada por um vetor do tipo char, onde cada índice do vetor corresponde a um caractere da string.
+
+Aqui podemos ver uma string:
+
+
+
+
Posição do vetor
+
0
+
1
+
2
+
3
+
4
+
+
+
+
+
Caractere
+
E
+
2
+
P
+
C
+
\0
+
+
+
+
+Observe que:
+
+- Posso acessar qualquer caractere da string com o índice do vetor (Em C++ sempre iniciando do zero)
+- Uma string é delimitada por aspas duplas (Por exemplo: “Paulo”, “Maria”, “ ”).
+- Cada caractere que constitui a string é delimitado por aspas simples (Por exemplo: ‘P’, ‘a’, ‘ ’)
+- As strings são finalizadas com o **caractere** especial ‘\0’, chamado null byte.
+
+
+
+Sintaxe:
+
+
+ string projeto = "D2PC";
+
+ //Imprimir um caractere do vetor:
+ cout << projeto[0];
+ //A saída será 'D'
+
+ //Modificar o vetor
+ projeto[0] = 'E'
+
+ cout << projeto[0];
+ //A saída será 'E'
+
+ //Imprimir toda string:
+ cout << projeto;
+ //A saída será 'E2PC'
+
+ //Imprimir toda a string acessando cada caractere:
+ for(int i=0;projeto[i]!='\0';i++){
+ cout << projeto[i];
+ }
+ //A saída será 'E2PC'
+
+ //Comparando os caracteres da string:
+ if(projeto[0]=='E'){
+ ...
+ }
+
+
+
+
+
+## Leitura de string
+
+Normalmente é utilizado a instrução **cin** para leitura de string.
+Sintaxe:
+
+
+
+ //Leitura de string:
+ cin >> projeto;
+ cout << projeto << endl;
+
+
+
+## Outros métodos de leitura
+Normalmente utilizamos **cin**, mas essa instrução tem uma limitação intencional, ela interrompe a leitura se encontrar um espaço.
+
+Para permitir a leitura de conteúdos contendo espaços, é preciso utilizar outra função de entrada, que obterá toda a linha:
+
+A instrução **getline(cin, projeto)** permitirá que todos os caracteres, até o enter, que forem digitados sejam obtidos.
+
+Se for necessário utilizar outro caractere para delimitar o fim do conteúdo da variável, esse caractere poderá ser especificado:
+**getline(cin, projeto, '.')**
+
+Com essa instrução, todos os caracteres que antecedem o ponto ('.') serão armazenados na variável projeto.
+
+
+
+ /*
+ Entrada: Cuidado. Getline em uso.
+ (note que possui tabulação(TAB) no meio da string)
+
*/
+ int main() {
+ string a, b, c, d, e;
+
+ getline(cin, a);
+ cout << a << endl;
+ //Saida: Cuidado. Getline em uso.
+ cin.ignore(1)
+
+ getline(cin, b, '.');
+ cout << b << endl;
+ //Saida: Cuidado
+
+ getline(cin, c);
+ cout << c << endl;
+ //Saida: . Getline em uso.
+
+ getline(cin, d, '\t');
+ cout << d << endl;
+ //Saida: Cuidado.
+
+ cin >> e;
+ cout << e;
+ //Saida: Getline
+ //"em uso" permanecerá no fluxo de entrada
+ }
+
+
+Note que:
+- \t é um **caractere** especial que simboliza tabulação(TAB)
+- **getline(cin, b, '.');** lê até o ponto, mas deixa os outros caracteres no fluxo de entrada, quando o **getline(cin, c);** lê, ele lerá oque está na vez no fluxo, podendo nao ser o valor esperado. Isso ocorre com o **getline(cin, a);** também, pois o getline lê até o enter, ou seja, deixa o enter no fluxo de entrada, então é necessario descartar o proximo caracter(enter) do fluxo da entrada para continuar o programa normalmente, isso que o cin.ignore(1) faz.
+
+## Tabela ASCII
+É o Código Padrão Americano para o Intercâmbio de Informação é um dos vários sistemas de representação de caracteres alfanuméricos. Além do computador ele é usado amplamente na internet para transferência de dados.
+
+
+ Observe que caracteres maiúsculo e minúsculo tem valores diferentes.
+
+- Em C++ cada caractere ocupa, apenas, 1 byte(8 bits) na memória, isso ocorre porque ele utiliza o padrão ASCII. JavaScript, por exemplo, cada caractere utiliza 4 bytes(32 bits), pois utiliza o padrão UTF-8
+
+No computador os caracteres são armazenados como números e interpretados como caracteres, como podemos ver a seguir:
+
+
+
+Observe que **forçamos** a saída como inteira (**(int)projeto[i]**), mesmo sendo um caractere, isso se chama **casting explícito**. Atenção com o casting, pois ele forçará só o próximo elemento, não todos os outros, então utilize parênteses se precisar utilizar para mais de um elemento:
+- (int)2.5 = 2
+- (int)(2.5+3.2) = 5
+- (int)2.5+3.2 = 5.2
+- (char)69 = 'E'
+- Pode ser feito com qualquer tipo de dado: (int), (double), (float), (char) e etc.
+
+Como se trata de números podemos manipular os caracteres, como por exemplo, se em um lugar do vetor tivermos o caractere **A** e fizermos **A**+1, então a saída será **B**, porque na tabela **A** tem o valor 66, e 66+1 será **B**, pois 67 é **B** na tabela ASCII:
+
+
+Observe que sem o casting apropriado a saída será um valor inteiro.
+
+### Problemas
+- [Salário com Bônus](https://www.beecrowd.com.br/judge/pt/problems/view/1009?origem=1)
+- [Criptografia](https://www.beecrowd.com.br/judge/pt/problems/view/1024?origem=1)
+- [LED](https://www.beecrowd.com.br/judge/pt/problems/view/1168?origem=1)
+- [Combinador](https://www.beecrowd.com.br/judge/pt/problems/view/1238?origem=1)
\ No newline at end of file
diff --git a/treinamento/tipo_dados.md b/treinamento/tipo_dados.md
new file mode 100644
index 0000000..c274441
--- /dev/null
+++ b/treinamento/tipo_dados.md
@@ -0,0 +1,58 @@
+---
+title: Tipo de dados
+layout: template
+filename: tipo_dados
+button: Tipo de dados
+type: treinamento
+order: 3
+---
+
+# Tipo de dados
+Em algumas linguagens(C, C++, Pascal e entre outras) é necessário declarar qual o tipo do dados que a variavel irá armazenar, como inteiro, decimal, caracter, booleano e etc. Nessa sessao tambem veremos sobre os intervalos que uma variavel suporta, isso porque o computador só consegue armazenar uma quantidade limitadas de dados, por exemplo, se tivermos apenas 4 casas disponiveis só poderemos escrever 10.000 numero, de 0000, 0001, 0002 ... 9997, 9998 e 9999, o computador funciona de forma similar.
+
+## Inteiro
+Esse tipo de variavel armazena numeros inteiros, ou seja, numeros **sem** casas decimais.
+
+Por exemplo:
+
+
+ int numero;
+ //-32.768 a 32.767
+
+ unsigned int numero;
+ //0 a 65535
+
+ long int numero;
+ //-2147483648 a 2147483647
+
+ unsigned long int numero;
+ //42949667295
+
+**Não precisa decorar todas essas declações, apenas a "int numero", pois é a de longe a mais usada**
+
+## Decimal
+Esse tipo de variavel armazena numeros decimais(também chamado de ponto flutuante), ou seja, numeros **com** casas decimais. Aqui os intervalos possuem a anotacao de elevado, entao 3.4E4932 significa 4932 possiveis numeros decimais.
+
+Por exemplo:
+
+
+ float numero=3.1416;
+ //3.4E-38 a 3.4E38
+
+ double numero;
+ //1.7E-308 a 1.7E308
+
+ long double numero;
+ //3.4E-4932 a 3.4E4932
+
+**Cuidado:**
+**As linguagens seguem o padrão americano, então é ao contrario do brasileiro, no brasil a virgula separa a parte inteira da parte decimal(3,1416), mas é o ponto ('.') usado no padrão americano (3.1416)**
+
+## Caractere
+Esse tipo de variavel armazena caracteres alfanumericos, como x, 1, %, ^ e etc.
+
+Por exemplo:
+
+ char palavra='a';
+
+**O intervalo e detalhes de uma variavel desse tipo serao descutidas em um tópico mais avançado chamado** [string](/treinamento/string.html)
\ No newline at end of file
diff --git a/treinamento/vetores.md b/treinamento/vetores.md
index 925dc19..2bd45ae 100644
--- a/treinamento/vetores.md
+++ b/treinamento/vetores.md
@@ -4,11 +4,11 @@ layout: template
filename: vetores
button: Vetores
type: treinamento
-order: 7
+order: 8
---
# Vetores
-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 (aqui)[https://www.youtube.com/watch?v=B6MUlVNzWQQ&ab_channel=COBI].
+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 [aqui](https://www.youtube.com/watch?v=B6MUlVNzWQQ&ab_channel=COBI).
Sintaxe: