Lista * somar(Lista *operando1, Lista *operando2) //funcionando perfeitamente
{
int i;
int valor = 0;
int tam1 = tamanho(operando1);
int tam2 = tamanho(operando2);
Lista *resultadoSoma = criar();
// caso os operandos sejam de tamanhos distintos, completa-se com zeros no inicio.
if(tam1 > tam2){
for(i = 0; i < tam1-tam2; i++)
inserir_primeiro(operando2, 0);
}
// caso os operandos sejam de tamanhos distintos, completa-se com zeros no inicio.
if(tam2 > tam1){
for(i = 0; i < tam2-tam1; i++)
inserir_primeiro(operando1, 0);
}
// soma do ultimo algarismo até o primeiro
// colocando as unidades no resultado e somando a dezena na proxima soma.
tam1 = tamanho(operando1);
while(tam1 > 0){
valor = ler_pos(operando1, tam1-1) + ler_pos(operando2, tam1-1) + valor/10 ;
inserir_primeiro(resultadoSoma, valor%10);
tam1--;
}
// caso sobre uma dezena da soma do primeiro algarismo, ela é adicionada no inicio do numero.
if(valor/10 > 0)
inserir_primeiro(resultadoSoma, valor/10);
return resultadoSoma;
}
int main () {
int elemento;
LISTA lista;
construir(&lista);
tamanho(&lista);
adicionar(&lista, 0, 6);
exibeLista(&lista);
tamanho(&lista);
adicionar(&lista, 1, 7);
adicionar(&lista, 2, 5);
adicionar(&lista, 3, 10);
exibeLista(&lista);
tamanho(&lista);
adicionar(&lista, 3, 17);
exibeLista(&lista);
deletarElemento(&lista, 1);
exibeLista(&lista);
elemento = busca(&lista, 6);
if (elemento != -1){
printf("%d\n", elemento);
}else{
printf("Elemento não encontrado!\n");
}
tamanho(&lista);
return 0;
}
int mover(Pilha * origem, Pilha * destino){
if(tamanho(origem) > 0 && (tamanho(destino) <= 0 || topo(origem) < topo(destino))){
empilhar(destino,desempilhar(origem));
return 1;
}
else {
printf("Nao e possivel fazer este movimento.\n");
return 0;
}
}
char* concat(char* s1, char* s2) {
char *s;
int tam1 = tamanho(s1), tam2 = tamanho(s2), tam = tam1+tam2+1;
s = malloc(tam*sizeof(char));
int i,j;
for (i=0; i<tam1; i++) s[i] = s1[i];
for (j=0; j<tam2; j++,i++) s[i] = s2[j];
s[i] = '\0';
return s;
}
int main () {
LISTA lista;
construir(&lista);
adicionar(&lista, 4);
adicionar(&lista, 6);
adicionar(&lista, 7);
adicionar(&lista, 8);
tamanho(&lista);
mostrar(&lista);
adicionar(&lista, 45);
tamanho(&lista);
mostrar(&lista);
}
//Funcao que simula o duelo entre os jogadores 1 e 2
void duelo(struct deck *jogador1, struct deck *jogador2, struct deck *aux, struct dados *dados)
{
struct carta cartaaux, carta1, carta2;
int jogadas=0;
clock_t start, end;
clock_t diff;
start=clock();
while(tamanho(jogador1)!=0 && tamanho(jogador2)!=0)
{
carta1 = desenfileira(jogador1);
carta2 = desenfileira(jogador2);
if(carta1.valor > carta2.valor){
while(tamanho(aux)!=0){
cartaaux = desenfileira(aux);
enfileira(cartaaux.valor, cartaaux.naipe, jogador1);
}
enfileira(carta1.valor, carta1.naipe, jogador1);
enfileira(carta2.valor, carta2.naipe, jogador1);
}else if(carta1.valor < carta2.valor){
while(tamanho(aux)!=0){
cartaaux = desenfileira(aux);
enfileira(cartaaux.valor, cartaaux.naipe, jogador2);
}
enfileira(carta1.valor, carta1.naipe, jogador2);
enfileira(carta2.valor, carta2.naipe, jogador2);
}else{
if(tamanho(aux)!=0){
carta1 = desenfileira(jogador1);
carta2 = desenfileira(jogador2);
enfileira(carta1.valor, carta1.naipe, aux);
enfileira(carta2.valor, carta2.naipe, aux);
}
enfileira(carta1.valor, carta1.naipe, aux);
enfileira(carta2.valor, carta2.naipe, aux);
}
jogadas++;
}
end=clock();
diff = (end-start);
printf("Foram feitas %d jogadas\n", jogadas);
printf("A duracao foi de %lu milisegundos\n", diff);
insereDados(diff, jogadas, dados);
}
/* Libera a memoria de todos os elementos da matriz (memoria do arranjo A) e
zera a variavel linhas */
void liberarMatriz(PontMTS mat) {
int i;
int tam = tamanho(mat);
for (i=0;i<tam;i++) free(&(mat->A[i]));
mat->linhas=0;
return;
} /* liberarMatriz */
/* Calcula a eficiencia da representacao matriz diagonal
comparacao com a usual, em percentagem */
float eficiencia(MTI a) {
int m = a.linhas;
if (m!=0)
return 100.0*((tamanho(&a))*sizeof(int))/(m*m*sizeof(int));
else
return 0;
}
int compara(const char* primeira, const char* segunda){
int dif = 0;
int i = 0;
if(tamanho(primeira) > tamanho(segunda))
return 1;
if(tamanho(primeira) < tamanho(segunda))
return -1;
do{
dif = primeira[i] - segunda[i];
i++;
}while(dif == 0 && primeira[i] != '\0' && segunda[i] != '\0');
return dif;
}
void PesquisaDicionario(TDicionario D, TItem novo){
int i;
TDicionario aux = (D);
for ( i = 0; i < tamanho(D); i++){
aux = aux->prox;
}
}
/* Ordena a lista */
void ordena(Lista *p_l){
printf("erro");
No_lista *p, *q, *r;
int size = tamanho(p_l), cont ,i;
for(i = size - 1; i >= 1; i--){
r = NULL;
q = *p_l;
p = q->prox;
for(cont = 0; cont < i; cont++){
if(q->info > p->info){
if(r == NULL)
*p_l = p;
else
r->prox = q->prox;
q->prox = p->prox;
p->prox = q;
r = p;
q = r->prox;
p = q->prox;
}
else{
r = q;
q = q->prox;
p = p->prox;
}
}
}
}
int move(char str[], int pos, int qtd){
int i, nElemens = tamanho(str);
str[pos] = '*';
for(i = pos; i < nElemens; i++)
str[i+1] = str[i+qtd];
return 0;
}
int main() {
printf("HELLO");
LISTA l;
inicializar(&l);
REGISTRO reg;
reg.chave = 1;
inserirOrdenado(reg,&l);
reg.chave = 80;
inserirOrdenado(reg,&l);
reg.chave = 2332;
inserirOrdenado(reg,&l);
reg.chave = 2000;
inserirOrdenado(reg,&l);
reg.chave = 2000;
inserirOrdenado(reg,&l);
reg.chave = 43;
inserirOrdenado(reg,&l);
reg.chave = 1000000;
inserirOrdenado(reg,&l);
reg.chave = 54323;
inserirOrdenado(reg,&l);
printf("\nTAMANHO %d REGISTRO %d\n", tamanho(&l),reg.chave);
exibir(&l);
system("pause");
return 0;
}
int quebra(char chave[], char str[]){
int i = 0, j = 0, w = 0, x = 0, strSize = tamanho(str), chaSize = tamanho(chave);
while(i < strSize){
if(str[i] == '*'){
for(j = strSize; j > i; j--){
str[j+(chaSize-1)] = str[j];
}
x = i;
for(j = i; j < (x+(chaSize)); j++, w++){
str[j] = chave[w];
}
}
i++; w = 0; j = 0; x = 0; strSize = tamanho(str);
}
return 0;
}
void exibirArranjo(PontMTS matriz){
int tam = tamanho(matriz);
int i;
for (i=0;i<tam;i++){
printf("%3d ",matriz->A[i]);
}
return;
}
// Retorna a o ponteiro para o inicio da lista inversa a recebida
Lista* strinvert(Lista* l1) {
int i;
Lista* l2 = criaLista(), *percorre = l1->prox;
for (i = 1; i <= tamanho(l1); i++) {
insereLetra(l2, percorre->info);
percorre = percorre->prox;
}
return l2;
}
void concatenan(char* destino, char* origem, int n){
int i = 0;
int j = tamanho(destino);
while(origem[i] != '\0' && (j + i) < TAM - 1 && i < n){
destino[j + i] = origem[i];
i++;
}
destino[j + i] = '\0';
}
// Retorna um ponteiro para o inicio da lista resultante da concatenacao das listas recebidas
Lista* strconcat(Lista* l1, Lista* l2) {
int i, j;
Lista *l3 = criaLista(), *l4 = criaLista(), *percorre = l1->prox;
for (i = 1; i <= tamanho(l1); i++) {
insereLetra(l3, percorre->info);
percorre = percorre->prox;
}
percorre = l2->prox;
for (j = 1; j <= tamanho(l2); j++) {
insereLetra(l3, percorre->info);
percorre = percorre->prox;
}
percorre = l3->prox;
//para corrigir a ordem de insercao na lista
for (i = 1; i <= tamanho(l3); i++) {
insereLetra(l4, percorre->info);
percorre = percorre->prox;
}
return l4;
}
PontMTS SomaMatriz(PontMTS a, PontMTS b) {
int lin = a->linhas;
if (b->linhas != a->linhas) return NULL;
PontMTS c = (PontMTS) malloc(sizeof(MTS));
inicializarMatriz(lin,c);
int x;
int tam = tamanho(a);
for (x=0;x<tam;x++)
c->A[x] = a->A[x] + b->A[x];
return c;
}
void contaTexto(pLDDE pListaVertical){
int i,tam=0;
pLDDE pListaHorizontal;
i=1;
while(buscaNaPosLog(pListaVertical,&pListaHorizontal,i++) != FRACASSO){
tam+=tamanho(pListaHorizontal); // utiliza funcao "tamanho" para contar palavras
}
printf("\n");
printf("Seu arquivo contem %d palavras. \n", tam);
printf("\n");
}
// Converte uma lista de caracteres para uma string
void listconvertstr(Lista* l1, char* str) {
int i;
int tam = tamanho(l1);
Lista* percorre = l1->prox;
if (l1->prox != NULL) {
for (i = 0; i < tam; i++) {
str[i] = percorre->info;
percorre = percorre->prox;
}
str[tam] = '\0'; //fim da string(certificar-se de mandar str vazia, para nao haver conflito entre dois '\0')
}
}
// Função menu
void menu()
{
short int opcao = 1;
while(opcao != 0)
{
printf("\n"
"|--------------------------|\n"
"| Bem-vindo! |\n"
"|--------------------------|\n"
"| SELECIONE UMA OPCAO: |\n"
"| 1: CONCATENAR STRING |\n"
"| 2: COMPARAR STRING |\n"
"| 3: COPIAR STRINGS |\n"
"| 4: TAMANHO DA STRING |\n"
"| 0: SAIR |\n"
);
scanf("%d", &opcao);
system("cls");
switch(opcao)
{
case 0:
printf("\nFim da execucao!\n");
return;
case 1:
printf("\n---- CONCATENAR STRING ----\n");
concatena();
break;
case 2:
printf("\n---- COMPARAR STRING ----\n");
compara();
break;
case 3:
printf("\n---- COPIA STRING ----\n");
copia();
break;
case 4:
printf("\n---- TAMANHO DA STRING ----\n");
tamanho();
break;
default:
printf("OPCAO INVALIDA!\n");
}
}
}
main()
{
tipo_fila *fila,*fila2;
int i, numero=1;
fila = (tipo_fila *) malloc (sizeof(tipo_fila));
fila2 = (tipo_fila *) malloc(sizeof(tipo_fila));
inicializar_fila(fila);
inicializar_fila(fila2);
while (numero !=0)
{
printf("Leitura do valor : ");
scanf("%d", &numero);
enqueue(numero, fila);
}
copia(fila,fila2);
printf("tamanho da fila: %d\n", tamanho(fila));
printf("tamanho da fila2: %d\n", tamanho(fila2));
imprimir_fila(fila);
imprimir_fila(fila2);
getch();
}
// retorna uma "substring" obtida a partir de uma lista de caracteres
// caso seja impossivel criar a "substring" desejada, retorna NULL
Lista* substr(Lista* inicio, int i1, int i2) {
int i;
Lista* inicio_substr = criaLista(), * percorre = inicio->prox;
int tam1 = tamanho(inicio);
if (i1 + i2 <= tam1) {
for (i = 1; i <= i2; i++) {
insereLetra(inicio_substr, percorre->info);
percorre = percorre->prox;
}
return inicio_substr;
} else {
printf("Impossivel criar substring desse tamanho");
return NULL;
}
}
int sigilo(char chave[], char str[]){
int x = 0, i = 0, j = 0, m = tamanho(chave);
for(i = 0; str[i] != '\0'; i++){
for(j = 0; chave[j] != '\0'; j++){
if(str[i+j] == chave[j])
x++;
else
x = 0;
}
if(x == m){
x = 0;
move(str, i, m);
}
}
return 0;
}
//case 3
void executarPotenciacao(Lista *base, int *expoente, Lista *resultado)
{
if(*expoente < 0 || tamanho(base) == 0)
{
printf("Para efetuar a potenciacao, voce deve escolher primeiro os valores da Base e do Expoente. \n");
printf("Tente novamente.\n");
return;
}
resultado = potenciacao(base, *expoente);
printf("\nResultado: ");
imprimir(resultado);
printf("\n");
printf("Para calcular uma nova potencia, pressione qualquer tecla. \n");
getch();
}
Lista * listaXnum(Lista * l, int n) // funcionando perfeitamente
{
Lista * resultadoMult = criar();
int valor = 0; // resultado da multiplicação de 'n' por um valor da lista
int tam;
// multiplica 'n' por toda a lista 'l'
for(tam = tamanho(l); tam > 0; tam--)
{
valor = n*ler_pos(l, tam-1) + valor/10; //valor é um numero de dois digitos
inserir_primeiro(resultadoMult, valor%10); // insere a unidade no final
}
// ao terminar a multiplicacao, insere o "vai um", que é a dezena, no inicio do numero;
if(valor/10 > 0)
inserir_primeiro(resultadoMult, valor/10);
return resultadoMult;
}
int main(int argc, char **argv) {
inserir(3);
inserir(1);
inserir(90);
inserir(6);
inserir(40);
inserir(2);
inserir(4);
inserir(20);
/* Testar ordenação da lista */
int *values = get_list();
int compare[8] = {1, 2, 3, 4, 6, 20, 40, 90};
int i = 0;
for(; i < 8; i++) {
assert(compare[i] == values[i]);
}
/* Testes do metodo buscar */
assert(tamanho() == 8);
/* Testes do metodo buscar */
assert(buscar(200) == 0);
assert(buscar(20) == 1);
/* Testes do metodo remover */
remover(1);
remover(3);
remover(20);
int *values2 = get_list();
int compare2[5] = {2, 4, 6, 40, 90};
for(i = 0; i < 5; i++) {
assert(compare2[i] == values2[i]);
}
print_list();
return EXIT_SUCCESS;
}
node* split (node *head, int position) {
node *temphead = (node *) malloc(sizeof(node));
temphead = head;
int metade, j=0;
metade = tamanho(temphead)/2;
while(j!=metade) {
if(temphead->next != NULL) {
temphead = temphead->next;
j++;
}
else
return;
}
if(temphead!=NULL) {
node *temphead2 = (node *) malloc(sizeof(node));
if(!temphead2)
exit(4);
temphead2 = temphead->next;
temphead->next = NULL;
return temphead2;
}
}
int main() {
int estado = 1;
unsigned int discos = 0;
Pilha * A = criar();
Pilha * B = criar();
Pilha * C = criar();
while(estado != 1000){
switch(estado){
case 1 :
system("cls");
estado = inicializar(A, &discos);
break;
case 2 :
system("cls");
mostrarPinos(A,B,C);
case 3 :
mostrarPossibilidades(A,B,C);
case 4 :
estado = movimentar(A, B, C);
break;
case 5 :
if(tamanho(C) == discos){
estado = 6;
}
else{
estado = 2;
}
break;
case 6 :
terminar(A, B, C);
estado = 1000;
break;
}
}
printf("Jogo finalizado!!");
}
