Sara Rodrigues21

gente já comecei a fazer, porém tá muito confuso iremos colocar em prática conteúdo de estrutura condicional utilizando a linguagem PHP O cálculo básico para se descobrir se o álcool é vantajoso ou não em relação à gasolina é simples. Basta dividir o preço do litro do álcool pelo da gasolina. Se o resultado for inferior a 0,7, use álcool. Se for maior que 0,7, então a gasolina é melhor. Por exemplo, se o litro do álcool custar R$ 5,30 e o da gasolina R$ 7,00, então o resultado será de 0,757. Ou seja, álcool ou gasolina? A gasolina é mais vantajosa. Assim, nesse período, valeu mais abastecer com gasolina. Diante do contexto apresentado, crie um script em php que simule a calculadora acima mediante as condições abaixo. A enfermeira Juliana reside em Maringá, e precisa encher o tanque de seu carro (Creta) a cada 20 dias, e ao chegar ao posto de sua confiança sempre se depara com os altos preços dos combustíveis seja álcool ou gasolina, e sempre se pergunta. Será que compensa colocar álcool? Na dúvida ela sempre coloca gasolina, uma média de 50 litros. No script deve ter: 1 - Uma variável que armazene o preço de cada combustível (álcool e gasolina) de sua cidade. 2 – Realizar os cálculos necessários (porcentagem e do custo do abastecimento em álcool e gasolina). 3 – Implementar a funcionalidade que informará a enfermeira Juliana se é viável ou não abastecer o seu carro no álcool, além de mostrar o custo final do seu abastecimento. Se não for viável, informar o motivo e o preço final também.

Alternativa 1: 2 Alternativa 2: 3 Alternativa 3: 1 3 Alternativa 4: 2 3 Alternativa 5: 1 2 3

Se existe a programação "front-end" é natural entender que existe uma programação "back-end". A programação back-end não é o objetivo do nosso estudo nessa disciplina, mas entender o que é o papel de cada uma nos ajuda a desenvolver melhor. Considerando o exposto acima sobre a programação back-end, analise as afirmações abaixo: I - A programação back-end roda apenas nos servidores e é uma programação mais pesada, que os computadores dos usuários não dariam conta de processar. II - A programação front-end precisa se comunicar com a programação back-end a fim de tratar os dados retornados pelo back-end e exibi-los da melhor forma ao usuário. III - A programação back-end envolve a parte de lógica e cálculos que não pode estar no computador dos usuários por questões de segurança, retornando apenas a informação já processada. IV - É responsabilidade da programação back-end acessar os dados no banco de dados e retorná-los ao usuário de forma que o usuário receba apenas a informação que possui permissão de acesso. É correto o que se afirma em: Alternativa 1 I, apenas. Alternativa 2: I e II, apenas. Alternativa 3: II e III, apenas. Alternativa 4: III e IV, apenas. Alternativa 5: II, III e IV, apenas.

@arfneto sobre começar a escrever o código, não colocar o menu em um programa que não está pronto. não entendi

@arfneto Acho que já te falei sobre isso, mas nunca coloque um menu em um programa que não está pronto. NUNCA escreva um programa interativo se puder evitar. Só vai perder tempo. começando por aqui...

@arfneto não tô entendendo mais nada, esse negócio é muito difícil

@arfneto //Bibliotecas #include <stdio.h> #include <stdlib.h> #include <math.h> //Variaveis int destino,origem,vertices=0; int custo,*custos=NULL; //Prototipação void dijkstra(int vertices,int origem,int destino,int *custos); void menu_mostrar(void); void grafo_procurar(void); void grafo_criar(void); //Função principal int main(int argc,char **argv){ int opt= -1; //Laço principla do menu do { //Desenha o menu na tela menu_mostrar(); scanf("%d",&opt); switch(opt){ case 1: //Cria um novo grafo grafo_criar(); break; case 2: //Procura os caminhos if(vertices>0){ grafo_procurar(); } break; } }while(opt!=0); printf("\nAlgoritmo de Dijkstra finalizado...\n\n"); system("Pause"); return 0; } //Implementação do algoritmo de Dijkstra void dijkstra(int vertices,int origem,inte destino,int*custos){ int i,v,cont=0; int *ant,*tmp; int *z;/*vertices para os quais se conhece o caminho minimo*/ double min; double dist[vertices];/*vetor com os custos dos caminhos*/ /*aloca as linhas da matriz*/ ant=(int*)calloc(vertices,sizeof(int*)); if(ant==NULL){ system("color fc"); printf("**Erro:memória Insuficiente**"); exit(-1); } tmp=(int*)calloc(vertices,sizeof(int*)); if(tmp==NULL){ system("color fc"); printf("**Erro:memória Insuficiente**"); exit(-1); } z=(int*)calloc(vertices,sizeof(int*)); if(z==NULL){ system("color fc""); printf("**Erro:memória Insuficiente**"); exit(-1); } for (i = 0; i < vertices; i++) { if (custos[(origem - 1) * vertices + i] !=- 1) { ant[i] = origem - 1; dist[i] = custos[(origem-1)*vertices+i]; } else { ant[i]= -1; dist[i] = HUGE_VAL; } z[i]=0; } z[origem-1] = 1; dist[origem-1] = 0; /* Laco principal */ do { /* Encontrando o vertice que deve entrar em z */ min = HUGE_VAL; for (i=0;i if (!z[i]){ if (dist[i]>=0 && dist[i] min=dist[i];v=i; } } } /* Calculando as distancias dos novos vizinhos de z */ if (min != HUGE_VAL && v != destino - 1) { z[v] = 1; for (i = 0; i < vertices; i++){ if (!z[i]) { if (custos[v*vertices+i] != -1 && dist[v] + custos[v*vertices+i] < dist[i]) { dist[i] = dist[v] + custos[v*vertices+i]; ant[i] =v; } } } } } while (v != destino - 1 && min != HUGE_VAL); /* Mostra o Resultado da busca */ printf("\tDe %d para %d: \t", origem, destino); if (min == HUGE_VAL) { printf("não Existe\n"); printf("\tCusto: \t- \n"); } else { i = destino; i = ant[i-1]; while (i != -1) { tmp[cont] = i+1; cont++; i = ant[i]; } for (i = cont; i > 0 ; i--) { printf("%d -> ", tmp[i-1]); } printf("%d", destino); printf("\n\tCusto: %d\n",(int) dist[destino-1]); } } void grafo_criar(void){ do { printf("\nInforme o numero de vertices (no minimo 3 "); scanf("%d", &vertices); } while (vertices < 3 ); if (!custos) { free(custos); } custos = (int *) malloc(sizeof(int)*vertices*vertices); //Se o compilador falhou em alocar espaço na memória if (custos == NULL) { system("color fc"); printf ("** Erro: memória Insuficiente **"); exit(-1); } //Preenchendo a matriz com -1 for (int i = 0; i <= vertices * vertices; i++){ custos[i] = -1; } do { system("cls"); printf("Entre com as Arestas:\n"); do { printf("Origem (entre 1 e %d ou ‘0’ para sair): ", vertices); scanf("%d", &origem); } while (origem < 0 || origem > vertices); if (origem) { do { printf("Destino (entre 1 e %d, menos %d): ", vertices, origem); scanf("%d", &destino); } while (destino < 1 || destino > vertices || destino == origem); do { printf("Custo (positivo) do vertice %d para o vertice %d: ", origem, destino); scanf("%d",&custo); custo *= 6.596; } while (custo < 0); custos[(origem-1) * vertices + destino - 1] = custo; } } while (origem); } //Busca os menores caminhos entre os vértices void grafo_procurar(void){ int i, j; system("cls"); system("color 03"); printf("Lista dos Menores Caminhos no Grafo Dado: \n"); for (i = 1; i <= vertices; i++) { for (j = 1; j <= vertices; j++) { dijkstra(vertices, i,j, custos); } printf("\n"); } system("pause"); system("color 07"); } //Desenha o menu na tela void menu_mostrar(void){ system("cls"); printf("Implementacao do Algoritmo de Dijasktra\n"); printf("opções:\n"); printf("\t 1 - Adicionar um Grafo\n"); printf("\t 2 - Procura Os Menores Caminhos no Grafo\n"); printf("\t 0 - Sair do programa\n"); printf("? "); } dá uma olhada fazendo favor e me fala se tá certo?

@arfneto vou escrever novamente aqui, daí te mando para dar uma olhada ok, muito obrigada viu @arfneto em me tira uma dúvida aqui nessa parte de custo, o valor q está dentro do colchete é o peso do vértice né?

@arfneto agora eu tô no caminho? to usando o rextester online peguei seu exemplo pra testar o programa e deu certo

@arfneto ok então, vou arrumar aqui

vou te mandar o código #include <stdio.h> #include <stdlib.h> #include <math.h> int destino, origem, vertices = 0; int custo, *custos = NULL; void dijkstra(int vertices,int origem,int destino,int *custos); void menu_mostrar(void); void grafo_procurar(void); void grafo_criar(void); int main(int argc, char **argv) { int opt = -1; do { menu_mostrar(); scanf("%d", &opt); switch (opt) { case 1: grafo_criar(); break; case 2: if (vertices > 0) { grafo_procurar(); } break; } } while (opt != 0); printf("\nAlgoritmo de Dijkstra inalizado...\n\n"); system("pause"); return 0; } void dijkstra(int vertices,int origem,int destino,int *custos) { int i, v, cont = 0; int *ant, *tmp; int *z; double min; double dist[vertices]; ant = (int*) calloc (vertices, sizeof(int *)); if (ant == NULL) { system("color fc"); printf ("** Erro: Memória Insuficiente **"); exit(-1); } tmp = (int*) calloc (vertices, sizeof(int *)); if (tmp == NULL) { @arfneto ele é um compilador online, a versão é atualizada te mandei um pedaço do código @arfneto vou te mostrar no outro compilador, um momento https://www.onlinegdb.com/online_c_compiler

@arfneto o programa q eu uso é o codepad

@arfneto isso mesmo, peguei o seu como base para fazer a atividade até porque o RA é diferente e os números passados também

@arfneto então eu comecei a fazer aqui, só q o professor me confundiu com uma videoaula vou te mandar o código q fiz, se você puder me ajudar @arfneto #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct { unsigned custo[7]; // pesos dos vertices const char* filial[5]; // nomes para as filiais const char* nome; const char* RA; // mais fácil de testar } Transp; Transp* apaga(Transp*); Transp* cria(const char*, const char*); int mostra(Transp*); int main( int argc, char** argv) { const char* RA_exemplo = "2025703-5"; char RA[10] = {0}; if (argc < 2) { // vai usar o exemplo mesmo strncpy(RA, RA_exemplo, 7); } else { // tem 7 ou 6 if (strlen(argv[1]) >= 7) strncpy(RA, argv[1], 7); else { if (strlen(argv[1]) == 6) { // se tem so 6 digitos poe '1' no final strncpy(RA, argv[1], 6); RA[6] = '1'; RA[7] = 0; } else strncpy(RA, RA_exemplo, 7); } }; // if() // cria uma transportadora de teste Transp* teste = cria(RA, "MS Mundo TR"); mostra(teste); teste = apaga(teste); return 0; } Transp* apaga(Transp* T) { free(T); return NULL; } Transp* cria(const char* RA, const char* nome) { const char* local[] = { "Matriz - MS 1", "Paracatu - MG 2", "Marquinho - PR 3", "Belo Horizonte - MG 4", "Porto de Santos - SP 5", }; Transp* tr = (Transp*)malloc(sizeof(Transp)); for (int i = 0; i < 5; i += 1) tr->filial[i] = local[i]; printf("RA: \"%s\"\n", RA); for (int i = 0; i < 7; i += 1) tr->custo[i] = 100 * (RA[i] - '0'); tr->RA = RA; tr->nome = nome; return tr; }; int mostra(Transp* tr) { printf("%s\t(RA considerado: '%s')\n\n", tr->nome, tr->RA); for (int i = 0; i < 5; i += 1) printf(" %d %s\n", 1+i, tr->filial[i]); printf("\nOs pesos: "); for (int i = 0; i < 7; i += 1) printf("%c=%d ", 'A' + i, tr->custo[i]); printf("\n"); return 0; } só não sei se tá certo

Uma empresa de delivery de comida solicitou uma aplicação onde o entregador recebe uma solicitação de entrega para realizar. A localização atual do motorista é representada a seguir pelo vértice número 1 (um) e o local de entrega está no vértice de número 5 (cinco). O grafo acima exibe todas as rotas para alcançar o local de entrega a partir do ponto de partida, que é o restaurante. O destino da corrida é o vértice indicado pelo número 5 (cinco). As possíveis rotas são representadas pelos demais vértices que vão de 1 (um), que é a origem, a 4 (quatro). Desenvolva um algoritmo que ajude o entregador escolher a melhor decisão de rota, pois devido ao aumento consecutivo do valor do combustível, o entregador quer uma estimativa de qual é a melhor rota até o destino da corrida. Foi feito um levantamento histórico do consumo médio das entregas passando por cada ponto de origem até o destino final. Na figura do grafo, os vértices 1, 2, 3, 4 e 5 representam, respectivamente as rotas em que o entregador deve passar para chegar ao destino. O trajeto é representado pelas arestas que liga (1 a 2), (1 a 3), (2 a 4), (2 a 5), e assim por diante. O consumo médio (peso) entre cada conexão está representado por X. Você deve substituir o X pelos 7 primeiros dígitos do seu RA (indo da esquerda para direita) multiplicado por 6,596, que é o valor médio do litro da gasolina nesse momento, na sequência: (1-2), (1-3), (2-4), (2-5), (3-2), (3-5), (4-5). Desenvolva um programa em linguagem C utilizando o algoritmo de Dijkstra para resolver o problema e informe o caminho de menor custo saindo de 1 (que é o ponto de partida da corrida) e chegando em 5 (que é o destino da corrida). O resultado do seu programa deverá indicar as rotas que poderão ser utilizadas pelo motorista e o seu respectivo peso. Apresente na tela todos as rotas com os seus respectivos pesos. Tire um print da sua tela de forma que pegue todos os destinos.