Informe o valor do primeiro elemento: 5

Os elementos do vetor são:

5  10  20  40  80

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>

// função principal do programa
int main(int argc, char *argv[]){
  // vamos declarar e construir um vetor de inteiros
  // de 5 elementos
  int valores[5];
  int i;
	  
  // agora vamos pedir para o usuário informar o
  // valor do primeiro elemento
  printf("Informe o valor do primeiro elemento: ");
  scanf("%d", &valores[0]);
    
  // agora vamos gerar os valores dos próximos elementos
  for(i = 1; i < 5; i++){
    // recebe o elemento anterior multiplicado por 2
    valores[i] = valores[i - 1] * 2;
  }
    
  // e agora mostramos o vetor gerado
  printf("\nOs elementos do vetor são:\n\n");
  for(i = 0; i < 5; i++){
    printf("%d   ", valores[i]);
  }
  
  printf("\n\n");
  system("PAUSE");
  return 0;
}

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <math.h> 
     
int main(int argc, char *argv[]){
  // velocidade (em m/s)
  float velocidade = 50; // em m/s
  // energia cinética
  float energia_cinetica = 75; // em joule
  
  // e então calculamos a massa do corpo
  float massa = (2 * energia_cinetica) / pow(velocidade, 2);
  
  // mostramos o resultado
  printf("A massa do corpo é: %fkg", massa);
			  
  printf("\n\n");
  system("PAUSE");
  return 0;
}

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

// função que permite remover um nó no fim
// da lista, ou seja, o último nó da lista.
// A função retorna um ponteiro para o início da lista
struct No *remover_final(struct No *inicio){
  struct No *n; // nó que será removido
  
  // nó que antecede o nó a ser removido. Isso
  // faz sentido, já que ele será o último nó
  // agora
  struct No *anterior;
  n = inicio; // aponta para o início da lista
  
  // varremos os nós da lista e paramos um nó antes do
  // nó a ser excluído
  while(n->proximo != NULL){
    anterior = n; // anterior assume o lugar de n
    n = n->proximo; // e n assume o seu próximo  
  }
  
  // anterior passa a ser o último nó agora
  anterior->proximo = NULL;
  
  // mostra o nó removido
  printf("\nNo removido: %d\n", n->valor);
  
  free(n); // libera o nó que antes era o último
  
  return inicio;
} 

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
 
// estrutura Nó
struct No{
  int valor;
  struct No *proximo;
};
// fim da estrutura Nó
 
// função que permite exibir os valores de
// todos os nós da lista
void exibir(struct No *n){
  if(n != NULL){
    do{
      printf("%d\n", n->valor);
      n = n->proximo;
    }while(n != NULL);
  }
  else
    printf("A lista esta vazia\n\n");
}
 
// função que permite remover um nó no fim
// da lista, ou seja, o último nó da lista.
// A função retorna um ponteiro para o início da lista
struct No *remover_final(struct No *inicio){
  struct No *n; // nó que será removido
  
  // nó que antecede o nó a ser removido. Isso
  // faz sentido, já que ele será o último nó
  // agora
  struct No *anterior;
  n = inicio; // aponta para o início da lista
  
  // varremos os nós da lista e paramos um nó antes do
  // nó a ser excluído
  while(n->proximo != NULL){
    anterior = n; // anterior assume o lugar de n
    n = n->proximo; // e n assume o seu próximo  
  }
  
  // anterior passa a ser o último nó agora
  anterior->proximo = NULL;
  
  // mostra o nó removido
  printf("\nNo removido: %d\n", n->valor);
  
  free(n); // libera o nó que antes era o último
  
  return inicio;
} 
 
// função que permite inserir nós no
// final da lista.
// veja que a função recebe o valor a ser
// armazenado em cada nó e um ponteiro para o
// início da lista. A função retorna um
// ponteiro para o início da lista
struct No *inserir_final(struct No *n, int v){
  // reserva memória para o novo nó
  struct No *novo = (struct No*)malloc(sizeof(struct No));
  novo->valor = v;
 
  // verifica se a lista está vazia
  if(n == NULL){
    // é o primeiro nó...não deve apontar para
    // lugar nenhum
    novo->proximo = NULL;
    return novo; // vamos retornar o novo nó como sendo o início da lista
  }
  else{ // não está vazia....vamos inserir o nó no final
    // o primeiro passo é chegarmos ao final da lista
    struct No *temp = n; // vamos obter uma referência ao primeiro nó
    // vamos varrer a lista até chegarmos ao último nó
    while(temp->proximo != NULL){
      temp = temp->proximo;
    }
    // na saída do laço temp aponta para o último nó da lista
   
    // novo será o último nó da lista...o campo próximo dele deve
    // apontar para NULL
    novo->proximo = NULL;
    // vamos fazer o último nó apontar para o nó recém-criado
    temp->proximo = novo;
    return n; // vamos retornar o início da lista intacto
  }
}
 
int main(int argc, char *argv[])
{
  // declara a lista
  struct No *inicio = NULL;
 
  // vamos inserir quatro valores no final
  // da lista
  inicio = inserir_final(inicio, 45);
  inicio = inserir_final(inicio, 3);
  inicio = inserir_final(inicio, 98);
  inicio = inserir_final(inicio, 47);
 
  // vamos exibir o resultado
  printf("Valores presentes na lista ligada antes da remocao:\n");
  exibir(inicio);
 
  // vamos remover o nó no fim da lista
  if(inicio != NULL){
    inicio = remover_final(inicio);
  }
  
  // vamos exibir o resultado
  printf("\nValores presentes na lista ligada apos a remocao:\n");
  exibir(inicio);
  
  system("pause");
  return 0;
}

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

Valores presentes na lista ligada antes da remocao:
45
3
98
47

No removido: 47

Valores presentes na lista ligada apos a remocao:
45
3
98

Pressione qualquer tecla para continuar. . .

// dois vetores de 5 inteiros cada
int a[] = {50, -2, 9, 5, 17};
int b[] = new int[5];

Valores no vetor a: 50   -2   9   5   17   
Valores no vetor b: -20   32   21   25   13

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>

int main(int argc, char *argv[]){
  setlocale(LC_ALL,""); // para acentos do português

  // dois vetores de 5 inteiros cada
  int a[] = {50, -2, 9, 5, 17};
  int b[5];
  int i;  
    
  // vamos preencher o segundo vetor de forma que a soma dos
  // valores de seus elementos seja 30
  for(i = 0; i < 5; i++){
    b[i] = 30 - a[i];  
  }
    
  // vamos mostrar o resultado
  printf("Valores no vetor a: ");
  for(i = 0; i < 5; i++){
    printf("%d  ", a[i]);  
  }
    
  printf("\nValores no vetor b: ");
  for(i = 0; i < 5; i++){
    printf("%d  ", b[i]);  
  }
   
  printf("\n\n");
  system("PAUSE");	
  return 0;
}

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// função principal do programa
int main(int argc, char *argv[]){
  // conjunto dos dados
  float conjunto[] = {10, 30, 90, 30};
  float soma = 0.0; // soma dos elementos
  float desvio_padrao = 0.0; // desvio padrão
  int tam = 4; // tamanho dos dados
  int i;
  float media;

  // vamos somar todos os elementos
  for(i = 0; i < tam; i++){
    soma = soma + conjunto[i];
  }

  // agora obtemos a média do conjunto de dados    
  media = soma / tam;

  // e finalmente obtemos o desvio padrão
  for(i = 0; i < tam; i++){
    desvio_padrao = desvio_padrao + pow(conjunto[i] - media, 2);
  }
    
  // mostramos o resultado
  printf("Desvio Padrão Populacional: %f\n", sqrt(desvio_padrao / tam));
  printf("Desvio Padrão Amostral: %f", sqrt(desvio_padrao / (tam - 1)));
  
  printf("\n\n");
  system("PAUSE");
  return 0;
}

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
  // vamos declarar um vetor de 10 inteiros
  int valores[10];
  int i;

  // agora vamos solicitar ao usuário que informe os 10 valores para
  // os elementos do vetor. O mais recomendável neste caso é usar um
  // laço for que repetirá 10 vezes e, a cada repetição, solicitaremos
  // um valor
  for(i = 0; i < 10; i++){
    printf("Informe o valor %d: ", (i + 1));
    scanf("%d", &valores[i]);
  }

  // para finalizar vamos exibir os valores informados pelo usuário e
  // presentes nos elementos do vetor
  printf("\nOs valores informados foram:\n");

  for(i = 0; i < 10; i++){
    printf("O valor %d foi: %d\n", (i + 1), valores[i]);
  }
  
  system("PAUSE");	
  return 0;
}

FILE *fopen(const char *nome, const char *modo);

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
  FILE *arquivo = fopen("c:\\testes.txt", "r");

  // testa se o arquivo foi aberto com sucesso
  if(arquivo != NULL)
    printf("Arquivo foi aberto com sucesso.");
  else
    printf("Nao foi possivel abrir o arquivo.");

  printf("\n\n");
  system("PAUSE");
  return 0;
}

Valor da carga em kN/m: 10
Distância em metros: 13

A reação no apoio A é: 65.000000 kN
A reação no apoio B é: 65.000000 kN
O momento fletor máximo é: 211.250000 kN

Informe uma distância a partir do apoio A: 4
O momento fletor na distância informada é: 180.000000 kN

A força cortante no apoio A é: 65.000000 kN
A força cortante no apoio B é: -65.000000 kN

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main(int argc, char *argv[]) {
  // variáveis usadas na resolução do problema
  float carga, distancia, reacao_a, reacao_b;
  float flexao_maxima, distancia_temp, flexao_distancia;
  float cortante_a, cortante_b;
  
  // vamos pedir para o usuário informar o valor da carga
  printf("Valor da carga em kN/m: ");
  scanf("%f", &carga);
  
  // vamos pedir para o usuário informar a distância entre os apoios
  printf("Distancia em metros: ");
  scanf("%f", &distancia);
  
  // vamos calcular a reação no apoio A
  reacao_a = (1.0 / 2.0) * carga * distancia;
  
  // vamos calcular a reação no apoio B
  reacao_b = reacao_a;
  
  // vamos calcular o momento fletor máximo
  flexao_maxima = (1.0 / 8.0) * carga * pow(distancia, 2.0);
  
  // e mostramos o resultado
  printf("\nA reacao no apoio A e: %f kN", reacao_a);
  printf("\nA reacao no apoio B e: %f kN", reacao_b);
  printf("\nO momento fletor maximo e: %f kN", flexao_maxima);
  
  // vamos pedir para o usuário informar uma distância a
  // partir do apoio A
  printf("\n\nInforme uma distancia a partir do apoio A: ");
  scanf("%f", &distancia_temp);
  // vamos mostrar o momento fletor na distância informada
  if (distancia_temp > distancia) {
    printf("\nDistancia invalida.\n");
  }
  else {
    flexao_distancia = (1.0 / 2.0) * carga * distancia_temp * 
      (distancia - distancia_temp);
    printf("O momento fletor na distancia informada e: %f kN", 
      flexao_distancia);  
  }
  
  // vamos mostrar a força cortante no apoio A
  cortante_a = (1.0 / 2.0) * carga * distancia;
  printf("\n\nA forca cortante no apoio A e: %f kN", cortante_a);
  
  // vamos mostrar a força cortante no apoio B
  cortante_b = cortante_a * -1;
  printf("\nA forca cortante no apoio B e: %f kN\n\n", cortante_b);
  
  printf("\n\n");
  system("PAUSE");
  return 0;
}

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <math.h>  
  
int main(int argc, char *argv[]){
  printf("Seno de 0 = %f", sin(0));
  printf("\nSeno de 1 = %f", sin(1));
  printf("\nSeno de 2 = %f", sin(2)); 
   
  printf("\n\n");
  system("PAUSE");
  return 0;
}

palavra = "FACULDADE"
resultado = palavra[0:len(palavra):2]
print(resultado)