Informe um valor inteiro: 8
O valor 8 é potência de dois
Informe um valor inteiro: 34
O valor 34 não é potência de dois
Informe um valor inteiro: 64
O valor 64 é potência de dois

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

// função que recebe um número inteiro e informe se ele é
// potência de dois
int is_potencia_dois(int n){
  // usamos o operador AND de bits para verificar se n AND n-1
  // é igual a 0
  return (n > 0) && (n & (n - 1)) == 0;
}

int main(int argc, char *argv[]){
  // variáveis usadas para 
  int valor;
  
  setlocale(LC_ALL,""); // para acentos do português
 
  // vamos pedir para o usuário informar um valor inteiro
  printf("Informe um valor inteiro: ");
  scanf("%d", &valor);
    
  // vamos testar se o número informado é potência de dois
  if(is_potencia_dois(valor)){
    printf("O valor %d é potência de dois", valor);
  }
  else{
    printf("O valor %d não é potência de dois", valor);
  }
 
  printf("\n\n");
  system("PAUSE");	
  return 0;
}

Informe o valor do primeiro elemento: 5

Os elementos do vetor são:

5  10  20  40  80

using System;

namespace Estudos {
  class Principal {
    // função principal do programa C#
    static void Main(string[] args) {
      // vamos declarar e construir um vetor de inteiros
      // de 5 elementos
      int[] valores = new int[5];

      // agora vamos pedir para o usuário informar o
      // valor do primeiro elemento
      Console.Write("Informe o valor do primeiro elemento: ");
      valores[0] = Int32.Parse(Console.ReadLine());

      // agora vamos gerar os valores dos próximos elementos
      for (int i = 1; i < valores.Length; i++) {
        // recebe o elemento anterior multiplicado por 2
        valores[i] = valores[i - 1] * 2;
      }

      // e agora mostramos o vetor gerado
      Console.WriteLine("\nOs elementos do vetor são:\n");
      for (int i = 0; i < valores.Length; i++) {
        Console.Write(valores[i] + "  ");
      }

      Console.WriteLine("\n\nPressione uma tecla para sair...");
      Console.ReadKey();
    }
  }
}

package estudosbancodados;

import java.lang.reflect.Field;
import java.sql.*;
import java.util.HashMap;
import java.util.Map;

public class EstudosBancoDados{
  static Map mapa; // usado para mapear os tipos JDBC
  
  public static void main(String[] args) {
    // strings de conexão
    String databaseURL = "jdbc:mysql://localhost/estudos";
    String usuario = "root";
    String senha = "osmar1234";
    String driverName = "com.mysql.jdbc.Driver";

    try {
      Class.forName(driverName).newInstance();
      Connection conn = DriverManager.getConnection(databaseURL, usuario, senha);

      // vamos obter um objeto da classe com.mysql.jdbc.DatabaseMetaData
      DatabaseMetaData dbmd = conn.getMetaData();

      // vamos obter os tipos de dados suportados por esta versão do MySQL
      // e seus correspondentes JDBC
      ResultSet tiposDados = dbmd.getTypeInfo();
      while(tiposDados.next()){
        System.out.println("MySQL: " + tiposDados.getString("TYPE_NAME") + " - JDBC: " 
          + getJdbcTypeName(Integer.parseInt(tiposDados.getString("DATA_TYPE"))));
      }
      
      // vamos fechar o ResultSet
      tiposDados.close();
    }
    catch (SQLException ex) {
      System.out.println("SQLException: " + ex.getMessage());
      System.out.println("SQLState: " + ex.getSQLState());
      System.out.println("VendorError: " + ex.getErrorCode());
    }
    catch (Exception e) {
      System.out.println("Problemas ao tentar conectar com o banco de dados: " + e);
    }
  }

  // Este método retorna o nome de um tipo JDBC
  // O retorno é null se o tipo JDBC não puder ser reconhecido
  public static String getJdbcTypeName(int jdbcType){
    // vamos usar reflection para mapear valores inteiros a seus nomes
    if(mapa == null) {
      mapa = new HashMap();

      // vamos obter todos os campos da classe java.sql.Types
      Field[] campos = java.sql.Types.class.getFields();
      
      // vamos percorrer os campos
      for(int i = 0; i < campos.length; i++){
        try{
          // vamos obter o nome do campo
          String nome = campos[i].getName();

          // vamos obter o valor do campo
          Integer valor = (Integer)campos[i].get(null);

          // vamos adicionar ao mapa
          mapa.put(valor, nome);
        }
        catch(IllegalAccessException e){
          System.out.println("Ops: " + e.getMessage());
        }
      }
    }

    // vamos retornar o nome do tipo JDBC
    return (String)mapa.get(new Integer(jdbcType));
  }
}

package estudos;

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class Estudos{
  public static void main(String[] args) {
    // primeiro conjunto
    Set<Integer> conjuntoA = new TreeSet<>();
    conjuntoA.add(2);
    conjuntoA.add(5);
    conjuntoA.add(8);
    conjuntoA.add(19);
    conjuntoA.add(30);
    
    // segundo conjunto
    Set<Integer> conjuntoB = new TreeSet<>();
    conjuntoB.add(2);
    conjuntoB.add(3);
    conjuntoB.add(1);
    conjuntoB.add(30);
    
    // vamos obter a interseção dos dois conjuntos      
    Set<Integer> conjuntoC = intersecao(conjuntoA, conjuntoB);        
    
    // vamos exibir os elementos no conjunto C
    Iterator iterator = conjuntoC.iterator();
    while(iterator.hasNext()){
      System.out.println(iterator.next());
    }
  }
  
  // método genérico que permite obter a interseção de dois conjuntos
  public static <T> Set<T> intersecao(Set<T> conjA, Set<T> conjB){
    Set<T> conjC = new TreeSet<>();
    // percorremos todos os elementos do conjunto A
    for(T elemento: conjA){
      // e verificamos se o elemento está contido no conjunto B
      if(conjB.contains(elemento)){
        conjC.add(elemento); // se estiver contido nós o adicionamos no conjunto C 
      }
    }
    
    return conjC; // e retornamos o conjunto C
  }
}