# Soluções de Teste - Ordenação (JS + Blocos ASCII)

Este arquivo traz soluções funcionais para testar as fases da atividade.

Observações:
- Todas as soluções usam índice iniciado em 0.
- Em blocos ASCII, os nomes seguem os blocos customizados da atividade (`ord_lista_*`) e blocos condicionais padrão.
- **Blocos por fase**:
  - Fases 1–2: sem loops, apenas `SE` e comparação/troca.
  - Fases 3–6: usam `ENQUANTO` (while), aritmética, e lógica.
  - Fase 6 em específico: inclui `logic_boolean` para a variável `trocou` (esse bloco NÃO está disponível na fase 3).
  - Fases 7+: seguem a mesma lógica das fases anteriores com listas maiores.

---

## Fase 1 - Ordenar 2 números

### JavaScript (funciona)
```javascript
if (lista_comparar(0, 1, ">")) {
  lista_trocar(0, 1);
}
```

### Blocos (ASCII)
```text
[SE]
  condicao: [ord_lista_comparar POSICAO:(0) OP:(>) POSICAO:(1)]
  [ENTAO]
    [ord_lista_trocar POSICAO:(0) com POSICAO:(1)]
```

---

## Fase 2 - Ordenar 3 números

### JavaScript (funciona)
```javascript
if (lista_comparar(0, 1, ">")) lista_trocar(0, 1);
if (lista_comparar(1, 2, ">")) lista_trocar(1, 2);
if (lista_comparar(0, 1, ">")) lista_trocar(0, 1);
```

### Blocos (ASCII)
```text
[SE]
  condicao: [ord_lista_comparar POSICAO:(0) OP:(>) POSICAO:(1)]
  [ENTAO]
    [ord_lista_trocar POSICAO:(0) com POSICAO:(1)]

[SE]
  condicao: [ord_lista_comparar POSICAO:(1) OP:(>) POSICAO:(2)]
  [ENTAO]
    [ord_lista_trocar POSICAO:(1) com POSICAO:(2)]

[SE]
  condicao: [ord_lista_comparar POSICAO:(0) OP:(>) POSICAO:(1)]
  [ENTAO]
    [ord_lista_trocar POSICAO:(0) com POSICAO:(1)]
```

---

## Fase 3 - Bubble Sort

### JavaScript (funciona)
```javascript
var n = lista_tamanho();
var i = 0;
while (i < n - 1) {
  var j = 0;
  while (j < n - 1 - i) {
    if (lista_comparar(j, j + 1, ">")) {
      lista_trocar(j, j + 1);
    }
    j = j + 1;
  }
  i = i + 1;
}
```

### Blocos (ASCII)
```text
definir n <- lista_tamanho()
[PARA i = 0 enquanto [i < [n - 1]] incremento [i + 1]]
  [PARA j = 0 enquanto [j < [[n - 1] - i]] incremento [j + 1]]
    [SE lista_comparar(j, >, j+1)]
      [lista_trocar(j, j+1)]
```

---

## Fase 4 - Bubble Sort com otimização

### JavaScript (funciona)
```javascript
var n = lista_tamanho();
var i = 0;
while (i < n - 1) {
  var trocou = false;
  var j = 0;
  while (j < n - 1 - i) {
    if (lista_comparar(j, j + 1, ">")) {
      lista_trocar(j, j + 1);
      trocou = true;
    }
    j = j + 1;
  }
  if (!trocou) break;
  i = i + 1;
}
```

### Blocos (ASCII)
```text
definir n <- lista_tamanho()
[PARA i = 0 enquanto [i < [n - 1]] incremento [i + 1]]
  definir trocou <- [FALSO]
  [PARA j = 0 enquanto [j < [[n - 1] - i]] incremento [j + 1]]
    [SE lista_comparar(j, >, j+1)]
      [lista_trocar(j, j+1)]
      definir trocou <- [VERDADEIRO]
  [SE [NÃO trocou]]
    [parar loop]
```

---

## Fase 5 - Selection Sort

### JavaScript (funciona)
```javascript
var n = lista_tamanho();
for (var i = 0; i < n - 1; i++) {
  var min = i;
  for (var j = i + 1; j < n; j++) {
    if (lista_comparar(j, min, "<")) {
      min = j;
    }
  }
  if (min != i) {
    lista_trocar(i, min);
  }
}
```

### Blocos (ASCII)
```text
definir n <- lista_tamanho()
[PARA i = 0 enquanto [i < [n - 1]] incremento [i + 1]]
  definir min <- i
  [PARA j = [i + 1] enquanto [j < n] incremento [j + 1]]
    [SE lista_comparar(j, <, min)]
      definir min <- j
  [SE lista_comparar(min, !=, i)]
    [lista_trocar(i, min)]
```

---

## Fase 6 - Insertion Sort

### JavaScript (funciona)
```javascript
var n = lista_tamanho();
for (var i = 1; i < n; i++) {
  var chave = lista_ler(i);
  var j = i - 1;
  while (j >= 0 && lista_ler(j) > chave) {
    lista_escrever(j + 1, lista_ler(j));
    j = j - 1;
  }
  lista_escrever(j + 1, chave);
}
```

### Blocos (ASCII)
```text
definir n <- lista_tamanho()
[PARA i = 1 enquanto [i < n] incremento [i + 1]]
  definir chave <- lista_ler(i)
  definir j <- [i - 1]
  [ENQUANTO [[j >= 0] E [lista_ler(j) > chave]]]
    [lista_escrever([j + 1], lista_ler(j))]
    definir j <- [j - 1]
  [lista_escrever([j + 1], chave)]
```

---

## Fase 7- Shell Sort

### JavaScript (funciona)
```javascript
var n = lista_tamanho();
var gap = Math.floor(n / 2);

while (gap > 0) {
  for (var i = gap; i < n; i++) {
    var temp = lista_ler(i);
    var j = i;

    while (j >= gap && lista_ler(j - gap) > temp) {
      lista_escrever(j, lista_ler(j - gap));
      j = j - gap;
    }

    lista_escrever(j, temp);
  }

  gap = Math.floor(gap / 2);
}
```

### Blocos (ASCII)
```text
definir n <- lista_tamanho()
definir gap <- arredondar_para_baixo([n / 2])
[ENQUANTO [gap > 0]]
  [PARA i = gap enquanto [i < n] incremento [i + 1]]
    definir temp <- lista_ler(i)
    definir j <- i
    [ENQUANTO [[j >= gap] E [lista_ler([j - gap]) > temp]]]
      [lista_escrever(j, lista_ler([j - gap]))]
      definir j <- [j - gap]
    [lista_escrever(j, temp)]
  definir gap <- arredondar_para_baixo([gap / 2])
```

---

## Fase 8 - Counting Sort

### JavaScript (funciona)
```javascript
var n = lista_tamanho();
var max = lista_ler(0);

for (var i = 1; i < n; i++) {
  if (lista_ler(i) > max) {
    max = lista_ler(i);
  }
}

var contagem = [];
for (var k = 0; k <= max; k++) {
  contagem[k] = 0;
}

for (var i2 = 0; i2 < n; i2++) {
  var v = lista_ler(i2);
  contagem[v] = contagem[v] + 1;
}

var pos = 0;
for (var valor = 0; valor <= max; valor++) {
  while (contagem[valor] > 0) {
    lista_escrever(pos, valor);
    pos = pos + 1;
    contagem[valor] = contagem[valor] - 1;
  }
}
```

### Blocos (ASCII)
```text
definir n <- lista_tamanho()
definir max <- lista_ler(0)
[PARA i = 1 enquanto [i < n] incremento [i + 1]]
  [SE [lista_ler(i) > max]]
    definir max <- lista_ler(i)

definir contagem <- []
[PARA k = 0 enquanto [k <= max] incremento [k + 1]]
  contagem[k] <- 0

[PARA i = 0 enquanto [i < n] incremento [i + 1]]
  definir v <- lista_ler(i)
  contagem[v] <- [contagem[v] + 1]

definir pos <- 0
[PARA valor = 0 enquanto [valor <= max] incremento [valor + 1]]
  [ENQUANTO [contagem[valor] > 0]]
    [lista_escrever(pos, valor)]
    definir pos <- [pos + 1]
    contagem[valor] <- [contagem[valor] - 1]
```
