Urgente~~¡Acerca del diseño del curso de C sobre el uso de asteriscos para formar letras A~Z~~~!

#include

#include

#define SCREEN_COLS 80 /* ¿Cuántas terminales? ¿Hay columnas*/

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

#defineVERTICAL_DISTANCE 1 /* La distancia vertical entre dos filas de caracteres */

#define BRUSH_CHAR ('*')

#define BLANK_CHAR (' ')

/* El modelo de alto y ancho de la fuente en el modelo de caracteres ASCII_TAB Alto y ancho de fuente medio*/

#define FONT_ROWS 7

#define FONT_COLS 5

/* El número máximo de caracteres que se pueden se muestra en la pantalla por línea */

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

// ASCII_TAB[] contiene todos los caracteres ASCII desde sp (32) hasta 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, 0x00 }, // '

{ 0x00, 0x00, 0x00 }, // '

{ 0x00, 0x00, 0x00, 0x00 }.0x00, 0x50, 0x30, 0x00 }, // ,

{ 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, 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 }, // & lt;

{ 0x14, 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, 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 }, // Yo

{ 0x20, 0x40, 0x41, 0x3F, 0x41, 0x00 }, // Yo

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

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

{ 0x7F, 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, 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, 0x00 }, // l

{ 0x7C, 0x04, 0x18, 0x04, 0x00 }, // l

{ 0x7C, 0x04 0x18, 0x0

4, 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)); /p>

}

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

{

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

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

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

scanf("%s", str);

len = strlen(str);

while (index < len) {

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

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

print_row(str[index + j] , i);

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

printf("%c", BLANK_CHAR);

}

}

printf("\n");

}

índice += CHAR_PER_LINE;

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

printf("\n");

}

}

devolver 0;

}

/* Pregunta 2 */

#include

#include < stdlib.h>

#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 & b*/

#define SQUARE(a) ( (a)*(a)

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

#define DISTANCIA(a,b) (sqrt(SQUARED_DISTANCE((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 la circunferencia del 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 - by

float dy2 = b.y - c.y; p> flotante x1 = (a.x + b.x) / 2.0;

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

flotante y1 = (a.y + b.y) / 2.0; /p>

float y2 = (b.y + c.y) / 2.0

r;

esult.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); /p>

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

resultado.p1 = a

resultado.p2 = c;

Devolver resultado;

}

/* Obtener el círculo más pequeño que contiene tres puntos dados

* Nota:

* 1 ) Los puntos del árbol pueden estar en línea recta

* o

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

*/

Círculo estático

get_min_circle(Punto a, Punto b, Punto c)

(Punto a), Punto b, Punto c).b, Punto c)

{

Resultado del círculo;

float ab,bc,ac, max;

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 la misma línea*/

printf("line\n");

if (EQUAL_FLOAT(max, ab)) {

/* ab es el diámetro*/

result.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;

result.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*/

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

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

resultado.r = max / 2.0 ;

resultado.p1 = a;

resultado.p2 = c;

}

} else { /* triángulo*/

/* Obtener la circunferencia del triángulo*/

p> 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);

Devuelve 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ño de(Elemento)*n);

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

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

printf("Por favor, 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;

}

devolver 0;

}