AKTU 1er año Sem 2 Documento resuelto 2016-17 | COMP. SISTEMA Y PROGRAMACION C | Sec C

Posted on by Rudeus Greyrat

Enlace de descarga de papel : Papel | semestre 2 | 2016-17

Tecnología B.
(SEM-II) EXAMEN DE TEORIA 2016-17
SISTEMA INFORMÁTICO Y PROGRAMACIÓN EN C

Tiempo: 3 horas
Marcas totales : 100

Nota :-

  • Hay tres secciones. La Sección A lleva 20 puntos, la Sección B lleva 30 puntos y la Sección C lleva 50 puntos.
  • Intenta todas las preguntas. Las marcas se indica frente a cada pregunta.
  • Asumir datos adecuados siempre que sea necesario.

Sección – C

Intenta dos de las siguientes preguntas: (2*15 = 30)

3) Definir estructura con sintaxis. Además, escriba un programa que compare dos fechas dadas. Para almacenar la estructura de uso de fecha, digamos fecha que contiene tres miembros, a saber, fecha, mes y año. Si las fechas son iguales, muestra el mensaje como «Igual», de lo contrario, «Desigual».

  • Una estructura es un tipo de datos definido por el usuario en C/C++. Una estructura crea un tipo de datos que se puede usar para agrupar elementos de tipos posiblemente diferentes en un solo tipo.

    ¿Cómo crear una estructura?
    La palabra clave ‘struct’ se utiliza para crear una estructura. El siguiente es un ejemplo.

    struct address {
        char name[50];
        char street[100];
        char city[50];
        char state[20];
        int pin;
    };

     
    ¿Cómo declarar variables de estructura?
    Una variable de estructura puede declararse con una declaración de estructura o como una declaración separada como los tipos básicos.

    // A variable declaration with structure declaration.
    struct Point {
        int x, y;
    } p1; // The variable p1 is declared with 'Point'
      
    // A variable declaration like basic data types
    struct Point {
        int x, y;
    };
      
    int main()
    {
        struct Point p1; // The variable p1 is declared like a normal variable
    }

    Nota: En C++, la palabra clave struct es opcional antes de la declaración de una variable. En C, es obligatorio.

    Programa que compara dos fechas dadas:

    #include <stdio.h>
      
    // Declaring the structure of Date
    struct Date {
        int date;
        int month;
        int year;
    };
      
    // Driver code
    int main()
    {
        int date1, date2, month1,
            month2, year1, year2;
      
        // Get the first date
        scanf("%d", &date1);
        printf("Enter the first date: %d", date1);
        scanf("%d", &month1);
        printf("\nEnter the first month: %d", month1);
        scanf("%d", &year1);
        printf("\nEnter the first year: %d", year1);
      
        // Initialise the structure with first date
        struct Date Date1 = { date1, month1, year1 };
      
        // Get the second date
        scanf("%d", &date2);
        printf("\nEnter the second date: %d", date2);
        scanf("%d", &month2);
        printf("\nEnter the second month: %d", month2);
        scanf("%d", &year2);
        printf("\nEnter the second year: %d", year2);
      
        // Initialise the structure with first date
        struct Date Date2 = { date2, month2, year2 };
      
        printf("\nThe given dates are: ");
      
        // Comparing the Dates
        if (Date1.date == Date2.date
            && Date1.month == Date2.month
            && Date1.year == Date2.year) {
            printf("Equal");
        }
        else {
            printf("Unequal");
        }
      
        return 0;
    }

    Producción:

    Enter the first date: 10
Enter the first month: 11
Enter the first year: 2018
Enter the second date: 10
Enter the second month: 11
Enter the second year: 2018
The given dates are: Equal

    • 4 Escriba una breve nota sobre lo siguiente (cualquiera de los dos):

  • (i) Stack con operación push y pop : Stack es una estructura de datos lineal que sigue un orden particular en el que se realizan las operaciones. El orden puede ser LIFO (Last In First Out) o FILO (First In Last Out).

    Principalmente se realizan las siguientes tres operaciones básicas en la pila:

    • Empujar: agrega un elemento a la pila. Si la pila está llena, se dice que hay una condición de desbordamiento.
    • Pop: elimina un elemento de la pila. Los elementos se abren en el orden inverso al que se empujaron. Si la pila está vacía, se dice que es una condición de subdesbordamiento.
    • Peek o Top: Devuelve el elemento superior de la pila.
    • isEmpty: Devuelve verdadero si la pila está vacía, de lo contrario, devuelve falso.

    stack

    ¿Cómo entender una pila de forma práctica?
    Hay muchos ejemplos de la vida real de stack. Considere el ejemplo simple de los platos apilados unos sobre otros en la cantina. La placa que está en la parte superior es la primera que se retira, es decir, la placa que se ha colocado en la posición más baja permanece en la pila durante el mayor período de tiempo. Por lo tanto, se puede ver simplemente que sigue el orden LIFO/FILO.

    Tiempo Complejidades de las operaciones en la pila:

    push(), pop(), isEmpty() y peek() toman tiempo O(1). No ejecutamos ningún bucle en ninguna de estas operaciones.

    Aplicaciones de pila:

    Implementación:
    hay dos formas de implementar una pila:

    • Usando array
    • Usar lista enlazada

    Implementando Stack usando Arrays

    // C program for array implementation of stack
    #include <limits.h>
    #include <stdio.h>
    #include <stdlib.h>
      
    // A structure to represent a stack
    struct Stack {
        int top;
        unsigned capacity;
        int* array;
    };
      
    // function to create a stack of given capacity. It initializes size of
    // stack as 0
    struct Stack* createStack(unsigned capacity)
    {
        struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
        stack->capacity = capacity;
        stack->top = -1;
        stack->array = (int*)malloc(stack->capacity * sizeof(int));
        return stack;
    }
      
    // Stack is full when top is equal to the last index
    int isFull(struct Stack* stack)
    {
        return stack->top == stack->capacity - 1;
    }
      
    // Stack is empty when top is equal to -1
    int isEmpty(struct Stack* stack)
    {
        return stack->top == -1;
    }
      
    // Function to add an item to stack.  It increases top by 1
    void push(struct Stack* stack, int item)
    {
        if (isFull(stack))
            return;
        stack->array[++stack->top] = item;
        printf("%d pushed to stack\n", item);
    }
      
    // Function to remove an item from stack.  It decreases top by 1
    int pop(struct Stack* stack)
    {
        if (isEmpty(stack))
            return INT_MIN;
        return stack->array[stack->top--];
    }
    // Driver program to test above functions
    int main()
    {
        struct Stack* stack = createStack(100);
      
        push(stack, 10);
        push(stack, 20);
        push(stack, 30);
      
        printf("%d popped from stack\n", pop(stack));
      
        return 0;
    }
  • (ii) Lista enlazada : Al igual que las arrays, la Lista enlazada es una estructura de datos lineal. A diferencia de las arrays, los elementos de la lista enlazada no se almacenan en ubicaciones contiguas; los elementos se vinculan mediante punteros.

    lista enlazada

    ¿Por qué lista enlazada?
    Los arreglos se pueden usar para almacenar datos lineales de tipos similares, pero los arreglos tienen las siguientes limitaciones.
    1) El tamaño de las arrays es fijo: por lo que debemos conocer el límite superior en el número de elementos de antemano. Además, generalmente, la memoria asignada es igual al límite superior independientemente del uso.
    2) Insertar un nuevo elemento en una array de elementos es costoso, porque se debe crear espacio para los nuevos elementos y, para crear espacio, los elementos existentes deben cambiarse.

    Por ejemplo, en un sistema si mantenemos una lista ordenada de ID en una array id[].

    id[] = [1000, 1010, 1050, 2000, 2040].

    Y si queremos insertar un nuevo ID 1005, entonces para mantener el orden ordenado, tenemos que mover todos los elementos después de 1000 (excluyendo 1000).
    La eliminación también es costosa con arrays hasta que se utilicen algunas técnicas especiales. Por ejemplo, para eliminar 1010 en id[], todo lo que esté después de 1010 debe moverse.

    Ventajas sobre las arrays
    1) Tamaño dinámico
    2) Facilidad de inserción/eliminación

    Inconvenientes:
    1) No se permite el acceso aleatorio. Tenemos que acceder a los elementos de forma secuencial a partir del primer Node. Por lo tanto, no podemos realizar búsquedas binarias con listas enlazadas de manera eficiente con su implementación predeterminada. Lea sobre esto aquí .
    2) Se requiere espacio de memoria adicional para un puntero con cada elemento de la lista.
    3) No compatible con caché. Dado que los elementos de la array son ubicaciones contiguas, existe una localidad de referencia que no existe en el caso de las listas vinculadas.

    Representación:
    una lista enlazada se representa mediante un puntero al primer Node de la lista enlazada. El primer Node se llama cabeza. Si la lista enlazada está vacía, el valor de head es NULL.
    Cada Node en una lista consta de al menos dos partes:
    1) datos
    2) Puntero (o referencia) al siguiente Node
    En C, podemos representar un Node usando estructuras. A continuación se muestra un ejemplo de un Node de lista vinculada con datos enteros.

    // A linked list node
    struct Node {
        int data;
        struct Node* next;
    };
  • (iii) Argumento de la línea de comandos : la función más importante de C/C++ es la función main(). Se define principalmente con un tipo de retorno de int y sin parámetros: 
    int main() { /* ... */ }

    También podemos dar argumentos de línea de comandos en C y C++. Los argumentos de la línea de comandos se dan después del nombre del programa en el shell de línea de comandos de los sistemas operativos.
    Para pasar argumentos de la línea de comandos, normalmente definimos main() con dos argumentos: el primer argumento es el número de argumentos de la línea de comandos y el segundo es la lista de argumentos de la línea de comandos.

    int main(int argc, char *argv[]) { /* ... */ }

    o

    int main(int argc, char **argv) { /* ... */ }
    • argc (ARGument Count) es de tipo int y almacena el número de argumentos de la línea de comandos pasados ​​por el usuario, incluido el nombre del programa. Entonces, si le pasamos un valor a un programa, el valor de argc sería 2 (uno para el argumento y otro para el nombre del programa)
    • El valor de argc no debe ser negativo.
    • argv(ARGument Vector) es una array de punteros de caracteres que enumeran todos los argumentos.
    • Si argc es mayor que cero, los elementos de la array de argv[0] a argv[argc-1] contendrán punteros a strings.
    • Argv[0] es el nombre del programa, después de eso hasta argv[argc-1] cada elemento son argumentos de línea de comando.

    • 5. ¿Cuáles son los diferentes modos de apertura de archivos en C . Supongamos que un archivo contiene los registros de los estudiantes y cada registro contiene el nombre y la edad de un estudiante. Escriba un programa en C para leer estos registros y mostrarlos ordenados por nombre.

  • Modos de apertura de archivos en C:
    • “r” – Archivo de búsquedas. Si el archivo se abre con éxito, fopen() lo carga en la memoria y establece un puntero que apunta al primer carácter que contiene. Si el archivo no se puede abrir, fopen( ) devuelve NULL.
    • “w” – Archivo de búsquedas. Si el archivo existe, su contenido se sobrescribe. Si el archivo no existe, se crea un nuevo archivo. Devuelve NULL, si no puede abrir el archivo.
    • “a” – Archivo de búsquedas. Si el archivo se abre con éxito, fopen() lo carga en la memoria y configura un puntero que apunta al último carácter que contiene. Si el archivo no existe, se crea un nuevo archivo. Devuelve NULL, si no puede abrir el archivo.
    • “r+” – Busca archivos. Si se abre con éxito, fopen() lo carga en la memoria y configura un puntero que apunta al primer carácter que contiene. Devuelve NULL, si no puede abrir el archivo.
    • “w+” – Busca archivos. Si el archivo existe, su contenido se sobrescribe. Si el archivo no existe, se crea un nuevo archivo. Devuelve NULL, si no puede abrir el archivo.
    • “a+” – Busca archivos. Si el archivo se abre con éxito, fopen() lo carga en la memoria y configura un puntero que apunta al último carácter que contiene. Si el archivo no existe, se crea un nuevo archivo. Devuelve NULL, si no puede abrir el archivo.

    Programa en C para leer estos registros y mostrarlos ordenados por nombre:

    // C program to read Student records 
    // like id, name and age, 
    // and display them in sorted order by Name 
      
    #include <stdio.h> 
    #include <stdlib.h> 
    #include <string.h> 
      
    // struct person with 3 fields 
    struct Student { 
        char* name; 
        int id; 
        char age; 
    }; 
      
    // setting up rules for comparison 
    // to sort the students based on names 
    int comparator(const void* p, const void* q) 
    { 
        return strcmp(((struct Student*)p)->name, 
                    ((struct Student*)q)->name); 
    } 
      
    // Driver program 
    int main() 
    { 
        int i = 0, n = 5; 
      
        struct Student arr[n]; 
      
        // Get the students data 
        arr[0].id = 1; 
        arr[0].name = "bd"; 
        arr[0].age = 12; 
      
        arr[1].id = 2; 
        arr[1].name = "ba"; 
        arr[1].age = 10; 
      
        arr[2].id = 3; 
        arr[2].name = "bc"; 
        arr[2].age = 8; 
      
        arr[3].id = 4; 
        arr[3].name = "aaz"; 
        arr[3].age = 9; 
      
        arr[4].id = 5; 
        arr[4].name = "az"; 
        arr[4].age = 10; 
      
        // Print the Unsorted Structure 
        printf("Unsorted Student Records:\n"); 
        for (i = 0; i < n; i++) { 
            printf("Id = %d, Name = %s, Age = %d \n", 
                arr[i].id, arr[i].name, arr[i].age); 
        } 
        // Sort the structure 
        // based on the specified comparator 
        qsort(arr, n, sizeof(struct Student), comparator); 
      
        // Print the Sorted Structure 
        printf("\n\nStudent Records sorted by Name:\n"); 
        for (i = 0; i < n; i++) { 
            printf("Id = %d, Name = %s, Age = %d \n", 
                arr[i].id, arr[i].name, arr[i].age); 
        } 
      
        return 0; 
    } 

    Producción:

    Unsorted Student Records:
Id = 1, Name = bd, Age = 12 
Id = 2, Name = ba, Age = 10 
Id = 3, Name = bc, Age = 8 
Id = 4, Name = aaz, Age = 9 
Id = 5, Name = az, Age = 10 


Student Records sorted by Name:
Id = 4, Name = aaz, Age = 9 
Id = 5, Name = az, Age = 10 
Id = 2, Name = ba, Age = 10 
Id = 3, Name = bc, Age = 8 
Id = 1, Name = bd, Age = 12

    • Publicación traducida automáticamente

    Artículo escrito por RishabhPrabhu y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *