Algortima Chipper dalam java

import java.util.LinkedHashSet;
import java.util.Set;

public class Chiper {
  //baris alphabet acuan
  private  String  alp  =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv
wxyz0123456789 .,?!@()-_=+";//,./';[]!@#$%^&*()_+-=<>?\"{}`~\\ 
  //key  bawaan  aplikasi,  digunakan  di  inisialisasi  jika  key  yang digunakan bukan bawaan aplikasi
  private String key = "<oGHsoienJGDdop90?>";
  //panjang alphabet, digunakan untuk penggeseran dan modulus alphabet
  private int alen = this.alp.length();
  
  //constructor umum
  public Chiper(){
    this.adjustKeyWord();
  }
  
  public Chiper(String phone){
    if(!phone.equals(""))
      this.key = this.mixKeyword(phone);
    
    this.adjustKeyWord();
  }
  
  //constructor dengan keyword custom
  public Chiper(String phone,String keyword){
    if(!phone.equals(""))
      this.key = this.mixKeyword(phone);
    
    if(!keyword.equals(""))
      this.key = this.mixKeyword(keyword);
    
    this.adjustKeyWord();
  }
  
  //constructor dengan baris abjad custom dan keyword custom
  public Chiper(String phone,String keyword,String alphabet){
    this.alp = alphabet;
    this.alen = this.alp.length();
    
    if(!phone.equals(""))
      this.key = this.mixKeyword(phone);
    
    if(!keyword.equals(""))
      this.key = this.mixKeyword(keyword);
    
    this.adjustKeyWord();
  }
  //fungsi mixing 2 string keyword
  private String mixKeyword(String keyword) {
    String rkey = "";
    
    int lbk = this.key.length();
    int lik = keyword.length();
    
    int tnk = lbk>lik ? lbk : lik ;
    
    for(int i = 0;i<tnk;i++){
      if(i<lbk)
        rkey += this.key.charAt(i);
      if(i<lik)
        rkey += keyword.charAt(i);
    }
    
    return rkey;
    
  }
  
  private void adjustKeyWord(){
    this.key = adjustKeyWord(this.key);
  }
  
  //fungsi adjustment key memastikan 1 buah char/g ad yg sama
  private String adjustKeyWord(String keyword) {
    String kw = "";
    Set<Character>  keyChars  =  new
LinkedHashSet<Character>(keyword.length());
    for(char c : keyword.toCharArray()){
      if((alp.indexOf(c)  !=  -1)  &&
keyChars.add(c)){
        kw += String.valueOf(c);
      }
    }
    //Log.i("keyword",kw);
    
    return kw;

  }
  
  //fungsi fibonanci key
  private void getFibonanciKey(int llen,int klen,String line){
    //selisih panjang kalimat dengan panjang key
    int loss = llen - klen;
    //Log.i("loss",String.valueOf(loss));
    //rumus fibonanci
    int mt = 1;
    for (char c : this.key.toCharArray()){
      mt += this.alp.indexOf(c);
    }
    mt %= klen;
    //Log.i("loss",String.valueOf(mt));
    //END rumus fibonanci
    String temkey = this.key;
    while(temkey.length()<llen){
      temkey += this.key;
    }
    //Log.i("repeater",temkey);
    
    String holder = "";
    int tmp2;
    for(int i=0;i<loss;i++){
      
      tmp2  =  this.alp.indexOf(temkey.charAt(i))  + this.alp.indexOf(temkey.charAt(i+mt));
      tmp2 += this.alen;
      tmp2 %= this.alen;
      holder += this.alp.charAt(tmp2);
    }
    
    this.key = mixKeyword(holder);
    //Log.i("keywordFibo",this.key);
    //return this.key;
  }

Vigenere Chipper dalam Java

adalah : metode menyandikan teks alfabet
dengan menggunakan deretan sandi Caesar berdasarkan huruf-huruf pada kata kunci.

Sandi Vigenère merupakan bentuk sederhana dari sandi substitusipolialfabetik.

Sebagai berikut coding di atas:

package lp2maray.com;

public class vc{

String enkripsi(String p,String k){
String l="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#&%*()-_=:,.'?/$^ ";
    int pms=l.length();
    int pln=p.length();
    int ky=k.length();
   
        String     y =k;
        int m = pln%ky;
            for( int i=1; i<pln/ky ; i++){k=k+y;}
            k=k+k.substring(0,m);   
String c="";   
for (int j=0; j<pln; j++ ){
    char hsl=l.charAt((l.indexOf(k.charAt(j)) + l.indexOf(p.charAt(j)))%pms);
    c=c + l.charAt((l.indexOf(k.charAt(j)) + l.indexOf(p.charAt(j)))%pms);
    }
return c;
}
           
//==================================================================================
String dekripsi(String p,String k){
String l="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#&%*()-_=:,.'?/$^ ";
    int pms=l.length();
    int cpr=p.length();
    int ky=k.length();
   
    String     y =k;
        int m = cpr%ky;
            for( int i=1; i<cpr/ky ; i++){k=k+y;}
            k=k+k.substring(0,m);   
String pl = "";       
for (int j=0; j<cpr; j++ ){
    char hsl=l.charAt(((l.indexOf(p.charAt(j)) - l.indexOf(k.charAt(j))) +pms )%pms);
    pl=pl + hsl;
    }   
return pl;
}
//==================================================================================   
}

Algoritma Kompressi data Huffman

IMPLEMENTASI KOMPRESI DAN ENKRIPSI DATA
DENGAN METODE HUFFMAN CODE
DALAM APLIKASI MOBILE

Riadi Marta Dinata.

Email: adiarray@yahoo.com

Abstrak
Penerapan metode kompresi pada saat pengiriman pesan teks melalui layanan SMS dapat
mengurangi biaya kirim pesan. Dua hingga tiga buah pesan dapat dikompres menjadi hanya satu pesan
sehingga biaya yang dibutuhkan untuk mengirim satu buah pesan saja. Metode kompresi yang akan digunakan adalah
Algoritma huffman
.
Pengiriman pesan akan tetap menggunakan layanan SMS sebagai sarana pengiriman dan penerimaan
pesan, sehingga otomatis juga harus ada program untuk mengkompre

PENDAHULUAN

Dengan pesatnya perkembangan teknologi seluler dan semakin maraknya persaingan di bidang seluler, maka setiap operator dan vendor seluler berlomba-lomba memberikan fasilitas yang terbaik dengan tujuan mendapatkan pelanggan sebanyak-banyaknya.
Salah satu fasilitas yang merupakan menu wajib yang disertakan oleh setiap operator seluler adalah fasilitas Short Message Service yang biasa disingkat dengan istilah SMS. SMS merupakan menu yang relatif paling dibutuhkan dan paling sering dipergunakan oleh setiap pelanggan seluler untuk menyampaikan suatu pesan, karena biaya yang digunakan lebih murah jika dibandingkan dengan langsung menelepon ke nomor tertentu.

Namun ada satu hal yang selama ini masih dilupakan oleh para operator seluler yaitu jumlah karakter per SMS sangat terbatas, hanya 160 karakter per SMS padahal biaya per SMS lumayan mahal.
Kompresi merupakan suatu hal penting dalam teknologi informasi. Proses kompresi merupakan proses untuk memperkecil bit tiap karakter sehingga memungkinkan  untuk menampung lebih dari 160 karakter untuk sekali SMS. Bahkan jika simbol-simbol tertentu tidak diikutsertakan pada penulisan SMS dan hanya menggunakan satu jenis tulisan saja, seperti penulisan SMS hanya menggunakan huruf kapital semua atau huruf kecil semua, maka SMS bisa dikompresi dengan hasil yang lebih baik, namun hal ini tergantung dengan karakter-karakter yang digunakan dalam menulis SMS. Hal ini tentu sangat menguntungkan bagi pelanggan karena selama ini jumlah karakter per SMS hanya 160 karakter.

Kode Huffman
Kode Huffman adalah algoritma yang menggunakan frekuensi/probabilitas kemunculan dari simbol pada sebuah string sebagai input dan menghasilkan output berupa prefix code yang mengkodekan string menggunakan bit paling sedikit dari seluruh kemungkinan binary prefix code yang mungkin. Algoritma ini dikembangkan oleh David A. Huffman pada paper yang ditulisnya sebagai prasyarat kelulusannya di MIT.
Kode Huffman salah satu algoritma dasar untuk kompresi data, yang bertujuan untuk mengurangi jumlah bit yang diperlukan untuk merepresentasikan informasi/pesan.

Dari Kamus atau daftar huffman yang sudah tersedia ditambahkan awalan dan diikuti dengan badannya. Untuk huruf kecil, yang harusnya sering digunakan, awalannya 0.
Sedang untuk Kurasa huruf besar digunakan  awalan 100.
Angka dan beberapa simbol diberiawalan 111, tanda baca umum 110, spasi 1011, dan khusus huruf kecil 'e' jadi 1010. Sisanya (simbol langka, Unicode lainnya), diberi awalan 1111110 diikuti kode char aslinya 16 bit. Awalan dan badan digabung, menghasilkan ubahan.



Gambar 1.1 Tabel Kamus Huffan 0, 100,  ada di atas







Gambar 1.3 Tabel Kamus Huffan 101 dan 110

Dari table yang di dapat, dimisalkan data yang akan dikompresi adalah kalimat sbb:
“HALO APA KABAR”
semuanya capital !

gambar 1.4 Scanning Karakter ke Huffam Kode

Gambar 1.5 Merubah Kode Huffan menjadi String

Gambar 1.6 Proses Dekompressi

Gambar 1.7 Proses Dekompressi

Kesimpulan
Contoh Kompressi data :
“HALO APA KABAR”
14 karakter x 8 bit = 112 bit => dikonfersi ke Huffman=>97 karakter=>13 byte
ratio: 13/14=>100%-90%=10%
Hasil kompressi akan lebih kecil lagi, jika menggunakan huruf kecil dan menghindari penggunaan huruf yang memiliki kode huffamn panjang.

sebagai berikut adalah coding masternya...silakan di modifikasi kembali untuk android, blackberry, iphone, web atau lainnya......

import java.io.PrintStream;
public class Huffman{
    public Huffman(){}
    static void init(){
        if(udahInit){return;}
        else{
            udahInit = true;
            cc[32] = "1011";
            cc[33] = "1100011";
            cc[34] = "1100110";
            cc[39] = "1100100";
            cc[40] = "11111010";
            cc[41] = "11111011";
            cc[44] = "1100001";
            cc[45] = "1100101";
            cc[46] = "1100000";
            cc[47] = "1111011";
            cc[48] = "1110000";
            cc[49] = "1110001";
            cc[50] = "1110010";
            cc[51] = "1110011";
            cc[52] = "1110100";
            cc[53] = "1110101";
            cc[54] = "1110110";
            cc[55] = "1110111";
            cc[56] = "1111000";
            cc[57] = "1111001";
            cc[58] = "1111100";
            cc[63] = "1100010";
            cc[64] = "1111010";
            cc[65] = "1000000";
            cc[66] = "10000101";
            cc[67] = "1001101";
            cc[68] = "10001011";
            cc[69] = "1100111";
            cc[70] = "10011001";
            cc[71] = "10010101";
            cc[72] = "1001000";
            cc[73] = "1000001";
            cc[74] = "100110001001";
            cc[75] = "1001100011";
            cc[76] = "1001001";
            cc[77] = "10010100";
            cc[78] = "1000110";
            cc[79] = "1000100";
            cc[80] = "10010110";
            cc[81] = "1001100010000";
            cc[82] = "1000111";
            cc[83] = "1000011";
            cc[84] = "100111";
            cc[85] = "10010111";
            cc[86] = "1000101001";
            cc[87] = "1000101000";
            cc[88] = "10011000101";
            cc[89] = "10000100";
            cc[90] = "1001100010001";
            cc[97] = "00000";
            cc[98] = "000101";
            cc[99] = "01101";
            cc[100] = "001011";
            cc[101] = "1010";
            cc[102] = "011001";
            cc[103] = "010101";
            cc[104] = "01000";
            cc[105] = "00001";
            cc[106] = "0110001001";
            cc[107] = "01100011";
            cc[108] = "01001";
            cc[109] = "010100";
            cc[110] = "00110";
            cc[111] = "00100";
            cc[112] = "010110";
            cc[113] = "01100010000";
            cc[114] = "00111";
            cc[115] = "00011";
            cc[116] = "0111";
            cc[117] = "010111";
            cc[118] = "00101001";
            cc[119] = "00101000";
            cc[120] = "011000101";
            cc[121] = "000100";
            cc[122] = "01100010001";
            return;
        }
    }

    static String huffmanSisanya(char kar){
        String s = Integer.toBinaryString(kar);
        s = "0000000000000000".substring(0, 16 - s.length()) + s;
        return ccSISANYA + s;
    }

    static byte[] stringKeByteA(String st){
        int lenAsli = st.length();
        st = st + "11111111";
        byte hs[] = new byte[(lenAsli + 7) / 8];
        for(int i = 0; i < lenAsli; i += 8)
        {
            String sebyte = st.substring(i, i + 8);
            byte b = (byte)Integer.parseInt(sebyte, 2);
            hs[i / 8] = b;
        }

        return hs;
    }

    static String byteAKeString(byte ba[]){
        String hs = "";
        for(int i = 0; i < ba.length; i++){
            int b = ba[i];
            if(b < 0)
                b += 256;
            String tp = Integer.toBinaryString(b);
            tp = "00000000".substring(0, 8 - tp.length()) + tp;
            hs = hs + tp;
        }

        return hs;
    }

    public static byte[] huffman(String st){
        init();
        String jadi = "";
        for(int i = 0; i < st.length(); i++)
        {
            char kar = st.charAt(i);
            if(kar >= '\200')
                jadi = jadi + huffmanSisanya(kar);
            else
            if(cc[kar] != null)
                jadi = jadi + cc[kar];
            else
                jadi = jadi + huffmanSisanya(kar);
        }

        return stringKeByteA(jadi);
    }

    static int cariKar(String buf)
    {
        if(buf.length() > 23)
            return -2;
        if(buf.length() == 23 && buf.substring(0, 7).equals(ccSISANYA))
            return Integer.parseInt(buf.substring(7), 2);
        for(int i = 0; i < 128; i++)
            if(cc[i] != null && cc[i].equals(buf))
                return i;

        return -1;
    }

    public static String dehuffman(byte ba[])
    {
        init();
        String st = byteAKeString(ba);
        String hs = "";
        String buf = "";
        for(int i = 0; i < st.length(); i++)
        {
            char kar = st.charAt(i);
            buf = buf + kar;
            int c = cariKar(buf);
            if(c >= 0)
            {
                buf = "";
                hs = hs + (char)c;
            } else
            if(c == -2)
                buf = "";
        }

        return hs;
    }



}