Escreva uma função recursiva que calcule a soma de todos os números compreendidos entre os valores A e B passados por parâmetro.

/*=============================================================================*
* includes                                                                     *
*=============================================================================*/

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

/*=============================================================================*
* declaracoes                                                                  *
*==============================================================================*
/*-----------------------------------------------------------------------------*
* declaracoes - prototipos de funcoes                                          *
*-----------------------------------------------------------------------------*/

int somaNumeros(int, int);

/*-----------------------------------------------------------------------------*
* funcao "main"                                                                *
*-----------------------------------------------------------------------------*/

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

    int iNumA = 0, iNumB = 0, ret = 0;

    printf("Digite o valor do numero A: ");
    scanf("%d", &iNumA);
    printf("\nDigite o valor do numero B: ");
    scanf("%d", &iNumB);
    if (iNumA < iNumB)
       ret = somaNumeros(iNumA, iNumB);
    else
        ret = somaNumeros(iNumB, iNumA);

    printf("\n\nResultado da soma do intervalo dos dois numeros: %d", ret);

    system("pause");

    return 1;
}

/*-----------------------------------------------------------------------------*
* corpo das funções - somaNumeros                                              *
*-----------------------------------------------------------------------------*/

int somaNumeros(int iNumA, int iNumB) {
    if (iNumB == iNumA + 1)
       return iNumA + iNumB;
    else
        return  iNumA + somaNumeros(iNumA + 1, iNumB);
}

Ordene um vetor gerado pelo método quicksort.

/*=============================================================================*
* includes                                                                     *
*=============================================================================*/

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

/*=============================================================================*
* typedef                                                                      *
*=============================================================================*/

struct lista {
       int iNum;
       struct lista *pLista;
};

typedef lista Lista;

/*=============================================================================*
* declaracoes                                                                  *
*==============================================================================*
/*-----------------------------------------------------------------------------*
* declaracoes - prototipos de funcoes                                          *
*-----------------------------------------------------------------------------*/

Lista* insereLista(Lista *, int);
int getTamanhoLista(Lista *);
void ordenaVetor(int *, int, int);
void criaVetor(Lista *, int *);

/*-----------------------------------------------------------------------------*
* funcao "main"                                                                *
*-----------------------------------------------------------------------------*/

int main(int argc, char *argv[]) {
    Lista *pLista = NULL;
    int *pVet = NULL;

    for (int i = 0; i < 10; i++) {
        int iNum = (int) rand() % 10;
        pLista = insereLista(pLista, iNum);
    }

    criaVetor(pLista, pVet);

    system("pause");
}

/*-----------------------------------------------------------------------------*
* corpo das funções - insereLista                                              *
*-----------------------------------------------------------------------------*/

Lista* insereLista(Lista *pLista, int iNum) {
       Lista *pAux = NULL;
       pAux = (Lista *) malloc(sizeof(Lista));
       pAux->iNum = iNum;
       pAux->pLista = pLista;
       return pAux;
}

/*-----------------------------------------------------------------------------*
* corpo das funções - getTamanhoLista                                          *
*-----------------------------------------------------------------------------*/

int getTamanhoLista(Lista *pLista) {
    int iTam = 0;
    Lista *pAux = pLista;
    while (pAux != NULL) {
          iTam++;
          pAux = pAux->pLista;
    }
    return iTam;
}

/*-----------------------------------------------------------------------------*
* corpo das funções - criaVetor                                                *
*-----------------------------------------------------------------------------*/

void criaVetor(Lista *pLista, int *pVet) {
     int iTamLista = 0;
     int i = 0;
     Lista *pAux = pLista;

     iTamLista = getTamanhoLista(pLista);
     pVet = (int *) malloc(sizeof(int) * iTamLista);

     while (pAux != NULL) {
           pVet[i] = pAux->iNum;
           pAux = pAux->pLista;
           i++;
     }

     ordenaVetor(pVet, 0, iTamLista - 1);

     printf("\n\n");
}

/*-----------------------------------------------------------------------------*
* corpo das funções - ordenaVetor                                              *
*-----------------------------------------------------------------------------*/

void ordenaVetor(int *pVet, int iPrim, int iUlt)
{
     int i, j, iMeio, iAux;
     i = iPrim;
     j = iUlt;
     iMeio = pVet[(i + j) / 2];
     do
     {
       while (pVet[i] < iMeio) i++;
       while (pVet[j] > iMeio) j--;
       if (i <= j) {
          iAux = pVet[i];
          pVet[i] = pVet[j];
          pVet[j] = iAux;
          i++;
          j--;
       }
     } while (i <= j);

     if (iPrim < j)
        ordenaVetor(pVet, iPrim, j);
     if (iUlt > i)
        ordenaVetor(pVet, i, iUlt);
}

Transforme uma lista simplesmente encadeada em um vetor. Descubra antes o tamanho da lista para que o vetor possa ser convenientemente alocado.
protótipo: void criaVetor(Lista *L, int *vetor)

/*=============================================================================*
* includes                                                                     *
*=============================================================================*/

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

/*=============================================================================*
* typedef                                                                      *
*=============================================================================*/

struct lista {
       int iNum;
       struct lista *pLista;
};

typedef lista Lista;

/*=============================================================================*
* declaracoes                                                                  *
*==============================================================================*
/*-----------------------------------------------------------------------------*
* declaracoes - prototipos de funcoes                                          *
*-----------------------------------------------------------------------------*/

Lista* insereLista(Lista *pLista, int iNum);
int getTamanhoLista(Lista *pLista);
void criaVetor(Lista *pLista, int *pVet);

/*-----------------------------------------------------------------------------*
* funcao "main"                                                                *
*-----------------------------------------------------------------------------*/

int main(int argc, char *argv[]) {
    Lista *pLista = NULL;
    int *pVet = NULL;

    for (int i = 0; i < 10; i++) {
        int iNum = (int) rand() % 10;
        pLista = insereLista(pLista, iNum);
    }

    criaVetor(pLista, pVet);

    system("pause");
}

/*-----------------------------------------------------------------------------*
* corpo das funções - insereLista                                              *
*-----------------------------------------------------------------------------*/

Lista* insereLista(Lista *pLista, int iNum) {
       Lista *pAux = NULL;
       pAux = (Lista *) malloc(sizeof(Lista));
       pAux->iNum = iNum;
       pAux->pLista = pLista;
       return pAux;
}

/*-----------------------------------------------------------------------------*
* corpo das funções - getTamanhoLista                                          *
*-----------------------------------------------------------------------------*/

int getTamanhoLista(Lista *pLista) {
    int iTam = 0;
    Lista *pAux = pLista;
    while (pAux != NULL) {
          iTam++;
          pAux = pAux->pLista;
    }
    return iTam;
}

/*-----------------------------------------------------------------------------*
* corpo das funções - criaVetor                                                *
*-----------------------------------------------------------------------------*/

void criaVetor(Lista *pLista, int *pVet) {
     int iTamLista = 0;
     int i = 0;
     Lista *pAux = pLista;

     iTamLista = getTamanhoLista(pLista);
     pVet = (int *) malloc(sizeof(int) * iTamLista);

     while (pAux != NULL) {
           pVet[i] = pAux->iNum;
           printf("\nPosicao vetor %d : %d ", i, pVet[i]);
           pAux = pAux->pLista;
           i++;
     }
     printf("\n\n");
}

Procure recursivamente um determinado valor em uma lista simplesmente encadeada. A função recebe o valor (v) e o inicio da lista (*L) como parâmetros e devolve 1 se encontrou o valor, ou 0, caso contrário.

/*=============================================================================*
* includes                                                                     *
*=============================================================================*/

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

/*=============================================================================*
* typedef                                                                      *
*=============================================================================*/

struct lista {
       int iNum;
       struct lista *pLista;
};

typedef lista Lista;

/*=============================================================================*
* declaracoes                                                                  *
*==============================================================================*
/*-----------------------------------------------------------------------------*
* declaracoes - prototipos de funcoes                                          *
*-----------------------------------------------------------------------------*/

Lista* insereLista(Lista *pLista, int iNum);
int procuraItem(Lista *pLista, int iNum);

/*-----------------------------------------------------------------------------*
* funcao "main"                                                                *
*-----------------------------------------------------------------------------*/

int main(int argc, char *argv[]) {
    int iQtdLista = 0, iProcura = 0;
    Lista *pLista = NULL;
    pLista = (Lista *) malloc(sizeof(Lista));

    do {
       printf("\nDigite com quantos numeros deseja preencher a lista: ");
       scanf("%d", &iQtdLista);
       } while (iQtdLista <= 0);

    srand(time(NULL));

    for (int i = 0; i < iQtdLista; i++) {
        int iNum = (int) rand() % 10000;
        printf("\n%d", iNum);
        pLista = insereLista(pLista, iNum);
    }

    printf("\n\nQual numero deseja procurar? ");
    scanf("%d", &iProcura);
    int ret = 100;
    ret = procuraItem(pLista, iProcura);

    if (ret == 1)
       printf("\nNumero encontrado");
    else
        printf("\nNumero nao encontrado");

    printf("\n");

    system("pause");
}

/*-----------------------------------------------------------------------------*
* corpo das funções - insereLista                                              *
*-----------------------------------------------------------------------------*/

Lista* insereLista(Lista *pLista, int iNum) {
       Lista *pAux = NULL;
       pAux = (Lista *) malloc(sizeof(Lista));
       pAux->iNum = iNum;
       pAux->pLista = pLista;
       return pAux;
}

/*-----------------------------------------------------------------------------*
* corpo das funções - procuraItem                                              *
*-----------------------------------------------------------------------------*/

int procuraItem(Lista *pLista, int iNum) {
    if (pLista) {
       if (pLista->iNum == iNum) {
          return 1;
       } else {
              return procuraItem(pLista->pLista, iNum);
              }
    }
}

Leia um arquivo tipo texto e o transforme em uma lista simplesmente encadeada. A função deverá receber um ponteiro para o arquivo já aberto e um ponteiro para uma lista inicializada com NULL.

/*=============================================================================*
* includes                                                                     *
*=============================================================================*/

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

/*=============================================================================*
* define                                                                       *
*=============================================================================*/

#define PATH_LEN 25
#define BUFF_LEN 255

/*=============================================================================*
* typedef                                                                      *
*=============================================================================*/

struct lista {
       int iNum;
       struct lista *pLista;
};

typedef lista Lista;

/*=============================================================================*
* declaracoes                                                                  *
*==============================================================================*
/*-----------------------------------------------------------------------------*
* declaracoes - prototipos de funcoes                                          *
*-----------------------------------------------------------------------------*/

FILE* abreArquivo(char *);
Lista* insereLista(Lista *, int);
void exibeLista(Lista *);

/*-----------------------------------------------------------------------------*
* funcao "main"                                                                *
*-----------------------------------------------------------------------------*/

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

    FILE *pArq = NULL;
    Lista *pLista = NULL;
    char *pPath = NULL;
    char *buff = NULL;

    buff = (char *) malloc(BUFF_LEN * sizeof(char));
    pPath = (char *) malloc(PATH_LEN * sizeof(char));

    printf("Digite o caminho do arquivo: ");
    scanf("%s", pPath);

    pArq = abreArquivo(pPath);
    if (pArq) {
       do {
          fgets(buff, BUFF_LEN, pArq);
          pLista = insereLista(pLista, atoi(buff));
          }
       while (!feof(pArq));
       printf("\n*** Lista ***\n\n");
       exibeLista(pLista);
    }
    else {
    printf("\nError");
    }
    system("pause");
    return 0;
}

/*-----------------------------------------------------------------------------*
* corpo das funções - abreArquivo                                              *
*-----------------------------------------------------------------------------*/

FILE* abreArquivo(char *pPath) {
      FILE* pArq = NULL;
      pArq = fopen(pPath, "r");
      if (pArq)
         return pArq;
      else
          return NULL;
}

/*-----------------------------------------------------------------------------*
* corpo das funções - insereLista                                              *
*-----------------------------------------------------------------------------*/

Lista* insereLista(Lista *pLista, int iNum) {
       Lista *pAux = NULL;
       pAux = (Lista *) malloc(sizeof(Lista));
       pAux->iNum = iNum;
       pAux->pLista = pLista;
       return pAux;
}

/*-----------------------------------------------------------------------------*
* corpo das funções - exibeLista                                            *
*-----------------------------------------------------------------------------*/

void exibeLista(Lista *pLista) {
     Lista *pAux = NULL;
     pAux = pLista;
     while (pAux != NULL) {
           printf("\n %d", pAux->iNum);
           pAux = pAux->pLista;
     }
     return;
}

Grave o conteúdo do vetor gerado no item 1, num arquivo tipo texto, sendo um número por linha. O nome do arquivo será solicitado pela função.

/*=============================================================================*
* includes                                                                     *
*=============================================================================*/

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

/*=============================================================================*
* declaracoes                                                                  *
*==============================================================================*
/*-----------------------------------------------------------------------------*
* declaracoes - prototipos de funcoes                                          *
*-----------------------------------------------------------------------------*/

void preencheVetor(int iNum, int *iVetor);

/*-----------------------------------------------------------------------------*
* funcao "main"                                                                *
*-----------------------------------------------------------------------------*/

int main(int argc, char *argv[]) {
    int iNum;
    printf("Digite um numero: \n");
    scanf("%d", &iNum);
    int *iVet = (int *)malloc(sizeof(int) * iNum);
    preencheVetor(iNum, iVet);
    printf("\n");
    for (int i = 0; i < iNum; i++)
        printf("\n %d ", iVet[i]);
    system("pause");

    return 0;
}

/*-----------------------------------------------------------------------------*
* corpo das funções - preencheVetor                                            *
*-----------------------------------------------------------------------------*/

void preencheVetor(int iNum, int *iVetor) {
     FILE *pArq;
     char *cPath = (char *) malloc(50 * sizeof(char));
     printf("Digite o caminho do arquivo: ");
     scanf("%s", cPath);
     pArq = fopen(cPath,"w+");
     if (pArq) {
        int iAux, iFlag = 0;
        srand(time(NULL));
        for (int i = 0; i < iNum; i++) {
            iAux = (int) rand() % 100;
            for (int j = 0; j < i; j++) {
                if (iAux == iVetor[j])
                   iFlag = 1;
            }
            if (iFlag != 1){
               iVetor[i] = iAux;
               fprintf(pArq,"%d\n", iVetor[i]);
            }
            else
                i--;
            iFlag = 0;
        }
     }
     fclose(pArq);
}

Preencha um vetor de tamanho n com números inteiros aleatórios sem repetição.
protótipo: void preencheVetor(int n, int *v) *

/*=============================================================================*
* includes                                                                     *
*=============================================================================*/

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

/*=============================================================================*
* declaracoes                                                                  *
*==============================================================================*
/*-----------------------------------------------------------------------------*
* declaracoes - prototipos de funcoes                                          *
*-----------------------------------------------------------------------------*/

void preencheVetor(int iNum, int *iVetor);

/*-----------------------------------------------------------------------------*
* funcao "main"                                                                *
*-----------------------------------------------------------------------------*/

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

    int iNum;
    printf("Digite um numero: \n");
    scanf("%d", &iNum);
    int *iVet = (int *)malloc(sizeof(int) * iNum);
    preencheVetor(iNum, iVet);
    printf("\n");
    for (int i = 0; i < iNum; i++)
        printf("\n %d ", iVet[i]);
    system("pause");

    return 0;

}
/*-----------------------------------------------------------------------------*
* corpo das funções - preencheVetor                                            *
*-----------------------------------------------------------------------------*/

void preencheVetor(int iNum, int *iVetor) {
     int iAux, iFlag = 0;
     srand(time(NULL));
     for (int i = 0; i < iNum; i++) {
          iAux = (int) rand() % 100;
          for (int j = 0; j < i; j++) {
              if (iAux == iVetor[j])
                 iFlag = 1;
          }
     if (iFlag != 1)
        iVetor[i] = iAux;
     else
         i--;
     iFlag = 0;
     }
}

List<String> lista = new ArrayList<String>();

lista.add("oi");
lista.add("ola");
lista.add("hey!");

for (String str : lista)
     System.out.println(str);

Primeiro passo: Obtendo o Ubuntu

Existe duas maneiras de conseguir a distribuição do Ubuntu. A primeira dela é fazendo o download em algum mirror. Para realizar o download, você pode visitar este link do site ubuntu-br. A segunda opção é solicitar um CD, totalmente de graça no site oficial.

Segundo passo: Instalando o Ubuntu

Para instalar o Ubuntu junto com o seu Windows, basta seguir dois passos extremamente simples. Primeiramente emule o iso do Ubuntu, ou rode o CD. Clique na opção Instalar no Windows. Logo em seguida, abrirá uma janela perguntando em qual partição deseja instalar, e qual o espaço que deseja reservar. Clique em OK e PRONTO. Agora é só esperar a instalação terminar e pronto, seu computador já estará rodando tanto o Windows quando o Ubuntu! Quando você for inicializar o computador, abrirá uma opção perguntando qual dos sistemas operacionais desejará inicializar.

Caso deseje desinstalar o Ubuntu, basta fazer igual a qualquer outro programa. Vá em Painel de Controle, Adicionar ou Remover Programas e selecione o Ubuntu.

Simples e fácil.

Espero ter ajudado.

Links úteis:

Ubuntu: www.ubuntu.com
Ubuntu-Br: www.ubuntu-br.org
Ubuntu Geek: www.ubuntugeek.com.br
Viva o Linux: www.vivaolinux.com.br