¡Urgente! En lenguaje C, escriba un programa e ingrese la letra A, y luego podrá generar una letra compuesta por * en la posición apropiada en la pantalla y el tamaño apropiado.

#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 /* distancia vertical entre dos filas de caracteres (interlineado) */< / p>

#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 pueden mostrar en cada línea de la pantalla*/

#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, 0x30, 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 }, // >>p>

{ 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<

/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

};

carácter estático get_char_xy(char ch, int x, int y)

{

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

ch = ' ';

ch -= ' ' ;

return (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[ ])

{

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 + index < len; j++) {

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

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

printf("%c", BLANK_CHAR);

}

}

printf("\n"); p>

}

index += CHAR_PER_LINE;

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

printf(" \norte

");

}

}

devuelve 0;

}

/* Pregunta 2* /

#include

#include

#include

# incluir

#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 SQUARE(a) ((a)*(a))

#define SQUARED_DISTANCE(a,b) (SQUARE ( (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 la circunferencia 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;

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

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

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

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

(dx2*dy1 - dx1*dy2);

r

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

resultado.p2 = c;

devolver resultado;

}

/* obtener 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;

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

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

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

/* ge

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

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ñ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(circle.p1, círculo.p2, elementos[i].p);

}

elementos[i].included = 1; p>

}

devuelve 0;

}