Las siguientes son algunas preguntas de la entrevista de programación C junto con sus respuestas.
(1) ¿Qué se generará si compila y ejecuta el siguiente código c?
marcas de estructura {
- No puedo resolver preguntas en InterviewBit. ¿Eso significa que voy a tener un desempeño pobre en la entrevista técnica?
- ¿Por qué el entrevistador hace preguntas algorítmicas de codificación agrietadas en las entrevistas de programación técnica?
- Cómo mejorar en la resolución lógica de problemas algorítmicos para entrevistas técnicas
- Antes de una entrevista, ¿los entrevistadores de las principales compañías de software están actualizando su conocimiento de algoritmos / estructura de datos?
- ¿Está predispuesto Facebook hacia los candidatos a entrevistas que son los mejores clasificados en las competencias de programación en línea?
int p: 3;
int c: 3;
int m: 2;
};
vacío principal(){
marcas de estructura s = {2, -6,5};
printf (“% d% d% d”, sp, sc, sm);
}
(a) 2-6 5
(b) 2 -6 1
(c) 2 2 1
(d) Error del compilador
(e) Ninguno de estos
Respuesta: (c)
Explicación:
Valor binario de 2: 00000010 (Seleccione tres dos bits)
Valor binario de 6: 00000110
Valor binario de -6: 11111001 + 1 = 11111010
(Seleccione los últimos tres bits)
Valor binario de 5: 00000101 (Seleccione los últimos dos bits)
Representación completa de la memoria:
(2) ¿Qué se generará si compila y ejecuta el siguiente código c?
vacío principal(){
int enorme * p = (int enorme *) 0XC0563331;
int enorme * q = (int enorme *) 0xC2551341;
* p = 200;
printf (“% d”, * q);
}
(a) 0
(b) Valor de basura
(c) nulo
(d) 200
(e) Error del compilador
Respuesta: (d)
Explicación:
Dirección física del gran puntero p
Dirección enorme: 0XC0563331
Dirección compensada: 0x3331
Dirección del segmento: 0XC056
Dirección física = Dirección del segmento * 0X10 + Dirección de desplazamiento
= 0XC056 * 0X10 + 0X3331
= 0XC0560 + 0X3331
= 0XC3891
Dirección física del gran puntero q
Dirección enorme: 0XC2551341
Dirección de desplazamiento: 0x1341
Dirección del segmento: 0XC255
Dirección física = Dirección del segmento * 0X10 + Dirección de desplazamiento
= 0XC255 * 0X10 + 0X1341
= 0XC2550 + 0X1341
= 0XC3891
Dado que los dos punteros enormes p y q apuntan a la misma dirección física, el contenido de q también será el mismo que el contenido de q.
(3) Escriba el programa c que muestra el puntero del mouse y la posición del puntero. (En la coordenada x, coordenada y)
Responder:
#incluye “dos.h”
#include “stdio.h”
vacío principal()
{
unión REGS i, o;
int x, y, k;
// muestra el puntero del mouse
ixax = 1;
int86 (0x33, & i, & o);
while (! kbhit ()) // su valor será falso cuando presionamos la tecla en el teclado
{
ixax = 3; // obtener la posición del mouse
x = oxcx;
y = oxdx;
clrscr ();
printf (“(% d,% d)”, x, y);
retraso (250);
int86 (0x33, & i, & o);
}
getch ();
}
(4) Escriba el programa ac para crear el comando dos: dir.
Responder:
Paso 1: Escribe el siguiente código.
#include “stdio.h”
#incluye “dos.h”
void main (int count, char * argv []) {
struct find_t q;
int a;
si (cuenta == 1)
argv [1] = “*. *”;
a = _dos_findfirst (argv [1], 1, & q);
if (a == 0) {
mientras que (! a) {
printf (“% s \ n”, q.name);
a = _dos_findnext (& q);
}
}
más{
printf (“Archivo no encontrado”);
}
}
Paso 2: guarde como list.c (puede dar cualquier nombre)
Paso 3: compila y ejecuta el archivo.
Paso 4: Escribe clic en Mi computadora del sistema operativo Windows XP y selecciona propiedades.
Paso 5: Seleccione Avanzado -> Variables de entorno
Paso 6: Encontrará la siguiente ventana:
Haga clic en el botón nuevo (botón dentro del cuadro rojo)
Paso 7: Escribe lo siguiente:
Nombre de la variable: ruta
Valor variable: c: \ tc \ bin \ list.c (Ruta donde ha guardado)
Paso 8: Abra el símbolo del sistema y escriba la lista y presione Entrar.
Tutorial de argumento de línea de comando.
(6) ¿Qué se generará si compila y ejecuta el siguiente código c?
vacío principal(){
int i = 10;
estático int x = i;
si (x == i)
printf (“Igual”);
más si (x> i)
printf (“Mayor que”);
más
printf (“Menor que”);
}
(a) Igual
(b) Mayor que
(c) Menos de
(d) Error del compilador
(e) Ninguno de los anteriores
Respuesta: (d)
Explicación:
Las variables estáticas son entidades de tiempo de carga, mientras que las variables automáticas son entidades de tiempo de ejecución. No podemos inicializar ninguna variable de tiempo de carga por la variable de tiempo de ejecución.
En este ejemplo, i es variable de tiempo de ejecución, mientras que x es variable de tiempo de carga.
Propiedades de las variables estáticas.
Propiedades de las variables automáticas.
(7) ¿Qué se generará si compila y ejecuta el siguiente código c?
vacío principal(){
int i;
flotante a = 5.2;
char * ptr;
ptr = (char *) & a;
para (i = 0; i <= 3; i ++)
printf (“% d”, * ptr ++);
}
(a) 0 0 0 0
(b) Basura Basura Basura Basura
(c) 102 56-80 32
(d) 102102-90 64
(e) Error del compilador
Respuesta: (d)
Explicación:
En c, el tipo de datos flotantes es de cuatro bytes, mientras que el puntero de caracteres ptr puede apuntar un byte de memoria a la vez.
Representación de memoria de flotante a = 5.2
El puntero ptr apuntará el primer cuarto byte, luego el tercer byte, luego el segundo byte y luego el primer byte.
Contenido del cuarto byte:
Valor binario = 01100110
Valor decimal = 64 + 32 + 4 + 2 = 102
Contenido del tercer byte:
Valor binario = 01100110
Valor decimal = 64 + 32 + 4 + 2 = 102
Contenido del segundo byte:
Valor binario = 10100110
Valor decimal = -128 + 32 + 4 + 2 = -90
Contenido del primer byte:
Valor binario = 01000000
Valor decimal = 64
Nota: el puntero de caracteres trata el bit MSB de cada byte, es decir, el bit más izquierdo de la figura anterior como bit de signo.
(8) ¿Qué se generará si compila y ejecuta el siguiente código c?
vacío principal(){
int i;
doble a = 5.2;
char * ptr;
ptr = (char *) & a;
para (i = 0; i <= 7; i ++)
printf (“% d”, * ptr ++);
}
(a) -51-52-52-52-52-52 20 64
(b) 51 52 52 52 52 52 20 64
(c) Ocho valores de basura.
(d) Error del compilador
(e) Ninguno de estos
Respuesta: (a)
Explicación:
En c, el tipo de datos doble es un tipo de datos de ocho bytes, mientras que el puntero de caracteres ptr puede apuntar un byte de memoria a la vez.
Representación de memoria de doble a = 5.2
el puntero ptr apuntará primero octavo byte luego séptimo byte luego sexto byte luego quinto byte luego cuarto byte luego tercer byte luego segundo byte luego primer byte como se muestra en la figura anterior.
Contenido del octavo byte:
Valor binario = 11001101
Valor decimal = -128 + 64 + 8 + 4 + 1 = -51
Contenido del séptimo byte:
Valor binario = 11001100
Valor decimal = -128 + 64 + 8 + 4 = -52
Contenido del sexto byte:
Valor binario = 11001100
Valor decimal = -128 + 64 + 8 + 4 = -52
Contenido del quinto byte:
Valor binario = 11001100
Valor decimal = -128 + 64 + 8 + 4 = -52
Contenido del cuarto byte:
Valor binario = 11001100
Valor decimal = -128 + 64 + 8 + 4 = -52
Contenido del tercer byte:
Valor binario = 11001100
Valor decimal = -128 + 64 + 8 + 4 = -52
Contenido del segundo byte:
Valor binario = 000010100
Valor decimal = 16 + 4 = 20
Contenido del primer byte:
Valor binario = 01000000
Valor decimal = 64
Nota: el puntero de caracteres trata el bit MSB de cada byte, es decir, el bit más izquierdo de la figura anterior como bit de signo.
(9) ¿Qué se generará si compila y ejecuta el siguiente código c?
vacío principal(){
printf (“% s”, “c” “pregunta” “banco”);
}
(a) c banco de preguntas
(antes de Cristo
(c) banco
(d) cquestionbank
(e) Error del compilador
Respuesta: (d)
Explicación:
En la cadena c, la constante “xy” es igual a “x”, “y”
Tutorial de cuerdas.
(10) ¿Qué se generará si compila y ejecuta el siguiente código c?
vacío principal(){
printf (“% s”, __ FECHA__);
}
(a) Fecha actual del sistema
(b) Fecha actual del sistema con hora
(c) nulo
(d) Error del compilador
(e) Ninguno de estos
Respuesta: (a)
Explicación:
__DATE__ es un identificador global que devuelve la fecha actual del sistema.
(11) ¿Qué se generará si compila y ejecuta el siguiente código c?
vacío principal(){
char * str = “puntero c”;
printf (“% *. * s”, 10,7, str);
}
(a) puntero en C
(b) puntero en C
(c) punto c
(d) cpointer nulo nulo
(e) punto c
Respuesta: (e)
Explicación:
Significado de% *. * S en la función printf:
Primero * indica el ancho, es decir, cuántos espacios se necesitarán para imprimir la cadena y segundo * indica cuántos caracteres se imprimirán de cualquier cadena.
La siguiente figura ilustra la salida del código anterior:
Propiedades de la función printf.
(12) ¿Qué se generará si compila y ejecuta el siguiente código c?
inicio nulo ();
fin vacío ();
#pragma start start
#pragma final de salida
int static i;
vacío principal(){
printf (“\ n función principal:% d”, ++ i);
}
inicio nulo () {
clrscr ();
printf (“\ n función de inicio :% d”, ++ i);
}
fin vacío () {
printf (“\ función nend :% d”, ++ i);
getch ();
}
(una)
función principal: 2
función de inicio: 1
función final: 3
(si)
función de inicio: 1
función principal: 2
función final: 3
(C)
función principal: 2
función final: 3
función de inicio: 1
(d) Error del compilador
(e) Ninguno de estos
Respuesta: (b)
Explicación:
Cada programa c comienza con la función principal y termina con una declaración nula. Pero el inicio de #pragma puede llamar a la función justo antes de la función principal y la salida de #pragma
¿Qué es la directiva pragma?
Tutorial de preprocesador.
(13) ¿Qué se generará si compila y ejecuta el siguiente código c?
vacío principal(){
int a = -12;
a = a >> 3;
printf (“% d”, a);
}
(a) -4
(b) -3
(c) -2
(d) -96
(e) Error del compilador
Respuesta 🙁 c)
Explicación:
El valor binario de 12 es: 00000000 00001100
El valor binario de -12 será el complemento de 2 de 12, es decir
Entonces el valor binario de -12 es: 11111111 11110100
Regla de desplazamiento a la derecha:
Regla 1: Si el número es positivo, llene los espacios vacantes en el lado izquierdo con 0.
Regla 2: si el número es negativo, llene los espacios vacantes en el lado izquierdo con 1.
En este caso el número es negativo. Por lo tanto, desplazar a la derecha todos los dígitos binarios por tres espacios y llenar el espacio vacante por 1 como se muestra en la siguiente figura:
Como es un número negativo, la salida también será un número negativo pero su complemento es 2.
Por lo tanto, la salida final será:
Y su valor decimal es: 2
Por lo tanto, la salida será: -2
(14) ¿Qué se generará si compila y ejecuta el siguiente código c?
#include “string.h”
vacío principal(){
clrscr ();
printf (“% d% d”, sizeof (“cadena”), strlen (“cadena”));
getch ();
}
(a) 6 6
(b) 7 7
(c) 6 7
(d) 7 6
(e) Ninguno de estos
Respuesta: (d)
Explicación:
El operador Sizeof devuelve el tamaño de la cadena que incluye el carácter nulo, mientras que la función strlen devuelve la longitud de una cadena que excluye el carácter nulo.
(15) ¿Qué se generará si compila y ejecuta el siguiente código c?
vacío principal(){
principal estático;
int x;
x = llamada (principal);
clrscr ();
printf (“% d”, x);
getch ();
}
int call (int address) {
dirección ++;
dirección del remitente;
}
(a) 0
(b) 1
(c) Valor de basura
(d) Error del compilador
(e) Ninguno de estos
Respuesta: (b)
Explicación:
Como sabemos, main no es una palabra clave de c pero es un tipo especial de función. Word main puede ser una variable de nombre en main y otras funciones.
¿Cuál es la función principal en c?
(16) ¿Qué se generará si compila y ejecuta el siguiente código c?
vacío principal(){
int a, b;
a = 1,3,15;
b = (2,4,6);
clrscr ();
printf (“% d”, a + b);
getch ();
}
(a) 3
(b) 21
(c) 17
(d) 7
(e) Error del compilador
Respuesta: (d)
Explicación:
En c, la coma se comporta como separador y como operador.
a = 1, 3, 15;
b = (2, 4, 6);
En las dos declaraciones anteriores, la coma funciona como operador. La coma goza de menor precedencia y la asociativa se deja de derecha a izquierda.
Asignando la prioridad de cada operador en la primera declaración:
Por lo tanto, 1 asignará a a.
Asignando la prioridad de cada operador en la segunda declaración:
(17) ¿Qué se generará si compila y ejecuta el siguiente código c?
int extern x;
vacío principal()
printf (“% d”, x);
x = 2;
getch ();
}
int x = 23;
(a) 0
(b) 2
(c) 23
(d) Error del compilador
(e) Ninguno de estos
Respuesta: (c)
Explicación:
Las variables externas pueden buscar la declaración de la variable en cualquier parte del programa.
(18) ¿Qué se generará si compila y ejecuta el siguiente código c?
vacío principal(){
int i = 0;
si (i == 0) {
i = ((5, (i = 3)), i = 1);
printf (“% d”, i);
}
más
printf (“igual”);
}
(a) 5
(b) 3
(c) 1
(d) igual
(e) Ninguno de los anteriores
Respuesta: (c)
Explicación:
(19) ¿Qué se generará si compila y ejecuta el siguiente código c?
vacío principal(){
int a = 25;
clrscr ();
printf (“% o% x”, a, a);
getch ();
}
(a) 25 25
(b) 025 0x25
(c) 12 42
(d) 31 19
(e) Ninguno de estos
Respuesta: (d)
Explicación:
% o se utiliza para imprimir el número en formato de número octal.
% x se usa para imprimir el número en formato de número hexadecimal.
Nota: en c, el número octal comienza con 0 y el número hexadecimal comienza con 0x.
(20) ¿Qué se generará si compila y ejecuta el siguiente código c?
#define message “union is \
poder de c ”
vacío principal(){
clrscr ();
printf (“% s”, mensaje);
getch ();
}
(a) la unión es poder de c
(b) poder de unión de c
(c) la unión es
Poder de c
(d) Error del compilador
(e) Ninguno de estos
Respuesta: (b)
Explicación:
Si desea escribir macro constante en una nueva línea, finalice con el carácter \.
(21) ¿Qué se generará si compila y ejecuta el siguiente código c?
#definir llamada (x) #x
vacío principal(){
printf (“% s”, llamada (c / c ++));
}
(C.A
(b) c ++
(c) # c / c ++
(d) c / c ++
(e) Error del compilador
Respuesta: (d)
Explicación:
# es operador de cadena. Convierte el argumento de llamada a la función macro en la cadena. Primero vea el archivo intermedio:
prueba.c 1:
test.c 2: void main () {
test.c 3: printf (“% s”, “c / c ++”);
prueba.c 4:}
prueba.c 5:
Está claro que la llamada de macro se reemplaza por su argumento en el formato de cadena.
(22) ¿Qué se generará si compila y ejecuta el siguiente código c?
vacío principal(){
if (printf (“cquestionbank”))
printf (“Sé c”);
más
printf (“Sé c ++”);
}
(a) Sé c
(b) Sé c ++
(c) cquestionbank Sé que c
(d) cquestionbank Sé c ++
(e) Error del compilador
Respuesta: (c)
Explicación:
El tipo de retorno de la función printf es un entero que devuelve el número de caracteres que imprime, incluidos los espacios en blanco. Por lo tanto, la función printf dentro de si la condición devolverá 13. En la condición if, cualquier número distinto de cero significa verdadero, por lo que la parte no se ejecutará.
Fuente: preguntas y respuestas de la entrevista de programación C