Benchmarks novos

benchmarks/ackermann.c

@@ -0,0 +1,12 @@
+#include <stdio.h>
+
+int ack(int m, int n) {
+    if (m == 0) return n + 1;
+    if (n == 0) return ack(m - 1, 1);
+    return ack(m - 1, ack(m, n - 1));
+}
+
+int main() {
+    printf("%d\n", ack(3, 11));
+    return 0;
+}

benchmarks/ackermann.delegua

@@ -0,0 +1,11 @@
+funcao ack(m: inteiro, n: inteiro): inteiro {
+    se m == 0 {
+        retorna n + 1
+    }
+    se n == 0 {
+        retorna ack(m - 1, 1)
+    }
+    retorna ack(m - 1, ack(m, n - 1))
+}
+
+escreva(ack(3, 11))

benchmarks/ackermann.rs

@@ -0,0 +1,9 @@
+fn ack(m: i32, n: i32) -> i32 {
+    if m == 0 { return n + 1; }
+    if n == 0 { return ack(m - 1, 1); }
+    ack(m - 1, ack(m, n - 1))
+}
+
+fn main() {
+    println!("{}", ack(3, 11));
+}

benchmarks/arvore.c

@@ -0,0 +1,69 @@
+#include <stdio.h>
+
+#define N 300000
+
+int valores[N];
+int esquerda[N];
+int direita[N];
+int tamanho = 0;
+
+void inserir(int val) {
+    if (tamanho == 0) {
+        valores[0] = val;
+        esquerda[0] = -1;
+        direita[0] = -1;
+        tamanho = 1;
+        return;
+    }
+    int atual = 0;
+    while (1) {
+        if (val < valores[atual]) {
+            if (esquerda[atual] == -1) {
+                esquerda[atual] = tamanho;
+                valores[tamanho] = val;
+                esquerda[tamanho] = -1;
+                direita[tamanho] = -1;
+                tamanho++;
+                return;
+            }
+            atual = esquerda[atual];
+        } else if (val > valores[atual]) {
+            if (direita[atual] == -1) {
+                direita[atual] = tamanho;
+                valores[tamanho] = val;
+                esquerda[tamanho] = -1;
+                direita[tamanho] = -1;
+                tamanho++;
+                return;
+            }
+            atual = direita[atual];
+        } else {
+            return;
+        }
+    }
+}
+
+int buscar(int val) {
+    int atual = 0;
+    while (atual != -1) {
+        if (val == valores[atual]) return 1;
+        atual = val < valores[atual] ? esquerda[atual] : direita[atual];
+    }
+    return 0;
+}
+
+int main() {
+    for (int i = 0; i < N; i++) {
+        int val = (i * 7141 + 54773) % 1000000;
+        if (val < 0) val = -val;
+        inserir(val);
+    }
+
+    int encontrados = 0;
+    for (int i = 0; i < N; i++) {
+        encontrados += buscar(i);
+    }
+
+    printf("%d\n", encontrados);
+    return 0;
+}

benchmarks/arvore.delegua

@@ -0,0 +1,73 @@
+var n: inteiro = 300000
+
+var valores: inteiro[] = [0]
+var esquerda: inteiro[] = [-1]
+var direita: inteiro[] = [-1]
+var tamanho: inteiro = 0
+
+para var k: inteiro = 1; k < n; k++ {
+    valores.adicionar(0)
+    esquerda.adicionar(-1)
+    direita.adicionar(-1)
+}
+
+para var i: inteiro = 0; i < n; i++ {
+    var val: inteiro = (i * 7141 + 54773) % 1000000
+    se val < 0 { val = 0 - val }
+
+    se tamanho == 0 {
+        valores[0] = val
+        esquerda[0] = -1
+        direita[0] = -1
+        tamanho = 1
+    } senao {
+        var atual: inteiro = 0
+        var inserido: inteiro = 0
+        enquanto inserido == 0 {
+            se val < valores[atual] {
+                se esquerda[atual] == -1 {
+                    esquerda[atual] = tamanho
+                    valores[tamanho] = val
+                    esquerda[tamanho] = -1
+                    direita[tamanho] = -1
+                    tamanho = tamanho + 1
+                    inserido = 1
+                } senao {
+                    atual = esquerda[atual]
+                }
+            } senao se val > valores[atual] {
+                se direita[atual] == -1 {
+                    direita[atual] = tamanho
+                    valores[tamanho] = val
+                    esquerda[tamanho] = -1
+                    direita[tamanho] = -1
+                    tamanho = tamanho + 1
+                    inserido = 1
+                } senao {
+                    atual = direita[atual]
+                }
+            } senao {
+                inserido = 1
+            }
+        }
+    }
+}
+
+var encontrados: inteiro = 0
+para var i: inteiro = 0; i < n; i++ {
+    var atual: inteiro = 0
+    var achou: inteiro = 0
+    enquanto atual != -1 {
+        se i == valores[atual] {
+            achou = 1
+            atual = -1
+        } senao se i < valores[atual] {
+            atual = esquerda[atual]
+        } senao {
+            atual = direita[atual]
+        }
+    }
+    encontrados = encontrados + achou
+}
+
+escreva(encontrados)

benchmarks/arvore.rs

@@ -0,0 +1,83 @@
+const N: usize = 300_000;
+
+struct Arvore {
+    valores: Vec<i32>,
+    esquerda: Vec<i32>,
+    direita: Vec<i32>,
+    tamanho: usize,
+}
+
+impl Arvore {
+    fn nova() -> Self {
+        Arvore {
+            valores: vec![0; N],
+            esquerda: vec![-1; N],
+            direita: vec![-1; N],
+            tamanho: 0,
+        }
+    }
+
+    fn inserir(&mut self, val: i32) {
+        if self.tamanho == 0 {
+            self.valores[0] = val;
+            self.esquerda[0] = -1;
+            self.direita[0] = -1;
+            self.tamanho = 1;
+            return;
+        }
+        let mut atual: i32 = 0;
+        loop {
+            let idx = atual as usize;
+            if val < self.valores[idx] {
+                if self.esquerda[idx] == -1 {
+                    self.esquerda[idx] = self.tamanho as i32;
+                    self.valores[self.tamanho] = val;
+                    self.esquerda[self.tamanho] = -1;
+                    self.direita[self.tamanho] = -1;
+                    self.tamanho += 1;
+                    return;
+                }
+                atual = self.esquerda[idx];
+            } else if val > self.valores[idx] {
+                if self.direita[idx] == -1 {
+                    self.direita[idx] = self.tamanho as i32;
+                    self.valores[self.tamanho] = val;
+                    self.esquerda[self.tamanho] = -1;
+                    self.direita[self.tamanho] = -1;
+                    self.tamanho += 1;
+                    return;
+                }
+                atual = self.direita[idx];
+            } else {
+                return;
+            }
+        }
+    }
+
+    fn buscar(&self, val: i32) -> i32 {
+        let mut atual: i32 = 0;
+        while atual != -1 {
+            let idx = atual as usize;
+            if val == self.valores[idx] { return 1; }
+            atual = if val < self.valores[idx] { self.esquerda[idx] } else { self.direita[idx] };
+        }
+        0
+    }
+}
+
+fn main() {
+    let mut arv = Arvore::nova();
+
+    for i in 0..N as i32 {
+        let mut val = (i * 7141 + 54773) % 1000000;
+        if val < 0 { val = -val; }
+        arv.inserir(val);
+    }
+
+    let mut encontrados = 0;
+    for i in 0..N as i32 {
+        encontrados += arv.buscar(i);
+    }
+
+    println!("{}", encontrados);
+}

benchmarks/crivo.c

@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define N 1000000
+
+int main() {
+    int* crivo = (int*)malloc((N + 1) * sizeof(int));
+    for (int i = 0; i <= N; i++) crivo[i] = 1;
+    crivo[0] = 0;
+    crivo[1] = 0;
+
+    for (int i = 2; i * i <= N; i++) {
+        if (crivo[i]) {
+            for (int j = i * i; j <= N; j += i) {
+                crivo[j] = 0;
+            }
+        }
+    }
+
+    int contagem = 0;
+    for (int i = 2; i <= N; i++) {
+        contagem += crivo[i];
+    }
+
+    printf("%d\n", contagem);
+    free(crivo);
+    return 0;
+}

benchmarks/crivo.delegua

@@ -0,0 +1,27 @@
+var n: inteiro = 1000000
+var crivo: inteiro[] = [0]
+
+para var k: inteiro = 1; k <= n; k++ {
+    crivo.adicionar(1)
+}
+
+crivo[1] = 0
+
+var i: inteiro = 2
+enquanto i * i <= n {
+    se crivo[i] == 1 {
+        var j: inteiro = i * i
+        enquanto j <= n {
+            crivo[j] = 0
+            j = j + i
+        }
+    }
+    i = i + 1
+}
+
+var contagem: inteiro = 0
+para var k: inteiro = 2; k <= n; k++ {
+    contagem = contagem + crivo[k]
+}
+
+escreva(contagem)

benchmarks/crivo.rs

@@ -0,0 +1,26 @@
+const N: usize = 1_000_000;
+
+fn main() {
+    let mut crivo = vec![1i32; N + 1];
+    crivo[0] = 0;
+    crivo[1] = 0;
+
+    let mut i = 2;
+    while i * i <= N {
+        if crivo[i] == 1 {
+            let mut j = i * i;
+            while j <= N {
+                crivo[j] = 0;
+                j += i;
+            }
+        }
+        i += 1;
+    }
+
+    let mut contagem = 0i32;
+    for k in 2..=N {
+        contagem += crivo[k];
+    }
+
+    println!("{}", contagem);
+}

benchmarks/executar.sh

@@ -96,6 +96,11 @@ run_benchmark() {
 run_benchmark "Fibonacci Recursivo (fib 40)" "fibonacci" "102334155"
 run_benchmark "Contagem de Primos (até 1M)" "primos" "78498"
 run_benchmark "Bubble Sort (10000 elementos)" "bubblesort" "1"
+run_benchmark "Crivo de Eratóstenes (até 1M)" "crivo" "78498"
+run_benchmark "Soma de Dígitos (1 a 10M)" "somadigitos" "315000001"
+run_benchmark "Ackermann (3, 11)" "ackermann" "16381"
+run_benchmark "Pontos - Classes (1M)" "pontos" "500000000"
+run_benchmark "Árvore BST (300K)" "arvore" "90021"
 
 echo ""
 echo "========================================"

benchmarks/pontos.c

@@ -0,0 +1,19 @@
+#include <stdio.h>
+
+typedef struct { int x; int y; } Ponto;
+
+int distanciaManhattan(Ponto* p) {
+    int dx = p->x < 0 ? -p->x : p->x;
+    int dy = p->y < 0 ? -p->y : p->y;
+    return dx + dy;
+}
+
+int main() {
+    int total = 0;
+    for (int i = 0; i < 1000000; i++) {
+        Ponto p = { .x = (i * 7 + 3) % 1000 - 500, .y = (i * 13 + 7) % 1000 - 500 };
+        total += distanciaManhattan(&p);
+    }
+    printf("%d\n", total);
+    return 0;
+}