Public/EX_03
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added permutations and powerset

Browse Source
This commit is contained in:
Rui Ribeiro 2025-09-30 13:13:09 +00:00
parent eb777e722d
commit 2b362d0916
2 changed files with 106 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

168
level-2/permutations/permutations.c
View File

@ -1,132 +1,60 @@
#include <unistd.h> // write #include <stdlib.h>
#include <stdlib.h> // malloc, free #include <stdio.h>
// Função auxiliar para obter o comprimento de uma string int length;
int ft_strlen(const char *s) char *set;
char *permutation;
int ft_strlen(char *s)
{ {
int len = 0; int i = 0;
while (s[len]) while(s[i])
len++; i++;
return (len); return (i);
} }
// Função auxiliar para imprimir uma string seguida de uma nova linha
void print_solution(const char *s) void permutations(int index, char *used)
{ {
write(1, s, ft_strlen(s)); if (index == length)
write(1, "\n", 1); {
printf("%s\n", permutation);
return ;
}
int i = 0;
while (i < length)
{
if (used[i] == '0')
{
permutation[index] = set[i];
used[i] = '1';
permutations(index + 1, used);
used[i] = '0';
}
i++;
}
} }
// Função auxiliar para trocar dois caracteres (usada na ordenação) char *populate_used()
void ft_swap(char *a, char *b)
{ {
char temp = *a; char *ret = (char *) calloc (length + 1, sizeof(char));
*a = *b; int i = 0;
*b = temp; while (i < length)
ret[i++] = '0';
return (ret);
} }
// Função para ordenar a string de entrada (Bubble Sort simples) int main(int ac, char **av)
// Isso é crucial para garantir que as permutações sejam geradas em ordem alfabética.
void sort_string(char *str, int n)
{ {
int i; if (ac != 2)
int j; return (1);
set = av[1];
i = 0; length = ft_strlen(av[1]);
while (i < n - 1) char *used = populate_used();
{ permutation = (char *) malloc(sizeof(char) * (length + 1));
j = 0; permutations(0, used);
while (j < n - i - 1) free(used);
{ free(permutation);
if (str[j] > str[j + 1]) return (0);
ft_swap(&str[j], &str[j + 1]);
j++;
}
i++;
}
}
// A função principal de backtracking, análoga à sua função `solve`
// Parâmetros:
// - original_str: A string original, já ordenada
// - current_perm: A permutação que estamos construindo (o "tabuleiro")
// - used: Um array que marca quais caracteres da string original já foram usados
// - n: O tamanho da string
// - k: A posição atual que estamos preenchendo em `current_perm` (análogo a `col`)
void generate_permutations(char *original_str, char *current_perm, int *used, int n, int k)
{
// Caso base: Se todas as posições foram preenchidas (k == n),
// análogo a `if (col == n)` no N-Queens.
if (k == n)
{
print_solution(current_perm);
return;
}
// Tenta colocar cada caractere da string original na posição 'k' atual
int i = 0;
while (i < n)
{
// Verifica se a "jogada" é válida, análogo ao `is_safe`.
// A condição é: o i-ésimo caractere da string original ainda não foi usado?
if (used[i] == 0)
{
// "Coloca a peça no tabuleiro":
// 1. Coloca o caractere na permutação atual
current_perm[k] = original_str[i];
// 2. Marca este caractere como usado
used[i] = 1;
// Chama a função recursivamente para a próxima posição (k + 1),
// análogo a `solve(board, n, col + 1)`
generate_permutations(original_str, current_perm, used, n, k + 1);
// Backtracking: Desfaz a jogada para que este caractere possa ser
// usado em uma posição diferente na próxima ramificação da recursão.
// Isso é crucial e um pouco mais explícito que no seu N-Queens.
used[i] = 0;
}
i++;
}
}
int main(int argc, char **argv)
{
if (argc != 2 || !argv[1][0])
{
// Não faz nada se não houver exatamente um argumento ou se for uma string vazia.
return (0);
}
int n = ft_strlen(argv[1]);
char *original_str = argv[1]; // Não precisamos de cópia, podemos ordenar o argumento
// 1. Ordena a string de entrada para garantir a saída em ordem alfabética
sort_string(original_str, n);
// 2. Aloca memória para a permutação que será construída
char *current_perm = (char *)malloc(sizeof(char) * (n + 1));
if (!current_perm)
return (1);
current_perm[n] = '\0'; // Garante a terminação da string
// 3. Aloca memória para o array de "usados" e o inicializa com 0
// `calloc` é útil aqui pois inicializa a memória com zeros.
int *used = (int *)malloc(sizeof(int) * n);
if (!used)
{
free(current_perm);
return (1);
}
for (int i = 0; i < n; i++)
used[i] = 0;
// Inicia o processo de backtracking a partir da primeira posição (k = 0)
generate_permutations(original_str, current_perm, used, n, 0);
// Liberta a memória alocada
free(current_perm);
free(used);
return (0);
} }

113
level-2/powerset/powerset_clean.c
View File

@ -1,68 +1,71 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
void print_subset(int *subset, int size) int target;
{ int length;
int i; int *set;
i = 0; void populate_array(int ac, char **av)
while (i < size) {
{ int i = 0;
printf("%d", subset[i]); int j = 2;
if (i < size - 1) while(j < ac)
printf(" "); {
i++; set[i] = atoi(av[j]);
} i++;
printf("\n"); j++;
}
} }
void find_subsets(int target, int *set, int set_size, int index, int *current_path, int path_len) void print_set(int *used)
{ {
if (target == 0) int i = 0;
return (print_subset(current_path, path_len)); int is_first = 1;
while(i < length)
if (index >= set_size) {
return; if (used[i] == 1)
{
current_path[path_len] = set[index]; if (is_first)
find_subsets(target - set[index], set, set_size, index + 1, current_path, path_len + 1); {
find_subsets(target, set, set_size, index + 1, current_path, path_len); fprintf(stdout, "%i", set[i]);
is_first = 0;
}
else
fprintf(stdout, " %i", set[i]);
}
i++;
}
printf("\n");
} }
int main(int argc, char **argv) void powerset(int index, int current_sum, int *used)
{ {
int target; if (index == length)
int *numbers; {
int *path; if (current_sum == target)
int size; print_set(used);
int i; return ;
}
if (argc < 2) powerset(index + 1, current_sum, used);
return (0); used[index] = 1;
powerset(index + 1, current_sum + set[index], used);
used[index] = 0;
}
target = atoi(argv[1]); int main(int ac, char **av)
size = argc - 2; {
if (ac < 2)
numbers = (int *)malloc(sizeof(int) * size); return (1);
if (!numbers)
return (1); length = ac -2;
target = atoi(av[1]);
path = (int *)malloc(sizeof(int) * size); set = (int *) malloc (sizeof(int) * length);
if (!path) int *used = (int *) calloc (length, sizeof(int));
{ populate_array(ac, av);
free(numbers); powerset(0, 0, used);
return (1); free(set);
} free(used);
i = 0; return (0);
while (i < size)
{
numbers[i] = atoi(argv[i + 2]);
i++;
}
find_subsets(target, numbers, size, 0, path, 0);
free(numbers);
free(path);
return (0);
} }