Quiero encontrar las preguntas y respuestas de la primera mitad del examen de informática de nivel 2 (lenguaje C) de la provincia de Jiangxi de 2011.
1. Pregunta correcta 1
La función del siguiente programa dado es: leer un número entero (2lt;=k《=10000》 e imprimir todos sus factores primos (es decir, Todos los factores son primos). Por ejemplo, si ingresa el número entero 2310, debería generar 2, 3, 5, 7, 11.
Corrija los errores en el programa para que pueda obtener el resultado. resultado correcto.
¡Tenga cuidado de no cambiar la función principal, agregar o eliminar líneas, ni cambiar la estructura del programa!
Programa de prueba:
#! incluir lt; conio.hgt;
#include lt;stdio.hgt;
********************* *** *******
IsPrime(int n); ——————Eliminar punto y coma
{int i, m
para ( i=2; ilt; n; i )
********************* *** *********
si !(ni) ————si (!(ni))
{ m=0;
retorno (m);
}
principal()
{ int j, k
clrscr ();
printf("nIngrese un número entero entre 2 y 10000: "); scanf("d", amp; k); factor(es) de d es(son): ",k);
for (j=2;jlt;=k;j)
if ((!(kj) ) amp;amp;(IsPrime(j)) printf("n 4d",j);
printf("n");
)
2, Pregunta de programación 1
m Las puntuaciones personales se almacenan en la matriz de puntuación. Escriba la función divertida. Su función es: utilizar el número de personas con puntuaciones inferiores al promedio como valor de la función y agrupar. el número de estudiantes con puntuaciones inferiores al promedio. La puntuación se coloca en la matriz que se indica a continuación.
Por ejemplo, cuando los datos en la matriz de puntuación son 10, 20, 30, 40, 50, 60, 70, 80, 90, el número de personas devueltas por la función debe ser 4. Los datos a continuación deben ser 10, 20, 30, 40.
Nota: Parte del programa fuente se proporciona a continuación.
No cambies nada en la función principal ni en otras funciones. Solo completa las llaves de la función divertida con algunas declaraciones que hayas escrito.
Programa de preguntas del examen:
#include lt;conio.hgt;
#include lt;stdio.hgt;
#include lt ;string.hgt;
int fun (int puntuación[], int m, int debajo[])
{
————int i , k=0; float aver=0;
for (i=0; ilt; m; i )
aver = (score[i]); p>promedio/=m;
for (i=0;ilt;m;i)
if (score[i]lt;promedio)
{abajo[k]=puntuación[i];
k
retern(k);}
}
principal ( )
{int i, n, debajo[9];
int puntuación [9]={10, 20, 30, 40, 50, 60, 70, 80, 90 };
clrscr();
n=fun(puntuación, 9, debajo);
printf("nDebajo de la puntuación promedio están: ");
for (i=0; ilt; n; i) printf ("d", debajo[i]);
}
3. 2
En el siguiente programa dado, la función de la función fun es: comparar los caracteres en las posiciones correspondientes de las dos cadenas a y b uno por uno, y almacenar los caracteres con un valor ASCII mayor o igual en la matriz c a la vez, formando una nueva cadena. Por ejemplo, si la cadena en a es aBCDeFgH y la cadena en b es: ABcd, entonces la cadena en c es: aBcdeFgh.
Corrija los errores en el programa para que pueda producir resultados correctos.
¡Tenga cuidado de no cambiar la función principal, agregar o eliminar líneas, ni cambiar la estructura del programa!
Programa de prueba
#include lt; studio.hgt
#include lt; ***********************************
void fun(char *p , char *q, char *c)——Eliminar punto y coma
****************************** ****** **********
{int k=1;——1 se cambia a 0
******* ******* *************************
mientras(*p!=*q) —— != cambiado a ||
*************************************** *****
{if (*plt; *q) c[k]=*q; ——Cambie el signo menor que a menor o igual
else c [k]=*p;
si (*p) p ；
si (*q) q ；
k ；
}
}
main()
{char a[10]="aBCDeFgh", b[10]="ABcd", c[80 ]={''};
fun(a, b, c);
printf("La cadena a: "); p> printf("La cadena b: "); pone (b);
printf("El resultado: ");
4. Corrección 3
En el siguiente programa, la función de la función divertida es eliminar todos los caracteres numéricos de la cadena en secuencia, formar una nueva cadena y reemplazar la cadena original.
Corrija los errores en el programa para que pueda producir resultados correctos.
¡Tenga cuidado de no cambiar la función principal, agregar o eliminar líneas, ni cambiar la estructura del programa!
Programa de prueba
#include lt; stdio.hgt;
#include lt; *s)
{ int i, j;
for (i=0, j=0; s[i]!='\0'; i )
******************************************
if (s[i]gt;='0' amp; amp; s[i]lt;='9')
s[j]=s[i] —————— j cambió a j++
*************************************** ***
s[j]="\0" ——————s[j]='\0'
}
main()
{char item[80];
clrscr();
printf("\nIngrese una cadena: "); ;
p>
printf("\n\nLa cadena es:\s\n", elemento
divertido (elemento); > printf("\n\nLa cadena de cambio es:\s\n", item);
}
Corrección 4
En el Siguiendo el programa dado, la función fun La función es: distinguir el número de letras mayúsculas y minúsculas en la cadena de bronce. Por ejemplo, si ingresa la cadena s: AAaaBBb123CCccccd, el resultado debería ser: superior=6, inferior=8.
Corrija los errores en el programa para que pueda producir resultados correctos.
¡Tenga cuidado de no cambiar la función principal, agregar o eliminar líneas, ni cambiar la estructura del programa!
Programa de prueba
#include lt;conio.hgt;
#include lt;stdio.hgt;
**** *****************************
diversión vacía (char *s, int a, int b) ————a debería ser *a, b debería ser *b
{ while(*s)
{ if (*sgt;='A' amp; amp; * slt;='Z')
************************************ ******
a; ————(*a);
if (*sgt;='a' amp; amp; *slt;='z ')
************************************
b; ——— —(*b) ;
s ;
}
}
principal()
{ char s[100]; int superior=0, inferior=0;
clrscr();
printf("nPor favor, una cadena: "); (s);
fun(s, amp; superior, amp; inferior);
printf("n superior=d inferior=dn", superior, inferior
}
6. Corrección 5
Supongamos que los números en la secuencia entera no se repiten y se almacenan en la matriz. En el programa que se proporciona a continuación, la función de la función fun es eliminar el elemento con valor x en la matriz. Almacenado en n está el número de elementos de la matriz.
Corrija los errores en el programa para que pueda producir resultados correctos.
¡Tenga cuidado de no cambiar la función principal, agregar o eliminar líneas, ni cambiar la estructura del programa!
Programa de prueba
#include lt; stdio.hgt
#define N 20
fun (int *a, int n , int x)
{int p=0, i;
a[n]=x
mientras (x!=a[p])
p=p 1;
si (p==n) devuelve -1
else
{para (i=) p；ilt；n；i )
************************************ ******* *******
a[i 1]=a[i]; ————a[i]=a[i 1]; >
devolver n- 1;
}
}
main()
{int w[N]={ -3, 0, 1, 5, 7, 99, 10, 15, 30, 90}, x, n, i;
n=10; datos originales: n");
for (i=0;ilt;n;i) printf("5d",w[i]);
printf("nInput x (para eliminar):") ; scanf("d", & x);
printf("Eliminar: dn", x);
n=fun(w, n , x);
p>
if (n==-1) printf("***¡No se encontrará!***nn"); /p>
{printf("Los datos después de eliminar: n");
for (i=0, ilt; n; i) printf ("5d", w[i]); printf ("nn");
}
}
7. Corrección 6
En el siguiente programa, la función de La función divertida es: de acuerdo con el parámetro formal entero m Valor, calcule el valor de la siguiente fórmula. t=1-1/2×2-1/3×3-…-1/m×m
Por ejemplo, si el valor en m es 5, debería generarse: 0,536389.
Corrija los errores en el programa para que pueda producir resultados correctos.
¡Tenga cuidado de no cambiar la función principal, agregar o eliminar líneas, ni cambiar la estructura del programa!
Programa de prueba:
#include lt;conio.hgt;
#include lt;stdio.hgt;
doble diversión ( int m)
{ doble y=1.0;
int i
***************** ***** *************************
para (i=2; ilt; m; i) —— —— Cambie “lt;” por "lt;="
****************************** ************ **
y-=1/(i*i); ————“1” se cambia a “1.0”
return(y);
}
main ()
{int n=5;
clrscr();
printf("\nEl resultado es 1f\n", fun(n));
}
Corrección 7
En el siguiente programa, la función de la función divertida es: Utilice el método de selección para ordenar los n elementos en la matriz de pequeños a grandes.
Corrija los errores en el programa para que pueda producir resultados correctos.
¡Tenga cuidado de no cambiar la función principal, agregar o eliminar líneas, ni cambiar la estructura del programa!
Programa de prueba:
#include lt; stdio.hgt
#define N 20
void fun(int a[] , int n)
{ int i, j, t, p;
para (j=0; jlt; n-1; j )
* ***************************
{p=j——Agregar ";"
for (i=j;i,n;i)——j se cambia a j 1
if (a[i]lt;a[p])
* ** ****************************
p=j;—j se cambia a i
t=a[p]; a[p]=a[j]; a[j]=t
}
}
main()
{
int a[N]={9, 6, 8, 3, -1}, i, m=5; p >printf("Datos antes de ordenar: ");
for (i=0; ilt; m; i) printf("d", a[i]); ;
fun(a, m);
printf("Datos ordenados: ");
for (i=0; ilt; m; i) printf("d", a[i]); printf("\n");
}
9 Corrección de error 8 (2004.7.27)
<. p> En el siguiente programa dado, la función de la función divertida es: encontrar el carácter con el valor de código ASCII más grande en la cadena str y colocarlo en la primera posición y mover el carácter original antes del carácter hacia atrás. Por ejemplo, antes de llamar a la función divertida, ingrese la cadena: ABCDeFGH y el contenido de la cadena después de la llamada es eABCDFGH.Corrija los errores en el programa para que pueda producir resultados correctos.
¡Tenga cuidado de no cambiar la función principal, agregar o eliminar líneas, ni cambiar la estructura del programa!
Programa de prueba:
#include lt; stdio.hgt
fun(char *p)
{ char max, * q; int i=0;
max=p[i];
mientras(p[i]!=0)
{ if(maxlt; p[i])
{max=p[i];
************************ ******* ********
p=q i; ——Cambiar a q=p i;
}
i ;
}
******************************
while(qlt; p) ——qlt; p cambió a qgt;
{*q=*(q-1);
q--;
}
p[0]=max;
}
main()
{char str[80 ];
printf("Ingrese una cadena: "); get(Str);
printf("\nLa cadena original: "); >
fun(str );
printf("\nLa cadena se mueve: "); puts (ptintf("\n\n"); }
10. Corrección 9 (2004.7.27)
En el siguiente programa, la función de diversión es contar el número de estudiantes cuyas puntuaciones están por debajo del promedio de la puntuaciones de n estudiantes Este número viene dado por Se devuelve el valor de la función y la puntuación promedio se almacena en la unidad de almacenamiento señalada por el parámetro formal aver. Por ejemplo, si ingresa las puntuaciones de 8 estudiantes:
80,5 60 72 90,5 98 51,5 88 64
El número de estudiantes con puntuaciones inferiores al promedio es 4 (puntuación promedio: 75,5625 ).
Corrija los errores en el programa para que pueda producir resultados correctos.
¡Tenga cuidado de no cambiar la función principal, agregar o eliminar líneas, ni cambiar la estructura del programa!
Programa de preguntas de prueba:
#include lt;conio.hgt;
#include lt;stdio.hgt;
#define N 20
int fun (float *s, int n, float *aver)
{float ave, t=0.0
int count=0, k , i;
para (k=0; klt; n; k )
******************** **** **********
t=s[k]; ——t =s[k];
ave=t/n;
for (i=0; ilt; n; i)
if (s[i]lt; ave) contar;
***** ***** **********************
*aver=amp;ave;——Quitar amp;
recuento de retornos
}
main()
{float s[30], aver
int m, i ;
clrscr();
printf("nPor favor ingrese m:"; scanf("d",amp;m);
printf("nPor favor ingrese d marca: n ", m);
for (i=0; ilt; m; i) scanf("f", s i);
printf("nEl número de estudiantes: dn" , fun(s, m, amp; aver));
printf("Ave=fn", aver);
)
11. Corrección 10 (2004.8.1)
En el siguiente programa dado, la función de la función fun es reemplazar todas las subcadenas apuntadas por t1 que aparecen en la cadena apuntada por s con la subcadena apuntada. por t2, entonces La nueva cadena formada se coloca en la matriz señalada por w. Aquí, se requiere que las longitudes de las cadenas a las que apuntan t1 y t2 sean las mismas. Por ejemplo, cuando el contenido del carácter señalado por s es abcdabfab, el contenido de la subcadena señalada por t1 es ab y el contenido de la subcadena señalada por t2 es 99, el resultado es el señalado por 2
El contenido de la matriz debe ser 99cd99f99.
Corrija los errores en el programa para que pueda producir resultados correctos.
¡Tenga cuidado de no cambiar la función principal, agregar o eliminar líneas, ni cambiar la estructura del programa!
Programa de prueba:
#includelt;conio.hgt;
#includelt;stdio.hgt;
#includelt;string. hgt;
int divertido (char *s, char *t1, char*t2, char*w)
{
int i; *r, *a;
strcpy(w, s);
while(*w)
{p=w; p>
p>
****************************************** ********
while(r) ——r se cambia a *r
if(*r==*p) {r;p}
else romper;
p>if(*r=='')
{a=w; *************** ****************************
while(*r){*a=*r;a ; r } ——Cambiar a while(*r){*a=*r; a r ;}
w =strlen(t2) ;
}
más w ;
}
}
principal()
{
char s[ 100], t1[100], t2[100], w[100];
clrscr();
printf ("nIngrese la cadena S: "); scanf(" s", s);
printf ("nIngrese la cadena t1: ");
printf ("nPor favor ingrese la cadena t2: ") ;scanf("s",t2);
if (strlen(t1)==strlen(t2))
{
printf("nEl resultado es: sn", w);
}
else printf("Error: strlen(t1)!=strlen( t2)n");
}
12. Corrección 11 (2004.8.1)
En el programa dado MODI1.C, la función de la diversión La función es: primero ingrese una matriz de 3 filas y 3 columnas desde el teclado. El valor de cada elemento de y luego genere el producto de los elementos diagonales principales.
Por favor, corrija los errores en el programa, o complete el contenido apropiado y elimine las líneas horizontales para que pueda producir resultados correctos.
Nota: ¡No cambie la función principal, no agregue ni elimine líneas y no cambie la estructura del programa!
Programa de prueba:
#include lt; stdio.hgt
int fun ()
{
int i, j;
********************* *** ****************
_____; ——suma = 1;
for (i=0; ilt; 3 ; i)
{ para (j=0;jlt;3;j)
******************** ********** *******************
scanf (〃d〃 a [i] [j]); —scanf("d", amp; a [i][j]);
}
for (i=0; ilt; 3; i)
suma=suma*a[i] [i];
printf (〃Suma=dn〃, suma
}
principal ()
{ fun ( ); }
13. Corrección 12 (8.1)
La función del siguiente programa es: leer un número entero k (2≤k). ≤10000) e imprime todos sus factores primos (es decir, todos los factores que son primos). Por ejemplo, si ingresa un número entero: 2310, debería generar: 2, 3, 5, 7, 11.
Corrija los errores gramaticales en el programa para que pueda producir resultados correctos.
Nota: ¡No cambie la función principal, no agregue ni elimine líneas y no cambie la estructura del programa!
Programa de prueba:
#include 〃conio.h〃
#include 〃stdio.h〃
***** *******************************************
EsPrime (int n); ——EsPrime(int n)
{ int i, m
m = 1
para (i = 2; i lt; n/ i )
************************************ *********
si !(ni) ——if(!(ni))
{ m=0 }
return ( m );
}
main ()
{ int j, k;
clrscr ();
printf (〃nPor favor ingrese un número entero entre 2 y 10000:〃); scanf (〃d〃,amp;k);
printf (〃nn Los factores primos) de d es ( are )：〃, k
for ( j = 2; j lt; = k; j )
if ( ( ! kj ) ) amp; ; ( IsPrime ( j ) ) } printf (〃n 4d〃, j );
printf (〃n〃);
}
14. Incorrecto 13 (8.4)
En el siguiente programa, la función de la función divertida es calcular el valor de la siguiente fórmula en función del parámetro formal m.
t=1 1/2 1/3 1/4 … 1/m
Por ejemplo, si ingresa 5, se debe generar 2.283333.
Corrija los errores gramaticales en el programa para que pueda producir resultados correctos.
Nota: ¡No cambie la función principal, no agregue ni elimine líneas y no cambie la estructura del programa!
Programa de prueba:
#includelt;conio.hgt;
#includelt;stdio.hgt;
doble diversión(int m )
{
double t=1.0;
int i
for(i=2; ilt; =m; i )
****************************************** *
t =1.0/k; ——k se cambia a i
********************** ******** **********************
____________ ——Completar retorno t;
}
main()
{
int m;
clrscr();
printf(“nPor favor ingrese 1 número entero: ”);
scanf(“d”, amp; m);
printf(“nEl resultado es 1fn”, fun(m) );
}
15. Corrección 14 (8.4)
En el siguiente programa, las funciones de las funciones fun y funx son:
Utilice el método de bisección para encontrar la ecuación 2x×x ×x-4x×x+3x-6=una raíz de 0, y se requiere que el error absoluto no exceda 0,001. Por ejemplo, si ingresa -100 para my 90 para n, la función encontrará una raíz de 2.000.
Corrija los errores gramaticales en el programa para que pueda producir resultados correctos.
Nota: ¡No cambie la función principal, no agregue ni elimine líneas y no cambie la estructura del programa!
Programa de prueba:
#includelt; stdio.hgt;
#includelt; )
{
return(2*x*x*x-4*x*x 3*x-6);
}
doble diversión(doble m, doble n)
{
************************ ***** ***************
int r;——cambiado a doble r;
r=(m n)/ 2;
************************************
while(fabs(n-m )lt; 0.001) —— "lt;" se cambia a " gt; = "
{if(funx(r)*funx(n)lt; 0 m= r;
else n=r
r=(m n)/2
)
devolver r; >
)
main()
{
doble m, n, raíz
printf("Ingrese m n: n"); scanf("1f1f ",amp;m,amp;n);
root=fun(m,n);
printf("root=6.3fn" ,root);
}
16. Corrección 15 (8.5)
En el siguiente programa dado, la función de la función fun es determinar si el El carácter ch coincide con una determinada cadena en la cadena señalada por los caracteres str son iguales; si son iguales, no haga nada si son diferentes, inserte el dispositivo al final de la cadena.
Corrija los errores en el programa para que pueda producir resultados correctos.
¡Tenga cuidado de no cambiar la función principal, agregar o eliminar líneas, ni cambiar la estructura del programa!
Programa de prueba
#include lt;conio.hgt;
#include lt;stdio.hgt;
#include lt; cadena.hgt;
************************************
void fun(char str, char ch)-----------------------1
{ while(*str amplificador; *cadena!=ch) cadena;
********************************* ***** *
if (*str==ch)----------------------- ----- --2
{ str[0]=ch;
********************* ********** ********
str[1]='0';---------------- ---------- ----------3
}
}
principal()
{char s[81] , c;
clrscr();
printf("nPor favor, introduzca una cadena: n"); >
printf("nIngrese el carácter a buscar: ");
c=getchar()
fun(s, c) > printf("nEl resultado es sn", s);
}
Respuesta a la pregunta 15:
1. ch)
2. if (*str=='
17, Corrección 16(8.5)
En el siguiente programa dado, la función de la función Creatlink consiste en crear una lista de un solo enlace de nodos principales y asignar valores de 0 a m-1 a cada campo de datos de nodo.
Corrija los errores en el programa para que el programa pueda producir. resultados correctos.
¡Tenga cuidado de no cambiar la función principal, agregar o eliminar líneas, ni cambiar la estructura del programa!
Programa de prueba
#include lt;conio.hgt;
#include lt;stdio.hgt;
#include lt; stdlib.hgt;
typedef struct aa
{ int data;
struct aa *next;
}NODE;
NODE *Creatlink(int n, int m)
{NODE *h=Null, *p, *s;
int i;
s=(NODO *)malloc(tamañode(NODO));
****************************** ** ****************
h=p; ---------------1
p-gt; siguiente=NULL
para (i=1; ilt; =n ; i )
{s=(NODO *)malloc(tamañode(NODO));
****************** **** ***********************
s-gt; datos=rand()m;----- ---- ---------------2
s-gt; siguiente=p-gt;
p-gt; siguiente=s;
p=p-gt; siguiente
}
**************** ******** *************************
volver p；------- ---------- ---------------3
}
enlace externo(NODO *h)
{NODO *p;
p=h-gt; siguiente
printf("nnLA LISTA: nn CABEZA"); (p)
{printf("-gt;d",p-gt;data);
p=p-gt;siguiente;
}
printf(" n");
}
principal()
{ NODO *cabeza
head=Creatlink(8,22);
outlink(head);
}
16 Pregunta Respuesta:
1 . h=p=s;
2. return h;
18. Corrección 17 (8.5)
En el siguiente programa dado, la función de la función fun es calcular y generar la suma de los 10 números naturales más grandes dentro de k que son divisibles por 13 o 17. El valor de k se pasa desde la función principal. Si el valor de k es 500, el valor de la función es 4622.
Corrija los errores en el programa para que pueda producir resultados correctos.
¡Tenga cuidado de no cambiar la función principal, agregar o eliminar líneas, ni cambiar la estructura del programa!
Programa de prueba
#include lt;conio.hgt;
#include lt;stdio.hgt;
int fun(int k)
{int m=0, mc=0, j;
mientras ((kgt;=2)amp;amp;(mclt;10))
************************************
{si (( k13=0 )||(k17=0))------------------1
{m=m mc;}
k--;
}
devolver m
***************** ******* *******************
_____________----------------- ------------ ---2
main()
{clrscr();
printf("dn" , fun(500));
}
Respuesta a la pregunta 17:
1 if ((k13==0)||(k17== 0))
2. }
19. Corrección 18 (8.5)
En el siguiente programa, la función fun es realizar el intercambio. de dos números enteros. Por ejemplo, si ingresa 60 y 65 para a y b respectivamente, el resultado es: a=65 b=60
Corrija los errores en el programa para que pueda producir resultados correctos.
¡Tenga cuidado de no cambiar la función principal, agregar o eliminar líneas, ni cambiar la estructura del programa!
Programa de prueba
#include lt;conio.hgt;
#include lt;stdio.hgt;
**** ******************************
Diversión vacía (int a, b)----- -- ------------------1
{int t;
********** * *******************
t=b=a=t ---------- - -----------------2
}
principal()
{int a, b ;
clrscr();
printf("Ingrese a, b: "); scanf("dd", amp; a, amp; b
); fun(amp; a, amp; b);
printf("a=d b=dn", a, b
}
Respuesta a pregunta 18:
1. diversión vacía (int *a, int *b)
2. p>
20. Corrección 19 (8.5)
En el siguiente programa, la función de la función divertida es: comenzando desde el bit bajo, saca el número en el dígito par del entero largo. variable s, una vez Construye un nuevo número y colócalo en t. Por ejemplo, cuando el número en s es 7654321, el número en t es 642.
Corrija los errores en el programa para que pueda producir resultados correctos.
¡Tenga cuidado de no cambiar la función principal, agregar o eliminar líneas, ni cambiar la estructura del programa!
Programa de prueba
#include lt;conio.hgt;
#include lt;stdio.hgt;
**** *****************************
diversión vacía (s larga, t larga)---- ----------------------1
{long sl=10;
s/=10;
*t=s10;
******************************
mientras (slt; 0)---------------------------------------- ------2
{s=s/100
*t=s10*sl *t
sl=sl*10;
}
}
main()
{long s, t
clrscr();
printf("nPor favor ingrese s: "); scanf ("ld", amp; s
fun (s, amp; t); > printf ("El resultado es: ldn", t );
}
Respuesta a la pregunta 19:
1. *t)
2. while (sgt; 0)
21. Corrección 20 (8.5)
Se han colocado N matrices de enteros ordenados en una pila de matrices En el siguiente programa, la función fun La función es: use el algoritmo de búsqueda binaria para encontrar la posición del número entero m en la matriz. Si se encuentra, se devuelve su valor de subíndice; de lo contrario, se devuelve -1.
El algoritmo básico de la media búsqueda es: antes de cada búsqueda, determine el rango a buscar en la matriz: bajo y alto (lowlt; alto), y luego compare m con el valor del elemento en el posición media (mid) Comparar. Si el valor de m es mayor que el valor en el elemento de la posición media, el siguiente rango de búsqueda se coloca en el elemento después de la posición media; de lo contrario, el siguiente rango de búsqueda cae en el elemento anterior a la posición media; Hasta lowgt;high, la búsqueda finaliza.
Corrija los errores en el programa para que pueda producir resultados correctos.
¡Tenga cuidado de no cambiar la función principal, agregar o eliminar líneas, ni cambiar la estructura del programa!
Programa de preguntas del examen
#include lt;stdio.hgt;
#define N 10
******* * *****************************
diversión vacía(int a[], int m)- --- -----------------------1
{int bajo=0, alto=N-1, medio;
while(lowlt;=alto)
{mid=(bajo alto)/2;
if (mlt; a[mid])
alto= medio-1;
************************************ *******
si no (mgt;=a[mid])------------------------- ---2
bajo=medio 1
else return(mid
}
return(-1);
}
main()
{int i, a[N]={-3, 4, 7, 9, 13, 45, 67, 89, 100, 180}, k, m;
printf("Los datos en la matriz a son los siguientes:");
for(i=0; ilt; N ; i) printf("d", a [i]);
printf("Ingrese m:"); =divertido(a,m);
p>if(kgt;=0) printf("m=d,index=d\n",m,k);
else printf("¡No se encuentra!\n") ;
}
Respuesta a la pregunta 20:
1. int m)
2. else if (mgt; a[mid])
Sí, ¿es así? Si es así, dame la mejor respuesta.