void testesOrdenacoes() {
int dados[] = { 4, 3, 1, 2, 0, 3, 5, 1, 2, -1, -2, 4, 8, 10, 4, 23, 2, -1, 5 };
/*printf( "Bubble Sort:\n" );
shuffle( dados, TAMANHO_ARRAY_ORDENACAO );
imprimir( dados, TAMANHO_ARRAY_ORDENACAO );
bubbleSort( dados, TAMANHO_ARRAY_ORDENACAO );
// ou => sort( &bubbleSort, dados, TAMANHO_ARRAY_ORDENACAO );
imprimir( dados, TAMANHO_ARRAY_ORDENACAO );
printf( "\nSelection Sort:\n" );
shuffle( dados, TAMANHO_ARRAY_ORDENACAO );
imprimir( dados, TAMANHO_ARRAY_ORDENACAO );
selectionSort( dados, TAMANHO_ARRAY_ORDENACAO );
// ou => sort( &selectionSort, dados, TAMANHO_ARRAY_ORDENACAO );
imprimir( dados, TAMANHO_ARRAY_ORDENACAO );
printf( "\nInsertion Sort:\n" );
shuffle( dados, TAMANHO_ARRAY_ORDENACAO );*/
imprimir( dados, TAMANHO_ARRAY_ORDENACAO );
insertionSort( dados, TAMANHO_ARRAY_ORDENACAO );
// ou => sort( &insertionSort, dados, TAMANHO_ARRAY_ORDENACAO );
imprimir( dados, TAMANHO_ARRAY_ORDENACAO );
}
int cdrom_cmd ( int idx, unsigned long num, word* buffer, word* pkt ) {
byte fase;
word puerto = descs_ide[idx].puerto_base;
byte id = descs_ide[idx].id_dispositivo;
imprimir ( "Se va a ejecutar %xw %xb\n", puerto, id );
atapi ( puerto, id );
/*
si reemplazo esto por atapi() funciona OK (?!?!?!)
if ( !seleccionar_dispositivo ( puerto, id ) ) {
imprimir ( "Error al seleccionar el dispositivo\n" );
}
outb ( 0, puerto + REG_FEATURE );
outb ( ((word)(32768 & 0xFF)), puerto + REG_LSB_CYL );
outb ( 32768 >> 8, puerto + REG_LSB_CYL );
outb ( 0x40 | id, puerto + REG_SEL_DRIVER );
delay ( MICRO(40000L) );
outb ( COMANDO_PAQUETE, puerto + COMANDO_PAQUETE );
delay ( MICRO(40000L) );
if ( leer_estado ( puerto, 0x88, 0x08, 50 ) ) {
imprimir ( "Error al leer estado!\n");
return -1;
}
fase = inb ( puerto + REG_ESTADO ) & 0x08;
fase |= (inb (puerto + REG_MOTIVO)) & 0x03;
if ( fase != FASE_SIN_COMANDO ) {
imprimir ("Fase erronea: %xb\n", fase);
return -1;
}
*/
escribir_puerto ( puerto + REG_DATOS, (word*) pkt, 12 );
while (1) {
if ( esperar_irq ( 0xC000, 1000 ) == 0 ) {
imprimir ( "No se disparo la IRQ!!\n" );
}
delay ( MICRO(10000L) );
fase = inb ( puerto + REG_ESTADO ) & 0x08;
fase |= (inb (puerto + REG_MOTIVO)) & 0x03;
if ( fase == FASE_FINALIZO ) {
imprimir ( "Escritura exitosa!\n" );
return 0;
}
}
return -1;
}
int main (){
Tno *cabeca;
cabeca = enfileirarPrimeiro(cabeca,0,0,0);
enfileirar(cabeca,1,1,1);
enfileirar(cabeca,2,2,2);
enfileirar(cabeca,3,3,3);
enfileirar(cabeca,4,4,4);
enfileirar(cabeca,5,5,5);
enfileirar(cabeca,6,6,6);
enfileirar(cabeca,7,7,7);
imprimir(cabeca);
desenfileirar(cabeca);
desenfileirar(cabeca);
desenfileirar(cabeca);
desenfileirar(cabeca);
desenfileirar(cabeca);
desenfileirar(cabeca);
desenfileirar(cabeca);
desenfileirar(cabeca);
imprimir(cabeca);
return 0;
}
int main(int argc, const char **argv){
int A[M][P];
int B[P][N];
int C[M][N];
// Pedir lo valores de la matriz
rellenar((int *)A, M, P, "primera: A");
imprimir((int *)A, M, P, "A");
rellenar((int *)B, P, N, "segunda: B");
imprimir((int *)B, P, N, "B");
// Hacer la multiplicación.
// Calcular cada i,j de C
for (int i=0; i<M; i++)
for (int j=0; j<N; j++){
C[i][j] = 0;
for (int k=0; k<P; k++)
C[i][j] += A[i][k] * B[k][j];
}
// Mostrar el resultado.
imprimir((int *)C, M, N, "Resultado");
return EXIT_SUCCESS;
}
int main() {
int i;
//criar a lista
LISTA_LIGADA_CIRCULAR lista;
criar(&lista);
//inserir itens na &lista
for (i = 0; i < 10; i++) {
ITEM item;
item.chave = i;
item.valor = rand();
inserir_fim(&lista, &item);
}
imprimir(&lista);
ITEM item1;
if (buscar(&lista, 9, &item1)) {
printf("encontrado: %d - %d\n---\n", item1.chave, item1.valor);
}
remover_posicao(&lista, 9);
ITEM item2;
item2.chave = 111;
item2.valor = 333;
inserir_fim(&lista, &item2);
imprimir(&lista);
apagar_lista(&lista);
return 0;
}
void mostrarPinos(Pilha * pino1, Pilha * pino2, Pilha * pino3){
printf("A: ");
imprimir(pino1);
printf("B: ");
imprimir(pino2);
printf("C: ");
imprimir(pino3);
}
static void _imprimirVetorDinamico(TVetorDinamico* v, void (*imprimir)(void*)){
TDadoVetorDinamico* dado = v->dado;
if(!dado) return;
void** vetor = dado->vetor;
unsigned i, n = dado->ocupa;
for(i=0; i < n-1; ++i){ imprimir(vetor[i]); printf(", "); }
imprimir(vetor[i]);
}
int main(){
int *a, tam;
a = inicializar(&tam);
ingresa(a, tam);
imprimir(a, tam);
seleccion(a,tam);
imprimir(a,tam);
return 0;
}
int main(int argc, char* argv[]) {
int enteros[] = {1,2,3,4};
float decimales[] = {1.1,2.2};
double DECIMALES[] = {3.1,3.2};
imprimir(enteros, sizeof(int), sizeof(enteros)/sizeof(int), &imprimir_entero);
imprimir(decimales, sizeof(float), sizeof(decimales)/sizeof(float), &imprimir_flotante);
imprimir(DECIMALES, sizeof(double), sizeof(DECIMALES)/sizeof(double), &imprimir_double);
}
int main(void){
double a=2.5,b=3,resultado;
imprimir();
resultado=suma(a,b);
printf("%g\n",resultado);
resultado=multiplicacion(a,b);
printf("%f\n",resultado);
imprimir();
return 0;
}
/**
* Tarea oseosa que va imprimiendo su propio nombre y su PID.
*/
void tarea_dummy() {
imprimir ("%c", *(tarea_actual->dato++));
//PAUSA
while (*(tarea_actual->dato) != '\0') {
delay (MICRO(50000L));
imprimir ("%c", *(tarea_actual->dato++));
//PAUSA
}
imprimir ("%d", tarea_actual->pid);
}
int main(){
int *a, tam = 1;
printf("metodo ordenamiento burbuja con arreglos\n");
a = crea_arreglo(&tam);
imprimir(a,tam);
burbuja(a,tam);
imprimir(a,tam);
free(a);
return 0;
}
int main()
{
int numeros[10] = {1,3,6,2,4,3,1,8,6,9};
imprimir (numeros, 10);
sort(numeros, 10);
imprimir (numeros, 10);
rsort(numeros, 10);
imprimir (numeros, 10);
return EXIT_SUCCESS;
}
void ArbolBinario::imprimir(NodoArbol* padre)
{
if(padre==NULL)
return;
std::cout<<padre->numero<<std::endl;
imprimir(padre->hijo_der);
imprimir(padre->hijo_izq);
}
int main(){
Sort<asc> test;
int *lista=new int[11];
int e=0;
for(int i=11;i>-1;--i){
lista[e]=i;++e;
}
imprimir(lista,lista+11);
test.burbuja(lista,lista+11);
imprimir(lista,lista+11);
}
void Arvore::imprimir(No* pNo)
{
if(pNo != NULL)
{
imprimir(pNo->getEsquerda());
cout<<pNo->getValor()<<" - ";
cout<<altura(pNo)<<" ";
cout<<" - "<<pNo->getPeso()<<endl;
imprimir(pNo->getDireita());
}
}
void ArbolBinario::imprimir(Elemento* nodo, ostream& out, int profundidad) {
if(nodo->hIzq != NULL) {
imprimir(nodo->hIzq, out, profundidad + 1);
}
for (int i = 0; i < profundidad; ++i) {
cout << "\t";
}
out << *nodo << endl;
if(nodo->hDer != NULL) {
imprimir(nodo->hDer, out, profundidad + 1);
}
}
//main
int main(int argc, char *argv[])
{
int matriz[6][4];
srand(time(NULL));
randomizer(matriz);
imprimir(matriz);
changer(matriz);
printf("\n");
imprimir(matriz);
system("PAUSE");
return 0;
}
/**
*
* Funcion que imprime el arbol en notacion preorden.
*
**/
void imprimir(Arbol *a, FILE *filetree, char nombres[][35])
{
int x;
if(a != NULL)
{
x = a->valor;
/* printf("%d ", x); */
salidaGraphviz(a, nombres[x], filetree);
imprimir(a->izq, filetree, nombres);
imprimir(a->der, filetree, nombres);
}
}
void imprimir(struct nodo * raiz, int contador){
int i,j;
i = contador;
if(raiz != NULL){
imprimir(raiz->derecho,++i);
printf("\n");
for(j = 1; j < i; j++){
printf("-");
}
printf("%d",raiz->dato);
imprimir(raiz->izquierdo,++i);
}
}
void RBTree::imprimir( RBNode* raiz )
{
//Si el hijo izquierdo no es centinela recorro ese primero
if( raiz->getLeft()->getCentinel() == false)
imprimir( raiz->getLeft());
//Imprimo el nodo actual
cout << raiz->getKey() << " " << raiz->getElement()<< " "<< raiz->getAltura() << endl;
//Si el hijo derecho no es centinela recorro ese sub-arbol
if( raiz->getRight()->getCentinel() == false)
imprimir( raiz->getRight());
}
int listar_cd ( dword base, byte id ) {
int i, j, k;
byte lectura;
for ( i = 0; i < 1; i++ ) {
atapi ( base, id );
outw ( 0x43 + 0x2 * 0x100, base );
outw ( 0x00, base );
outw ( 0x00, base );
outw ( 0x00, base );
outw ( 0xC8, base );
outw ( 0x00, base );
inb ( base );
for ( j = 0; j < 500; j++ ) {
//.cdtrnwewait
delay ( MICRO(10000L) );
lectura = inb ( base + 7 );
//imprimir ( "lectura: 0x%xb\n", lectura );
/**
* Se chequea que el bit 7 no haya venido en uno
*/
if ( (lectura & 0x80) == 0x00 ) {
//.cdtrl1
k = 0;
//.cdtrread
while ( k++ < 100) {
lectura = inb ( base + 7 );
//imprimir ( "lectura1: 0x%xb\n", lectura );
/**
* 0x50 = 0101 0000
* 0x08 = 0000 1000
*/
if ( 1 || (lectura & 0x08) == 0x08 ) {
imprimir ( "lei: 0x%xw ", inw ( base ) );
} else {
imprimir ( "inb\n" );
break;
//return 0;
}
}
break;
//return 0;
}
}
}
imprimir ("saliendo...\n");
return -1;
}
int main () {
struct no * lista = NULL; //inicializacao da lista: lista vazia
int opcao, elem;
do {
printf ("\n 1-inserir inicio 2-inserir final");
printf ("\n 3-remover inicio 4-remover final");
printf ("\n 5-imprimir lista 0-sair : ");
scanf ("%d", &opcao);
switch (opcao) {
case 1: printf ( "\n***Inserindo no inicio da lista***");
printf ("\nValor a ser inserido: ");
scanf ("%d", &elem);
inserir_inicio (elem, &lista);
imprimir (lista);
break;
case 2: printf ( "\n***Inserindo no final da lista***");
printf ("\nValor a ser inserido: ");
scanf ("%d", &elem);
inserir_final (elem, &lista);
imprimir (lista);
break;
case 3: printf ( "\n***Removendo do inicio da lista***");
if (lista != NULL) {
elem = remover_inicio (&lista);
printf ("\nValor removido: %d ", elem);
}
else
printf ("\nLista Vazia!");
imprimir (lista);
break;
case 4: printf ( "\n***Removendo do final da lista***");
if (lista != NULL) {
elem = remover_final (&lista);
printf ("\nValor removido: %d ", elem);
}
else
printf ("\nLista Vazia!");
imprimir (lista);
break;
case 5: imprimir (lista);
break;
case 0: printf ("\nSaindo....");
break;
default: printf ("\nOpcao Invalida!");
}
} while (opcao != 0);
system ("pause");
return (0);
}
/**
* buscar_entrada: busca una entrada dentro del root directory
* @param nombre nombre de la entrada a buscar
* @param arch puntero a la variable donde se almacenaran los datos
* de la entrada encontrada
*
* @return el estado de la operacion
*/
int buscar_entrada ( char* nombre, entrada_directorio* arch ) {
int indice, j;
int sector_dir_raiz;
int tamanio_dir_raiz;
int cant_entradas = 512 / sizeof(entrada_directorio);
entrada_directorio ed[cant_entradas];
if ( sector_booteo == NULL ) {
if ( cargar_BPB (sector_booteo) == ERROR ) {
imprimir ("Error cargando el sector de booteo\n");
return ERROR;
}
}
/*
* calculo el primer sector del directorio raiz:
* 1 (BPB) + cant_sectores_reservados + tam_FAT * cant_tablas_FAT
*/
sector_dir_raiz = sector_booteo->BPB_cant_sectores_reservados + 1 +
sector_booteo->BPB_tamanio_FAT * sector_booteo->BPB_cant_FAT;
/*
* calculo la cantidad de sectores que ocupa el directorio raiz
* Nota: se redondea para arriba!
*/
tamanio_dir_raiz = ( sector_booteo->BPB_cant_entradas_root *
sizeof ( entrada_directorio ) + 512 ) / 512;
// leo los N sectores del directorio raiz
for ( indice = 0; indice < tamanio_dir_raiz; indice++ ) {
if ( leer_sector_logico ( sector_dir_raiz++, ed ) == LECTURA_ERRONEA ) {
imprimir ( "Error leyendo directorio raiz!\n" );
return ERROR;
}
for ( j = 0; j < cant_entradas; j++ ) {
if ( ed[j].nombre[0] == ULTIMA_ENTRADA ) {
return ERROR;
} else if ( ed[j].atributos != ATR_NOMBRE_LARGO &&
ed[j].atributos != ATR_ID_UNIDAD &&
ed[j].nombre[0] != BORRADO ) {
if ( comparar_nombres ( nombre, ed[j].nombre ) == OK ) {
*arch = ed[j];
return OK;
}
}
}
}
return ERROR;
}
void fun2 ()
{
int i=0; /*i es el turno (los pares corresponden al jugador 2 y los impares al jugador 1)*/
int x=0; /*x es la casilla del tabñero a seleccionar*/
while (i<10){
system ("cls");
imprimir (Tablero);
if ((det_ganador (Tablero)==1)||(det_ganador (Tablero)==2)){
break;
}
else{
if (i%2==0){
printf ("\n\n\nIngrese la casilla que desea : ");
scanf ("%d", &x);
if ((x>10)||(x<1)){
printf ("\nIngrese una opción válida.");
getch ();
}
else{
if ((Tablero[Vc[x-1]]==88)||(Tablero[Vc[x-1]]==79)){
printf ("\nLa casilla seleccionada ya ha sido escogida.");
getch ();
}
else{
mod_tablero (Tablero, x, 1);
i++;}
}
}
else{
x=1+(rand()%9);
if ((Tablero[Vc[x-1]]==88)||(Tablero[Vc[x-1]]==79)){
printf ("\nLa casilla seleccionada ya ha sido escogida.");
getch ();
}
else {
mod_tablero (Tablero, x, 2);
i++;
}
}
}
if (i==9)
i++;
}
system ("cls");
imprimir (Tablero);
ganador (det_ganador (Tablero));
}
int main(int argc, char** argv) {
RubroNegra arvore;
arvore = novaRubroNegra();
int chave;
char operacao;
void* resultadoBusca;
while (operacao != 'q') {
usage();
operacao = getchar();
getchar();
switch (operacao) {
case 'i':
scanf("%d", &chave);
printf("Inserindo chave: [%d].\n", chave);
if (inserir(arvore, chave, (void*) chave)) printf("Chave [%d] já existe.\n", chave);
else
printf("Chave [%d] inserida.\n", chave);
getchar();
break;
case 'r':
scanf("%d", &chave);
printf("Removendo chave: [%d].\n", chave);
if (remover(arvore, chave)) printf("Chave [%d] não encontrada.\n", chave);
else
printf("Chave [%d] removida.\n", chave);
getchar();
break;
case 'b':
scanf("%d", &chave);
printf("Buscando chave: [%d].\n", chave);
resultadoBusca = buscar(arvore, chave);
if (resultadoBusca == NULL) printf("Chave [%d] não encontrada.\n", chave);
else
printf("Resultado da busca: [%d].\n", (int) resultadoBusca);
getchar();
break;
case 'p':
printf("Imprimindo árvore.\n");
imprimir(arvore);
break;
case 'd':
printf("Destruindo árvore.\n");
destruir(arvore);
printf("Árvore destruída.\n");
break;
default:
usage();
break;
}
}
return 0;
}
int carregar_arquivo(struct arquivo *p_arquivo, char *p_caminho)
{
if (p_caminho == NULL)
return 0;
p_arquivo->caminho = p_caminho;
FILE *f = fopen(p_arquivo->caminho, "rb");
if (!f)
return 0;
fseek(f, 0, SEEK_END);
p_arquivo->tamanho = ftell(f);
rewind(f);
if (p_arquivo->tamanho == -1)
return 0;
p_arquivo->conteudo = malloc(sizeof(char) * (p_arquivo->tamanho+1));
size_t newLen = fread(p_arquivo->conteudo, sizeof(char), p_arquivo->tamanho, f);
if(newLen == 0)
{
imprimir(COR_VERMELHO, "Ops! Ocorreu um erro ao ler o arquivo: %s\nTente novamente!", p_arquivo->caminho);
}
else
{
p_arquivo->conteudo[++newLen] = '\0';
}
fclose(f);
return 1;
}
int int main()
{
struct cdsMusica cd1={"Brindo con el alma", "Diomedes Diaz", "Vallenato", 11,1986,19900};
imprimir(cd1);//??
return 0;
}
int main(int argc, char *argv[])
{
char *entrada=argv[1], *saida=argv[2]; //Obtendo o nome dos arquivos passados por parametro ao executar o programa
int instancias,aux;
FILE *input= fopen (entrada,"r"); //Abertura do arquivo de leitura de dados.
FILE *out= fopen (saida,"w+a"); //Abertura do arquivo para gravação dos dados de saida.
Matriz *MAT;
if(input == NULL ) //Verificar se o arquivo de entrada não pode ser aberto.
{
fprintf(out,"ERRO 01: Houve algum problema ao abrir o seu arquivo de texto, verifique se o arquivo existe ou se o nome digitado esta correto");
fclose(input);
fclose(out);
return 0;
}
fscanf(input,"%d ",&instancias);
if(instancias <= 0) //Verifica se o número de instãncias lido é permitido.
{
fprintf(out,"ERRO 02: Número de instâncias insuficiente");
fclose(out);
fclose(input);
return 0;
}
while(instancias > 0)//Loop para executar as leituras e operações das matrizes de acordo com o número de instâncias.
{
MAT = criar(MAT,input,out);
MAT = carregar(MAT,input);
MAT = verificar(MAT,input,out);
imprimir(MAT,out,instancias);
liberar(MAT);
instancias--;
}
fclose(out); //fechamento dos arquivos utilizados durante o programa
fclose(input);
return 0;
}
void permutar (int A[], int size, int cp){//cp: combinaciones posibles
int comb = 1;
int i = 0;
int j = 1;
int c;
printf("-----Permutaciones-----\n");
while(comb <= cp/2){
imprimir(A, size);
int aux[size];
for(c = 0; c < size; c++){
aux[c] = A[c];
}
invertir(aux, size);
intercambiar(&A[i], &A[j]);
i++; j++;
if(j%size == 0){
j = 0;
}
else if(i%size == 0){
i = 0;
}
comb++;
}
}
