Urgente~ Con respecto al diseño del curso de lenguaje C, se utilizan asteriscos para formar letras A~Z en la salida~~~. ! !

/* Pregunta 1*/

#include

#include

# define SCREEN_COLS 80 /* cuantas columnas tiene el terminal */

#define HORIZONTAL_DISTANCE 4 /* distancia horizontal entre dos caracteres (distancia de columnas) */

#define VERTICAL_DISTANCE 1 /* vertical distancia entre dos filas de caracteres (interlineado) */

#define BRUSH_CHAR ('*')

#define BLANK_CHAR (' ')

/* La altura y el ancho de la fuente en la fuente ASCII_TAB */

#define FONT_ROWS 7

#define FONT_COLS 5

/* El número máximo de caracteres que se puede mostrar en cada línea de la pantalla Número*/

#define CHAR_PER_LINE (SCREEN_COLS/(FONT_COLS + HORIZONTAL_DISTANCE))

// ASCII_TAB[] contiene todos los caracteres ASCII de sp ( 32) a z (122)

static const unsigned char ASCII_TAB[][5]= //5*7

{

{ 0x00, 0x00, 0x00, 0x00, 0x00 }, // sp

{ 0x00, 0x00, 0x2f, 0x00, 0x00 }, // !

{ 0x00, 0x07, 0x00, 0x07, 0x00 } , // "

{ 0x14, 0x7f, 0x14, 0x7f, 0x14 }, // #

{ 0x24, 0x2a, 0x7f, 0x2a, 0x12 }, // $

{ 0xc4, 0xc8 , 0x10, 0x26, 0x46 }, // %

{ 0x36, 0x49, 0x55, 0x22, 0x50 }, // &

{ 0x00, 0x05, 0x03, 0x00, 0x00 }, // '

{ 0x00, 0x1c, 0x22, 0x41, 0x00 }, // (

{ 0x00, 0x41, 0x22, 0x1c, 0x00 }, // )

{ 0x14, 0x08, 0x3E, 0x08, 0x14 }, // *

{ 0x08, 0x08, 0x3E, 0x08, 0x08 }, / / +

{ 0x00, 0x00, 0x50, 0x3

0, 0x00 }, // ,

{ 0x10, 0x10, 0x10, 0x10, 0x10 }, // -

{ 0x00, 0x60, 0x60, 0x00, 0x00 }, / / .

{ 0x20, 0x10, 0x08, 0x04, 0x02 }, // /

{ 0x3E, 0x51, 0x49, 0x45, 0x3E }, // 0

{ 0x00, 0x42, 0x7F, 0x40, 0x00 }, // 1

{ 0x42, 0x61, 0x51, 0x49, 0x46 }, // 2

{ 0x21, 0x41, 0x45, 0x4B, 0x31 }, // 3

{ 0x18, 0x14, 0x12, 0x7F, 0x10 }, // 4

{ 0x27, 0x45, 0x45, 0x45, 0x39 }, // 5

{ 0x3C, 0x4A, 0x49, 0x49, 0x30 }, // 6

{ 0x01, 0x71, 0x09, 0x05, 0x03 }, // 7

{ 0x36, 0x49, 0x49, 0x49, 0x36 }, // 8

{ 0x06, 0x49, 0x49, 0x29, 0x1E }, // 9

{ 0x00, 0x36, 0x36, 0x00, 0x00 }, // :

{ 0x00, 0x56, 0x36, 0x00, 0x00 }, // ;

{ 0x08, 0x14, 0x22, 0x41, 0x00 }, // <

{ 0x14, 0x14, 0x14, 0x14, 0x14 }, // =

{ 0x00, 0x41, 0x22, 0x14, 0x08 } , // >

{ 0x02, 0x01, 0x51, 0x09, 0x06 }, // ?

{ 0x32, 0x49, 0x59, 0x51, 0x3E }, // @

{ 0x7E, 0x11, 0x11, 0x11, 0x7E }, // A

{ 0x7F, 0x49, 0x49, 0x49, 0x36 }, // B

{ 0x3E, 0x41, 0x41, 0x41, 0x22 }, // C

{ 0x7F, 0x41, 0x41, 0x22, 0x1C }, // D

{ 0x7F, 0x49, 0x49, 0x49, 0x41 }, // E

{ 0x7F, 0x09, 0x09, 0x09, 0x01 }, // F

{ 0x3E, 0x41, 0x49, 0x49, 0x7A }, / / G

{ 0x7F, 0x08, 0x08, 0x08, 0x7F }, // H

{ 0x00, 0x41, 0x7F, 0x41, 0x00 }, //

I

{ 0x20, 0x40, 0x41, 0x3F, 0x01 }, // J

{ 0x7F, 0x08, 0x14, 0x22, 0x41 }, // K

{ 0x7F, 0x40, 0x40, 0x40, 0x40 }, // L

{ 0x7F, 0x02, 0x0C, 0x02, 0x7F }, // M

{ 0x7F, 0x04 , 0x08, 0x10, 0x7F }, // N

{ 0x3E, 0x41, 0x41, 0x41, 0x3E }, // O

{ 0x7F, 0x09, 0x09, 0x09, 0x06 }, // P

{ 0x3E, 0x41, 0x51, 0x21, 0x5E }, // Q

{ 0x7F, 0x09, 0x19, 0x29, 0x46 }, // R

{ 0x46, 0x49, 0x49, 0x49, 0x31 }, // S

{ 0x01, 0x01, 0x7F, 0x01, 0x01 }, // T

{ 0x3F, 0x40, 0x40, 0x40, 0x3F }, // U

{ 0x1F, 0x20, 0x40, 0x20, 0x1F }, // V

{ 0x3F, 0x40, 0x38 , 0x40, 0x3F }, // W

{ 0x63, 0x14, 0x08, 0x14, 0x63 }, // X

{ 0x07, 0x08, 0x70, 0x08, 0x07 }, // Y

{ 0x61, 0x51, 0x49, 0x45, 0x43 }, // Z

{ 0x00, 0x7F, 0x41, 0x41, 0x00 }, // [

{ 0x55, 0x2A, 0x55, 0x2A, 0x55 }, // '\'

{ 0x00, 0x41, 0x41, 0x7F, 0x00 }, // ]

{ 0x04, 0x02, 0x01, 0x02, 0x04 }, // ^

{ 0x40, 0x40, 0x40, 0x40, 0x40 }, // _

{ 0x00, 0x01, 0x02 , 0x04, 0x00 }, // '

{ 0x20, 0x54, 0x54, 0x54, 0x78 }, // a

{ 0x7F, 0x48, 0x44, 0x44, 0x38 }, // b

{ 0x38, 0x44, 0x44, 0x44, 0x20 }, // c

{ 0x38, 0x44, 0x44, 0x48, 0x7F }, // d

{ 0x38, 0x54, 0x54, 0x54, 0x18 }, // e

{ 0x08, 0x7E, 0x09, 0x01, 0x02 }, // f

{ 0x0C

, 0x52, 0x52, 0x52, 0x3E }, // g

{ 0x7F, 0x08, 0x04, 0x04, 0x78 }, // h

{ 0x00, 0x44, 0x7D, 0x40 , 0x00 }, // i

{ 0x20, 0x40, 0x44, 0x3D, 0x00 }, // j

{ 0x7F, 0x10, 0x28, 0x44, 0x00 }, // k

{ 0x00, 0x41, 0x7F, 0x40, 0x00 }, // l

{ 0x7C, 0x04, 0x18, 0x04, 0x78 }, // m

{ 0x7C, 0x08, 0x04, 0x04, 0x78 }, // n

{ 0x38, 0x44, 0x44, 0x44, 0x38 }, // o

{ 0x7C, 0x14 , 0x14, 0x14, 0x08 }, // p

{ 0x08, 0x14, 0x14, 0x18, 0x7C }, // q

{ 0x7C, 0x08, 0x04, 0x04, 0x08 }, // r

{ 0x48, 0x54, 0x54, 0x54, 0x20 }, // s

{ 0x04, 0x3F, 0x44, 0x40, 0x20 }, // t

{ 0x3C, 0x40, 0x40, 0x20, 0x7C }, // u

{ 0x1C, 0x20, 0x40, 0x20, 0x1C }, // v

{ 0x3C, 0x40, 0x30, 0x40, 0x3C }, // w

{ 0x44, 0x28, 0x10, 0x28, 0x44 }, // x

{ 0x0C, 0x50, 0x50 , 0x50, 0x3C }, // y

{ 0x44, 0x64, 0x54, 0x4C, 0x44 } // z

};

static char get_char_xy( char ch, int x, int y)

{

if (ch < ' ' || ch > 'z')

ch = ' ';

ch -= ' ';

retorno (ASCII_TAB[ch][x] & (1<

}

static void print_row(char ch, int fila)

{

int i;

for (i = 0; i < FONT_COLS; i++) {

printf("%c", get_char_xy(ch, i, fila));

}

}

int main(int argc, char *argv[])

{

c

har str[80] = { '\0' };

int i, j, k, len, index = 0;

printf("Ingrese una cadena:\n ");

scanf("%s", str);

len = strlen(str);

while (index < len) { p>

para (i = 0; i < FONT_ROWS; i++) {

para (j = 0; j < CHAR_PER_LINE && j + índice < len; j++) {

print_row(cadena[índice + j], i);

for (k = 0; k < DISTANCIA_HORIZONTAL; k++) {

printf("%c", BLANK_CHAR

}

}

printf("\n");

}

índice + = CHAR_PER_LINE ;

for (k = 0; k < DISTANCIA_VERTICAL; k++) {

printf("\n");

}

}

return 0;

}

/* Pregunta 2*/

#include < / p>

#include

#include

#include

#define MIN_POINT_NUMBER 3

#define MAX_POINT_NUMBER 100

#define MAX_POINT_COORD 1000.0

typedef struct Point_ {

float x;

float y;

} Punto;

typedef struct Circle_ {

Punto o /* centro */

Punto p1 ;

Punto p2;

float r; /* radio */

} Círculo;

typedef struct {

Punto p;

int incluido;

} Elemento;

/* devuelve la distancia al cuadrado de los puntos a y b */

#define CUADRADO(a) ((a)*(a))

#de

bien DISTANCIA_CUADRADA(a,b) (CUADRADO((a).x-(b).x) + CUADRADO((a).y-(b).y))

#define DISTANCIA(a ,b) (sqrt(DISTANCIA_CUADRADA((a),(b))))

#define MAX(a,b) ((a) > (b) ? (a): (b))

#define MIN(a,b) ((a) < (b)? (a): (b))

#define EQUAL_FLOAT(a,b) (fabs( (a)-(b)) < 0.00001)

/* obtener el círculo circunstante de un triángulo */

Círculo estático

get_circumcircle(Punto a, Punto b, Punto c)

{

Resultado del círculo;

float dx1 = a.x - b.x;

float dx2 = b.x - c.x ;

float dy1 = a.y - b.y;

float dy2 = b.y - c.y;

float x1 = (a.x + b.x) / 2.0;

flotador x2 = (b.x + c.x) / 2.0;

flotador y1 = (a.y + b.y) / 2.0;

flotador y2 = (b.y + c.y) / 2.0 ;

resultado.o.x = ((dy1*dy2*(y2-y1) + x2*dx2*dy1 - x1*dx1*dy2)) / \

(dx2*dy1 - dx1*dy2);

resultado.o.y = ((dx1*dx2*(x2-x1) + y2*dy2*dx1 - y1*dy1*dx2)) / \

(dy2*dx1 - dy1*dx2);

resultado.r = DISTANCIA(resultado.o, a);

resultado.p1 = a;

result.p2 = c;

devuelve resultado;

}

/* obtiene el círculo mínimo que incluye tres puntos dados

* Nota:

* 1) los puntos del árbol pueden estar en una línea

* o

* 2) los puntos del árbol forman un triángulo

*/

Círculo estático

get_min_circle(Punto a, Punto b, Punto c)

{

Resultado del círculo ;

flotador ab,bc,ac, máx.

;

ab = DISTANCIA(a,b);

bc = DISTANCIA(b,c);

ac = DISTANCIA(a,c);

max = MAX(ab, MAX(bc,ac));

printf("[%f, %f]\n[%f, %f]\n[% f, %f]\n",a.x,a.y,b.x,b.y,c.x,c.y);

if (EQUAL_FLOAT(max*2, ab+bc+ac)) { /* en el mismo line */

printf("line\n");

if (EQUAL_FLOAT(max, ab)) {

/* ab es el diámetro * /

resultado.o.x = (a.x + b.x) / 2.0;

resultado.o.y = (a.y + b.y) / 2.0;

resultado.r = max / 2.0;

resultado.p1 = a;

resultado.p2 = b;

} else if (EQUAL_FLOAT(max, bc)) {

/* bc es el diámetro */

resultado.o.x = (b.x + c.x) / 2.0;

resultado.o.y = (b.y + c.y) / 2.0;

resultado.r = max / 2.0;

resultado.p1 = b;

resultado.p2 = c;

} else {

/* ac es el diámetro */

result.o.x = (a.x + c.x) / 2.0;

result.o.y = (a.y + c.y) / 2.0;

resultado.r = max / 2.0;

resultado.p1 = a;

resultado.p2 = c;

}

} else { /* triángulo */

/* obtiene el círculo circunstante del triángulo */

printf("triangle\n ");

resultado = get_circumcircle(a, b, c);

}

printf("El centro del círculo es [%f, %f] , el radio es %f\n",

result.o.x, result.o.y, result.r);

r

eturn resultado;

}

int

main(int argc, char *argv[])

{

Círculo círculo;

Elemento *elementos;

int n = 0, i;

while (n < MIN_POINT_NUMBER || n > MAX_POINT_NUMBER) {

printf("Ingrese el número de punto (3-100):\n");

scanf("%d", &n);

}

elementos = (Elemento*)malloc(tamañode(Elemento)*n);

memset(elementos, 0, tamaño de(Elemento)*n);

for (i = 0; i < n; i++) {

printf("Ingrese el punto (%d en %d):\n", i+1, n);

scanf("%f %f", &elements[i].p.x, &elements[i].p.y);

}

elementos[0].included = 1;

elementos[1].included = 1;

elementos[2].included = 1;

círculo = get_min_circle(elementos[0].p, elementos[1].p, elementos[2].p);

for (i = 0; i < n; i++) {

if (elementos[i].incluidos )

continuar;

if (DISTANCIA(elementos[i].p, círculo.o) - círculo.r > 0.00001) {

círculo = get_min_circle (círculo.p1, círculo.p2, elementos[i].p);

}

elementos[i].incluidos = 1;

}

devuelve 0;

}