arfneto

Talvez tenha. Fazia tempo que eu não lia nada sobre isso, acho que o formato "754" está bem estabelecido. Mas tem um exemplo aqui: http://www.edwardbosworth.com/My3121Textbook_HTM/MyText3121_Ch17_V02.htm Talvez tenha alguma biblioteca de conversão, veja em http://developer.ibm.com pode ser um bom começo. Mas o formato está bem documentado e não é complicado.

Não, não poderia. Você declarou isso como int então é um valor integral, sem decimais. A divisão vai truncar o valor. Não pensou em testar? Algo como mostrar o resultado? int a = 268; printf("268, 268/100 %d %d\n", a, a / 100); Que mostraria 268, 268/100 268 2 Só uma linha afinal. if (centena == 2 || 4 || 6 || 8) { ... Aqui você tem um problema. Computadores não entendem contexto. Você não pode escrever isso. Ou melhor, pode mas não expressa o que você quer testar... if ( (centena == 2) || (centena == 4) || (centena == 6) || (centena == 8) ) {}; Isso é o que você quer testar. Não pode omitir a condição. adicionado 15 minutos depois if (centena == 2 || 4 || 6 || 8) { printf ("CENTENA PAR"); } Talvez seja o caso de explicar o que está escrito acima. O que está escrito para o compilador C. É uma questão de prova comum em C e operadores afinal. Em C 0 é falso. Qualquer outra coisa é verdadeira. if(2) é verdadeiro, if(4), qualquer coisa menos if(0) é verdadeiro. A expressão acima tem DOIS operadores: == e || == é avaliado antes de || 2, 4 ,6 e 8 são como eu disse verdadeiro if ( (centena == 2) || 4 || 6 || 8 ) printf ("CENTENA PAR"); Assim é como vai ser avaliado. Sempre use parenteses. Se centena for 2 a primeira expressão vai ser true. Mas como 4 é verdadeiro basta isso para (a OU b OU c OU d) ser verdade, certo? Então essa expressão é sempre verdadeira. O compilador deve ter dado um aviso que você não considerou... Veja o que diz no meu compilador: Pois é: constante não nula || constante não nula é sempre uma constante não nula...

pode ser que só eu esteja lendo assim, mas se trata de dois pontos e um vetor no espaço. O primeiro ponto a ponta da flecha. O segundo a posição da maçã. O vetor a direção do tiro. Lembro extensa e folclórica discussão dias atrás neste forum tentando estabelecer que um vetor é definido por 3 coisas: módulo, direção e sentido.Pois é: o vetor indica a direção do tiro, que nesse caso é considerado retinho. E o sentido nesse caso é importante porque o cara tem que atirar na direção da maçã... Não adianta apontar certo mas para o lado errado. O módulo não importa. O cara vai acertar a maçã se os pontos A e M estiverem alinhados com o vetor D. Como se espera. Aqui entre nós a flecha tem mesmo cara de vetor com até uma ponta indicando o sentido. Ou não? Mas são pontos no espaço. Imagino que R3 indique isso.... Claro que no plano dá na mesma. y = ax + b é uma reta no plano Se ela contem dois pontos de D contem A contem M Então A maçã já era.

Não acha que devia ter postado isso antes? Entendeu o programa que te enviei? Há décadas o padrão para isso é o IEEE754. Veja uma descrição em https://docs.microsoft.com/pt-br/cpp/build/ieee-floating-point-representation?view=vs-2019 por exemplo A FC05 é o valor que quer. Apenas encontre a especificação para o float IBM 4 e converta. Nada tem a ver com Little Endian Big Endian exceto que vai ter claro que inverter os bytes como mostra o programa que te enviei. Se entendeu o programa viu que simplesmente ele grava esse valor de duas maneiras e lê de volta. E depois lê o trecho do seu arquivo onde estão os dados.

Pode evoluir um pouco mais, certo? mostre os valores que está lendo. É mais seguro use prompts para orientar a leitura das notas comece com valores fixos e faça as contas todas, antes de ficar lendo. Isso só via te atrasar

que tal resolver ao menos um dos casos, ainda que com valores fixos?

Que está fazendo esse programa? Não lê nada não mostra nada não verifica se algum número é primo não tenta ver qual o maior ou menor não calcula a média Como iniciante, escolha algo e tente fazer, como ler e mostrar os valores e ao final mostrar o maior. Vai se sentir melhor

e?

São pontos no espaço...

#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<string.h> int main(int argc, char** argv) { union { float valor; unsigned char bytes[4]; } u; unsigned int N = 0; FILE* file = NULL; file = fopen("teste.txt","w"); u.valor = 719877; N = fwrite((void*)&u, 4, 1, file); printf("Gravou float: %d * %d bytes\n", N, sizeof(float)); N = fwrite((void*)u.bytes, 1, 4, file); printf("Gravou byte a byte: %d bytes\n", N); fclose(file); file = fopen("teste.txt", "r"); float outro = 0; fread(&outro, 4, 1, file); printf("Leu um float: %f\n", outro); fread(u.bytes, 1, 4, file); printf("Leu em 4 bytes: %f\n", u.valor); printf("byte a byte: %X %X %X %X\n", u.bytes[0], u.bytes[1], u.bytes[2], u.bytes[3] ); fclose(file); printf("Lendo arquivo original\n"); file = fopen("arquivo.txt", "r"); unsigned char buffer[256]; N = fread(buffer, 1, 256, file); // le 240 printf("Leu %d do arquivo original\n", N); for (int i = 220; i <= 236; i += 8) { printf("%04d : %02X %02X %02X %02X %02X %02X %02X %02X\n", i, buffer[i], buffer[i + 1], buffer[i + 2], buffer[i + 3], buffer[i + 4], buffer[i + 5], buffer[i + 6], buffer[i + 7] ); }; // for() fclose(file); }; // main() Esse programa vai te ajudar a entender o que acontece: Ele grava de duas maneiras esse valor em um arquivo e depois lê e depois abre o arquivo original e mostra a parte que interessa Veja o resultado Gravou float: 1 * 4 bytes Gravou byte a byte: 4 bytes Leu um float: 719877.000000 Leu em 4 bytes: 719877.000000 byte a byte: 50 C0 2F 49 Lendo arquivo original Leu 256 do arquivo original 0220 : 00 00 00 15 00 45 AF C0 0228 : 50 00 00 00 00 00 00 00 0236 : 00 00 00 00 00 00 00 00 Estão invertidos como esperado, mas tem dois bits de diferença: de AF para 2F e de 45 para 49. Está certo sobre o valor? Sabe a máquina e a linguagem que gerou isso? O formato interno do float é o que importa aqui eu acho.

trata-se apenas de inverter os bytes e as palavras. Você tem um arquivo que foi gerado assim? Big Endian? De que máquina? Sabe ler um dump ou usar um editor hex?

Esse algoritmo é a implementação comum, como te mostrei. Apenas a transcrição da definição. No caso dos 3 métodos. Só muda o ponto da "visita", no caso aqui o momento onde imprime o nó. Veja um exemplo de código para os 3 tipos de percurso, em C, direto de https://www.tutorialspoint.com/data_structures_algorithms/tree_traversal_in_c.htm void pre_order_traversal(struct node* root) { if(root != NULL) { printf("%d ",root->data); pre_order_traversal(root->leftChild); pre_order_traversal(root->rightChild); } } void inorder_traversal(struct node* root) { if(root != NULL) { inorder_traversal(root->leftChild); printf("%d ",root->data); inorder_traversal(root->rightChild); } } void post_order_traversal(struct node* root) { if(root != NULL) { post_order_traversal(root->leftChild); post_order_traversal(root->rightChild); printf("%d ", root->data); } } Se acha que em seu cenário pode atingir mesmo algum caso limite e não quer usar recursão pode implementar todos os 3 usando uma pilha para controlar o percurso na volta. Não é complicado. O que importa para o aluno considerar é que: o inOrder trás os elementos em ordem crescente numa árvore binária. PostOrder visita os nós a partir "do fundo" e é a maneira segura de você apagar a estrutura ao final do programa, porque uma vez que você visitou o nó não vai mais passar por ele então pode chamar free() O percurso por nível é o que traz os elementos em ordem.

arv* insere(arv* raiz, arv arvoree) { int i = 0; arv* a; if (i == NULL) { a = (arv*)malloc(sizeof(arv)); strcpy(a->nome, arvoree.nome); strcpy(a->email, arvoree.email); strcpy(a->endereco, arvoree.endereco); strcpy(a->dataAniversario, arvoree.dataAniversario); a->idade = arvoree.idade; a->esq = NULL; a->dir = NULL; Continua valendo tudo que eu escrevi, mas acho que ficou meio escondido isso no texto: Acabou de declarar como i = 0 e em seguida testa se é igual a NULL, que é... ZERO. void imprimePreOrdem(arv* raiz){ if(raiz != NULL) { printf("\nNome: %s\n", raiz->nome); printf("Email: %s\n", raiz->email); printf("Endereco: %s\n", raiz->endereco); printf("Aniversario: %s\n", raiz->dataAniversario); printf("Idade: %i anos\n\n\n", raiz->idade); imprimePreOrdem(raiz->esq); imprimePreOrdem(raiz->dir); } } Não é assim inusitado. É apenas o comum. Nada original. Veja por exemplo em https://www.tutorialspoint.com/data_structures_algorithms/tree_traversal_in_c.htm que Bem familiar não é. Não precisa nem abrir o site pra copiar o código Mas não é o caso de copiar. É a definição mesmo: Em preOrder você "visita" o nó na primeira vez que o vê e depois continua percorrendo a árvore, sempre começando pela esquerda. Não vem com muitas falhas. Considere que a recursão ocorre uma vez para cada nível. Com uma árvore binária como essa uma árvore de apenas 10 níveis já pode ter até 2^10 - 1 = 1023 elementos. Seria preciso uma entrada bem especial, algo como entrar com valores em ordem decrescente para cair no pior caso e deixar apenas um nó para cada nível para ter uma situação mais preocupante. Mas é válida a preocupação. E por isso em geral se tenta usar árvores balanceadas automaticamente para ir distribuindo os nós mais arrumadinhos para os dois lados em relação à raiz. Basicamente se faz isso usando rotação dos nós e mudando a raiz quando preciso, e mantendo a árvore "equilibrada".

Ainda não entendi aquela parte, mas vendo seu programa tem algo que talvez você não tenha entendido mesmo nisso... Você vai criar uma classe cadastro. Ou uma struct como fez... mas.. struct cadastro { int cod; /* Código do solicitante*/ char solicitante[50]; /* Nome do solicitante*/ char cpf[11]; /* CPF do solicitante*/ char endereco[50]; /* Endereço do Solicitante*/ char email[50]; /* Email do Solicitante*/ char sexo[2]; /* Sexo do Solicitante (M)- Masculino e (F)- Feminino*/ char faixaetaria[2]; /* Faixa etária do solicitante*/ }; struct cadastro solicitante[MAX]; int topo; void inserir(); void excluir(); void listar(); void pesquisar(); void alterar(); int const MAXTAM=1000; int Frente, Tras; int Fila[MAXTAM]; void Fila_Construtor(){ Frente=0; Tras=-1; } Uma grande vantagem --- e a razão na verdade dessa linguagem ter sido criada --- é a facilidade de abstração. Isso quer dizer a simplicidade com que você cria um modelo no programa para representar a sua realidade. Você não fez nada. É como se estivesse programando em C ou FORTRAN. Essas funções que declarou depois são todas vinculadas ao cadastro. Está errado como escreveu. Pois é. C++ tem implementações de fila com todas essas funções já na biblioteca padrão. Imagino que não possa usar porque faz parte de seu enunciado escrever isso, mas é claro que pode escrever o programa usando isso e depois trocar pelas suas versões. Isso seria um caso simples de uma das propriedades mais importantes desse tipo de linguagem: o tal do encapsulamento. Isso quer dizer que de qualquer forma fila é uma outra classe de seu programa. E você deve usar isso. Toda uma geração de linguagens existe em torno desses conceitos, esse lance de programação orientada a objetos. Seu curso nunca teve uma introdução ao menos a respeito? Tem um enunciado mais preciso? Não está praticamente nada definido sobre as solicitações. De todo modo, considere esse exemplo e veja se entende a diferença entre o programa que fez, que é basicmente um programa em C, e esse: Um exemplo de cadastro: #include <iomanip> #include <iostream> using namespace std; class Cadastro { public: string nome; class Item { public: int cod; char solicitante[50]; char cpf[15]; char endereco[50]; char email[50]; char sexo[2]; // M F char faixaetaria[2]; }; int tamanho; int capacidade; Item** item; Cadastro(); Cadastro(int); ~Cadastro(); int Adicionar(const Item*); int Capacidade(); Item* Consultar(const int); Item* Consultar(const char* CPF); void define_nome(string); int Remover(const int cod); int Remover(const char* CPF); int Listar(); int Tamanho(); }; Um exemplo de fila: #pragma once #include <iomanip> #include <iostream> class Fila { public: class Solicitacao { public: int cod; int cod_solicitante; char descricao[50]; }; int capacidade; int tamanho; Solicitacao** sol; public: Fila(); Fila(int); ~Fila(); int Inserir(Solicitacao*); int Listar(); int Remover(Solicitacao*); int Tamanho(); bool Vazia(); }; Esse é um exemplo bem trivial, nem é muito certo. Mas imagino que dê pra entender as diferenças mais básicas: Um Cadastro tem itens As funções do cadastro se aplicam ao cadastro e ficam dentro dele Você pode pesquisar por nome ou CPF com rotinas iguais Uma fila tem solicitações As solicitações remetem a um cadastro As funções da fila fazem parte de cada fila Como escrever com isso int main(int argc, char** argv) { int res = 0; Fila fila(50); // solicitacoes Cadastro cadastro(10); // solicitantes Cadastro outros[2]; // exemplo cadastro.define_nome("oficial"); outros[0].define_nome("um outro"); outros[1].define_nome("mais um"); do { Alguem* um = cria_alguem(1); res = cadastro.Adicionar(um); delete um; cout << "Cadastro reporta " << cadastro.Tamanho() << " de " << cadastro.Capacidade() << " possiveis solicitantes" << endl; } while (res == 0); cadastro.Listar(); outros[0].Listar(); outros[1].Listar(); return 0; } Escrevi isso copiando do seu programa. Esse programa funciona e usa uma função cria_alguem() que devolve um item de cadastro novinho e com código crescente. E cria uma fila com tamanho e 3 cadastros e preenche um deles até lotar. Depois lista os 3 e encerra. E sabe que lotou porque Adicionar() retorna erro e aí sai do loop. E já é boa parte do seu programa num instante, porque em C++ é mais fácil criar modelos. Citando o criador da linguagem, um dos objetivos ao criar C++ era escrever uma linguagem com "abstrações de custo zero". Rodando esse programa: Criando Fila com capacidade para 50 solicitacoes Cadastro reporta 1 de 10 possiveis solicitantes Cadastro reporta 2 de 10 possiveis solicitantes Cadastro reporta 3 de 10 possiveis solicitantes Cadastro reporta 4 de 10 possiveis solicitantes Cadastro reporta 5 de 10 possiveis solicitantes Cadastro reporta 6 de 10 possiveis solicitantes Cadastro reporta 7 de 10 possiveis solicitantes Cadastro reporta 8 de 10 possiveis solicitantes Cadastro reporta 9 de 10 possiveis solicitantes Cadastro reporta 10 de 10 possiveis solicitantes Cadastro reporta 10 de 10 possiveis solicitantes cadastro 'oficial' com 10 de 10 possiveis solicitantes #001/010: Nome: Nome1001 SobreNome1001 CPF: 123.001.001-02 End: Rua R1001 01 Ap 2 #002/010: Nome: Nome1002 SobreNome1002 CPF: 123.002.002-03 End: Rua R1002 02 Ap 3 #003/010: Nome: Nome1003 SobreNome1003 CPF: 123.003.003-04 End: Rua R1003 03 Ap 4 #004/010: Nome: Nome1004 SobreNome1004 CPF: 123.004.004-05 End: Rua R1004 04 Ap 5 #005/010: Nome: Nome1005 SobreNome1005 CPF: 123.005.005-06 End: Rua R1005 05 Ap 6 #006/010: Nome: Nome1006 SobreNome1006 CPF: 123.006.006-07 End: Rua R1006 06 Ap 7 #007/010: Nome: Nome1007 SobreNome1007 CPF: 123.007.007-08 End: Rua R1007 07 Ap 8 #008/010: Nome: Nome1008 SobreNome1008 CPF: 123.008.008-09 End: Rua R1008 08 Ap 9 #009/010: Nome: Nome1009 SobreNome1009 CPF: 123.009.009-10 End: Rua R1009 09 Ap 10 #010/010: Nome: Nome1010 SobreNome1010 CPF: 123.010.010-01 End: Rua R1010 10 Ap 1 cadastro 'um outro' vazio cadastro 'mais um' vazio Apagando Cadastro com 0/ 10 solicitantes Apagando Cadastro com 0/ 10 solicitantes Apagando Cadastro com 10/ 10 solicitantes Apagando solicitante #1001 Apagando solicitante #1002 Apagando solicitante #1003 Apagando solicitante #1004 Apagando solicitante #1005 Apagando solicitante #1006 Apagando solicitante #1007 Apagando solicitante #1008 Apagando solicitante #1009 Apagando solicitante #1010 Apagando Fila com 0/ 50 solicitacoes E você vê que tudo acontece como previsto. E é muito mais simples que em C. OK, talvez em COBOL fosse bem mais simples escrever os relatórios Mas criou a fila os cadastros, preencheu um, e listou os 3 e apagou tudo.

sugiro programar aos poucos, uma coisa por vez. Pense bem na interface, algo simples porque não muda nada no jogo. Defina os comandos, pode usar uma letra ou simbolo pra cada um pense numa "tela" com umas 4 linhas apenas e vá repetindo na tela a cada ciclo, algo como uma linha com a tela as cartas do jogador e do computador, os pontos e o comando

o que seria isso? não entendi. "direcionar um cadastro de uma pessoa para iniciar outro? Pode explicar de outro modo?

Não, não é negativo. Como parte da iniciativa para evitar inserção de código malicioso --- hacking --- toda área de memória alocada para um programa é inicialmente zerada. Então idade entra com zero e fica assim para todo o sempre. Se prestar atenção ao programa, e ao que o autor disse e ao que expliquei acima, fica claro que o programa dele entrou no loop e apenas mantem menoridade com zero pela razão que você notou. Se idade fosse negativo o programa apenas mostraria os totais e terminaria, já que a condição do while não seria satisfeita...

Se vai ler de um arquivo basta definir um formato. Se vai ler a cada execução deixe isso fora das funções e simplesmente leia um a um e mostre em seguida para ficar mais seguro. Chame as funções com os valores e mostre o resultado e grava no disco. Isso claro sugere uma função double area(double raio, double diametro); Para ter um resultado mais útil talvez devesse pedir o valor mínimo e máximo da espessura e um intervalo, e imprimir assim uma planilha de custos acompanhando a variação da espessura, certo? E isso sugere double peso(double area, double espessura); E as fórmulas das funções você já escreveu. Como a área aparentemente só é usada para calcular o peso talvez seja supérfluo usar duas funções.

E que erro é que "ele dá"? Não entendi. Quanto ao seu problema da menoridade: while (idade >= 0) { Seu programa começa assim. Só que você não inicializou idade. Então como é uma área que acabou de ser recebida do sistema para alocar as suas variáveis está tudo zerado, certo? Inclusive a idade. Quando você entra no loop com idade igual a zero a primeira coisa que acontece é copiar if (idade < menoridade) { menoridade = idade; } já que menoridade é 200 e idade é zero. E aí nunca mais esse valor vai sair de lá. Só sairia com uma idade negativa, mas aí o programa termina porque saí do loop com essa condição. Então não é surpresa que menoridade seja sempre zero...

Na verdade esqueci de deixar a vírgula. É a isso que me refiro: const char* margem[11] = { "", "", " ", " ", " ", " ", " ", " ", " ", " ", " ", }; Você pode deixar a última vírgula. Durante muito tempo não compilava. É uma liberalidade, porque o programador SEMPRE esquecia. E em programas que geravam código fonte era preciso ter esse tratamento especial para a última linha. Por falar em liberalidade, em C é perfeitamente válido inicializar vetores fora de ordem. E mesmo faltando índices. Algo como const char* margem[11] = { [ 4] = " ", [ 5] = " ", [ 6] = " ", [ 7] = " ", [ 8] = " ", [ 1] = "", [ 2] = " ", [ 3] = " ", [ 9] = " ", [10] = " ", }; Serviria sem problemas no programa acima. Veja que a posição 0 não foi inicializada. Em C++ não pode ser assim fora de ordem.

Essa é uma solução mais formal. E elegante. Muito boa porque leva em conta a topologia da coisa: sempre vai imprimir 100 letrinhas em 10 linhas de 10 letras. Conforme muda o contexto imprime o espaço ou o asterisco. E o código reflete isso. Se você considerar o espaço apenas como alinhamento ainda seria formal, marginalmente mais eficiente e mais legível escrever apenas #include "stdio.h" int main() { const char* margem[11] = { "", "", " ", " ", " ", " ", " ", " ", " ", " ", " " }; int i = 0; int asteriscos = 0; printf("(A)\n\n"); for (i = 1; i <= 10; i += 1) { for (asteriscos = 1; asteriscos <= i; asteriscos += 1) printf("*"); printf("\n"); } printf("\n(B)\n\n"); for ( i = 1; i <= 10; i += 1) { for (int asteriscos = 10; asteriscos >= i; asteriscos -= 1) printf("*"); printf("\n"); } printf("\n(C)\n\n"); for (int i = 1; i <= 10; i += 1) { printf("%s", margem[i]); for (int asteriscos = 10; asteriscos >= i; asteriscos -= 1) printf("*"); printf("\n"); } printf("\n(D)\n\n"); for (int i = 1; i <= 10; i += 1) { printf("%s", margem[11-i]); for (int asteriscos = 1; asteriscos <=i; asteriscos += 1) printf("*"); printf("\n"); } return 0; } inserindo as margens onde necessário. Esse imprime exatamente como está no enunciado. Pela gramática da linguagem o if é seguido de um comando que pode ser segundo por um else e outro comando. E a definição de comando é essa: um comando simples termina por um ; ou pode ser um bloco delimitado por { }. Um if como esse abaixo seria um exemplo completo if (i == 0) {} else ; tanto ; quando { } são comandos válidos. Para retirar a necessidade do ; antes do else seria preciso aceitar o else como terminador de comando. Mas aí seria preciso decidir: ou else pode ser aceito como ; em qualquer comando ou seria preciso avaliar APENAS o else dentro do if para aceitar isso. E aí a gramática não seria mais genérica em relação aos comandos. Provavelmente não valeria a pena mudar tanto as coisas. Às vez se aceita alguma coisa assim para ajudar o programador, alguma liberalidade, como deixei aí no exemplo uma vírgula a mais antes da chave na declaração das constantes. Pra que não seja preciso o programador voltar lá se retirar do final da lista alguma coisa. Fica "feio" mas é útil. Mas no caso do else seria talvez muito trabalho porque iria mudar a avaliação de comandos no geral.

A menos que seja visto como um desafio pessoal ou algo imposto, não faz sentido criar um programa para um único desenho. Compilar o programa para gerar algo já é algo esquisito: imagine ter que compilar o código para mudar uma curva no coraçãozinho... A cada curva nova. Quer desenhar um quadrado? Outro programa. Um triângulo? Outro programa. Talvez um programa para desenhar corações ao menos, que aceitasse parâmetros e aprendesse com o tempo. Ou o simples como eu disse: um programa que copia desenhos de um arquivo e aceite alguns parâmetros como cor e intensidade do traço. Que tal um programa plotter? Comandos: baixa a caneta levanta a caneta move a caneta numa direção muda a cor da caneta limpa o desenho imprime termina Original? nada original. Mas desenha qualquer coisa. Afinal um plotter é assim. E programas como o Turtle Graphics (para crianças) que rodava no Apple. Que Apple? o Apple II nos '70. Era assim também. Um plotter tartaruga para crianças desenharem na tela. Na tela verde, claro. E já não era original. Qualquer semelhança com o turtle do phyton é porque é a mesma coisa. Não sei porque o Brazilian Student citado não usou turtle para desenhar o meigo coração, já que basta usar import turtle e começar a desenhar e foi feito para isso afinal. E pode ler de arquivos. E foi feito para crianças. turtle.forward(50) turtle.left(90) turtle.forward(50) turtle.left(90) turtle.forward(50) turtle.left(90) turtle.forward(50) turtle.left(90) Exemplo para desenhar um quadrado em Desenhando um quadrado com a tartaruga em Phyton

Entendo. Então sabe que imprimiu 3 vezes a mesma coisa. Porque não postou o código? Entenda que cada bloco desses é só uma letra entre parenteses seguida por uma lista de 10 linhas de 10 letrinhas. E cada letrinha pode ser espaço ou asterisco. Só isso. Para imprimir os asteriscos você DEVE usar um printf("*"); para cada um. O resto você pode fazer como quiser. E para ver como fazer é só contar de 1 a 10 para as linhas e dentro das linhas acertar o número de espaços em cada linha, o que varia de um em um. É opcional imprimir os espaços à direita já que ninguém vai ver mesmo . E os espaços a esquerda vão alinhar os asteriscos. Ou aumenta um a cada linha ou diminui um a cada linha, dependendo do padrão. Qual a sua dificuldade?

Isso em fundo preto seria o que?

A inclusão não é automática. Facilita muito a vida do programador, porque você pode se preparar para os limites em uso para a plataforma onde o código está sendo compilado, e assim se pode escrever um código mais genérico. Não por acaso as rotinas da biblioteca padrão usam isso, e assim se você inclui stdlib em seu programa vai ter acesso às contantes em limits.h. E claro que isso vale para qualquer outra biblioteca que por alguma razão inclua limits.h porque assim são os #include Programar sem isso quer dizer que você precisa saber de outro modo o valor disso em cada programa. Coisas simples como usar INT_MAX como um valor padrão para um int que vai guardar um mínimo ou INT_MIN no caso contrário teriam que ser improvisadas de outro modo. limits.h é o simples: Você usa as constantes e o compilador põe o valor. Integer de 16 bits? 32? 64? 36? Tanto faz, por exemplo.