Pages,pages

Selasa, 13 Maret 2012

 TOWER OF HANOI

Rekursi

Secara sederhana, rekursi adalah ketika fungsi memanggil dirinya sendiri. Artinya, dalam definisi fungsi ada panggilan untuk fungsi yang sama. Pada awalnya ini mungkin tampak seperti sebuah loop tidak pernah berakhir, atau seperti anjing mengejar ekornya. Tidak pernah dapat menangkapnya. Demikian juga tampaknya metode kami tidak akan pernah selesai. Ini mungkin benar adalah beberapa kasus, tetapi dalam prakteknya kita dapat memeriksa untuk melihat apakah kondisi tertentu adalah benar dan keluar dalam kasus (kembali dari) metode kami. Kasus di mana kita berakhir rekursi kita disebut kasus dasar. Selain itu, seperti dalam satu lingkaran, kita harus mengubah beberapa nilai dan incremently maju lebih dekat dengan kasus dasar kita.Pertimbangkan fungsi ini.kekosongan myMethod (int counter){jika (counter == 0)
     
kembali;lain
       
{
       
System.out.println ("" + counter);
       
myMethod (- counter);
       
kembali;
       
}}Rekursi ini tidak tak terbatas, dengan asumsi metode ini melewati nilai integer positif. Apa yang akan menjadi output?Pertimbangkan metode ini:kekosongan myMethod (int counter){jika (counter == 0)
     
kembali;lain
       
{
       
System.out.println ("hello" + counter);
       
myMethod (- counter);
       
System.out.println ("" + counter);
       
kembali;
       
}}Jika metode ini disebut dengan nilai 4, apa yang akan menjadi output? Jelaskan.Rekursi di atas pada dasarnya adalah sebuah loop seperti untuk loop atau while loop. Kapan kita lebih memilih rekursi untuk loop berulang? Kami menggunakan rekursi ketika kita bisa melihat bahwa masalah kita dapat direduksi menjadi masalah sederhana yang bisa diselesaikan setelah pengurangan lebih lanjut.Setiap rekursi harus memiliki karakteristik berikut.

   
1. Sebuah kasus sederhana dasar yang kami punya solusi untuk dan nilai kembali.
   
2. Cara mendapatkan masalah kita lebih dekat dengan kasus dasar. Yakni cara untuk memotong keluar bagian dari masalah untuk mendapatkan masalah agak sederhana.
   
3. Sebuah panggilan rekursif yang melewati masalah sederhana kembali ke metode.Kunci untuk berpikir secara rekursif adalah untuk melihat solusi untuk masalah sebagai versi kecil dari masalah yang sama. Kunci untuk memecahkan persyaratan pemrograman rekursif adalah membayangkan bahwa metode Anda melakukan apa yang namanya mengatakan hal ini bahkan sebelum Anda benar-benar selesai menulisnya. Anda harus berpura-pura metode melakukan tugasnya dan kemudian menggunakannya untuk memecahkan kasus yang lebih kompleks. Berikut adalah cara.Mengidentifikasi kasus dasar (s) dan apa kasus dasar (s) lakukan. Sebuah kasus dasar adalah masalah yang paling sederhana mungkin (atau kasus) metode Anda dapat berlalu. Mengembalikan nilai yang benar untuk kasus dasar. Metode rekursif Anda kemudian akan terdiri dari pernyataan jika-lain di mana kasus dasar mengembalikan satu nilai dan kasus non-basa (s) secara rekursif hubungi (s) metode yang sama dengan parameter yang lebih kecil atau set data. Dengan demikian Anda menguraikan masalah Anda menjadi dua bagian: (1) Kasus yang paling sederhana mungkin yang Anda dapat menjawab (dan imbalan), dan (2) semua kasus yang lebih kompleks lain yang Anda akan menyelesaikan dengan mengembalikan hasil dari panggilan kedua metode Anda . Ini panggilan kedua metode Anda (rekursi) akan menyampaikan masalah kompleks tapi dikurangi dengan satu kenaikan. Ini dekomposisi masalah benar-benar akan menjadi solusi, lengkap akurat untuk masalah untuk semua kasus selain kasus dasar. Dengan demikian, kode metode ini sebenarnya memiliki solusi pada rekursi pertama.Mari kita pertimbangkan untuk menulis suatu metode untuk mencari faktorial dari integer. Misalnya 7! sama dengan 7 * 6 * 5 * 4 * 3 * 2 * 1.Tapi kita juga benar jika kita mengatakan 7! sama dengan 7 * 6!.Dalam melihat faktorial dari 7 di cara kedua kita telah mendapatkan pemahaman yang berharga. Kita sekarang dapat melihat masalah kita dalam hal versi sederhana dari masalah kami dan kami tahu bagaimana membuat masalah kita semakin lebih sederhana. Kami juga telah mendefinisikan masalah kita dalam hal itu sendiri. Yakni kita mendefinisikan 7! dalam hal 6!. Ini adalah inti dari masalah rekursif pemecahan. Sekarang yang kita miliki untuk lakukan adalah memutuskan apa kasus dasar. Apakah faktorial sederhana? 1!. 1! sama dengan 1.Mari kita menulis fungsi faktorial secara rekursif.int myFactorial (integer int){if (bilangan bulat == 1)
     
mengembalikan 1;lain
       
{
       
kembali (integer * (myFactorial (integer-1);
       
}}Perhatikan bahwa kasus dasar (faktorial dari 1) diselesaikan dan nilai kembali diberikan. Sekarang mari kita bayangkan bahwa metode kami benar-benar bekerja. Jika berhasil kita dapat menggunakannya untuk memberikan hasil kasus yang lebih kompleks. Jika nomor kami adalah 7 kita akan kembali 7 * hasil faktorial dari 6. Jadi kita actaully memiliki jawaban yang tepat untuk semua kasus di rekursi tingkat atas. Masalah kita semakin kecil pada setiap panggilan rekursif karena setiap kali kita memanggil metode kami memberikan jumlah yang lebih kecil. Coba jalankan program ini di kepala Anda dengan nomor 2. Apakah itu memberikan nilai yang benar? Jika berhasil untuk 1 maka harus bekerja selama dua sejak 2 hanya mengembalikan 2 * faktorial 1. Sekarang akan bekerja untuk 3? Nah, 3 harus kembali 3 * faktorial 2. Sekarang karena kita tahu bahwa faktorial 2 karya, faktorial dari 3 juga bekerja. Kami dapat membuktikan bahwa 4 karya dengan cara yang sama, dan seterusnya dan sebagainya.Bahan untuk dipikirkan: bertanya pada diri sendiri, ini bisa ditulis iteratif?Catatan: biasakan Anda menulis kasus dasar dalam metode sebagai pernyataan pertama.Catatan: Melupakan kasus dasar menyebabkan rekursi tak terbatas.Namun, pada kenyataannya, kode Anda tidak akan berjalan selamanya seperti infinite loop, sebagai gantinya, Anda akhirnya akan kehabisan ruang stack (memori) dan mendapatkan error run-time atau pengecualian yang disebut stack overflow. Ada masalah yang berarti beberapa dengan rekursi. Sebagian besar sulit (terutama untuk programmer berpengalaman) untuk berpikir secara rekursif, meskipun banyak AI spesialis mengatakan bahwa dalam rekursi kenyataan lebih dekat dengan dasar proses berpikir manusia daripada metode pemrograman lainnya (seperti iterasi). Ada juga ada masalah stack overflow ketika menggunakan beberapa bentuk rekursi (rekursi kepala.) Masalah utama lainnya dengan rekursi adalah bahwa hal itu dapat lebih lambat untuk menjalankan dari iterasi sederhana. Lalu mengapa menggunakannya? Tampaknya selalu ada solusi iteratif untuk setiap masalah yang dapat diselesaikan secara rekursif. Apakah ada perbedaan dalam kompleksitas komputasi? Tidak.Apakah ada perbedaan dalam efisiensi eksekusi? Ya, pada kenyataannya, versi rekursif biasanya kurang efisien karena harus mendorong dan dan recursions pop dan mematikan tumpukan run-time, sehingga iterasi akan lebih cepat. Di sisi lain, Anda mungkin melihat bahwa versi rekursif menggunakan variabel lokal lebih sedikit atau tidak ada.Jadi mengapa menggunakan rekursi? Jawaban atas pertanyaan kita adalah terutama karena lebih mudah untuk kode solusi rekursif sekali seseorang dapat mengidentifikasi solusi itu. Kode rekursif biasanya lebih kecil, lebih ringkas, lebih elegan, bahkan mungkin lebih mudah untuk memahami, meskipun itu tergantung pada yang berpikir gaya. Tetapi juga, ada beberapa masalah yang sangat sulit untuk memecahkan tanpa rekursi. Masalah-masalah yang membutuhkan mundur seperti mencari labirin untuk jalan ke pintu keluar atau operasi berbasis pohon (yang akan kita lihat dalam semester 2) sebaiknya diselesaikan secara rekursif. Ada juga beberapa algoritma sorting yang menarik yang menggunakan rekursi. 


Towers of Hanoi

Masalah ini berasal dari sejarah, para biksu di Vietnam juga diminta membawa 64 disk emas dari satu menara (stack) yang lain. Setiap disk adalah ukuran yang berbeda. Ada 3 tumpukan, setumpuk sumber, setumpuk tujuan dan stack menengah. Sebuah disk yang ditempatkan pada salah satu dari tiga tumpukan tapi tidak ada disk dapat ditempatkan di atas sebuah disk lebih kecil. Menara sumber memegang 64 disk. Bagaimana para biksu mengatasi masalah ini? Berapa lama waktu yang dibutuhkan mereka?Solusi termudah adalah satu rekursif. Kunci solusinya adalah dengan melihat bahwa untuk memindahkan disk apapun, kita harus terlebih dahulu memindahkan disk lebih kecil dari itu, sehingga definisi rekursif. Cara lain untuk melihatnya adalah ini, jika kita memiliki metode untuk memindahkan tiga disk atas ke posisi tengah, kita bisa menempatkan disk terbesar di tempatnya. Semua yang perlu kita lakukan adalah menganggap kita memiliki metode ini dan kemudian menyebutnya.Mari kita mulai dengan 1 disk (kasus dasar kami): Pindahkan 1 disk dari menara awal ke menara tujuan dan kita selesai.Untuk memindahkan 2 disk:Pindahkan disk lebih kecil dari menara awal sampai menengah menara, memindahkan disk yang lebih besar dari menara awal ke menara akhir, memindahkan disk lebih kecil dari menara ke menara menengah akhir dan kita selesai.Untuk memindahkan disk n (atau berpikir, katakanlah, 3 disk):Memecahkan masalah untuk n - 1 disk (yaitu 2 disk) dengan menggunakan menara menengah bukan menara akhir (yaitu mendapatkan 2 disk ke menara menengah). Kemudian, pindahkan disk terbesar dari menara awal ke menara akhir. Kemudian lagi memecahkan masalah untuk n - 1 disk tapi menggunakan menara menengah bukan menara awal (yaitu mendapatkan 2 disk ke menara akhir menggunakan menara awal sebagai menara menengah). 


Tail Rekursi

Rekursi ekor didefinisikan sebagai yang terjadi ketika panggilan rekursif adalah pada akhir instruksi rekursif. Ini tidak terjadi dengan solusi faktorial saya di atas. Hal ini berguna untuk melihat ketika orang menggunakan algoritma rekursi ekor karena dalam kasus seperti itu, algoritma biasanya dapat ditulis ulang untuk menggunakan iterasi gantinya. Bahkan, compiler akan (atau paling tidak harus) mengubah program rekursif menjadi iteratif satu. Hal ini menghilangkan potensi masalah stack overflow.Ini tidak terjadi dengan rekursi kepala, atau ketika fungsi menyebut dirinya secara rekursif di tempat yang berbeda seperti di Menara larutan Hanoi. Tentu saja, bahkan dalam kasus ini kita juga bisa menghapus dengan menggunakan rekursi tumpukan kita sendiri dan pada dasarnya mensimulasikan bagaimana rekursi akan berhasil.Dalam contoh saya di atas faktorial compiler harus memanggil fungsi rekursif sebelum melakukan perkalian karena harus menyelesaikan nilai (return) fungsi sebelum dapat menyelesaikan perkalian. Jadi urutan eksekusi akan "kepala" rekursi, rekursi yaitu terjadi sebelum operasi lainnya.Untuk mengkonversi ini rekursi ekor untuk kita perlu mendapatkan semua perkalian selesai dan diselesaikan sebelum rekursif memanggil fungsi. Kita perlu untuk memaksa urutan operasi sehingga kita tidak menunggu perkalian sebelum kembali. Jika kita melakukan ini stack frame bisa dibebaskan.Cara yang tepat untuk melakukan tail-rekursif faktorial adalah:int faktorial (int angka) {
    
if (jumlah == 0) {
           
mengembalikan 1;
        
}
        
factorial_i (jumlah, 1);}int factorial_i (int currentNumber, jumlah int) {
    
if (currentNumber == 1) {
        
kembali jumlah;
    
} Else {
        
kembali factorial_i (currentNumber - 1, jumlah * currentNumber);
    
}}Perhatikan bahwa dalam SPT panggilan factorial_i (currentNumber - 1, jumlah currentNumber *); kedua parameter adalah segera diatasi. Kita bisa menghitung apa setiap parameter adalah tanpa menunggu pemanggilan fungsi rekursif untuk kembali. Ini tidak terjadi dengan versi sebelumnya faktorial. Perampingan ini memungkinkan kompilator untuk meminimalkan penggunaan tumpukan seperti yang dijelaskan di atas. Berkat Jon Bartlett misalnya.Beberapa definisi (jenis rekursi):

    
* Rekursi Tail: call adalah tail-rekursif jika tidak ada yang harus dilakukan setelah kembali panggilan. Yakni ketika kembali panggilan, nilai yang dikembalikan segera kembali dari pemanggilan fungsi. Lebih sederhana, rekursi ekor adalah ketika panggilan rekursif adalah pernyataan terakhir dalam fungsi. Lihat Rekursi Tail.
          
o Keuntungan dari rekursi ekor
          
o Keuntungan dari rekursi ekor (2)
    
* Rekursi Kepala: panggilan adalah kepala-rekursif ketika pernyataan pertama dari fungsi adalah panggilan rekursif.
    
* Rekursi Tengah atau Multi: call adalah pertengahan rekursif ketika panggilan rekursif terjadi di tengah fungsi. Yakni ada pernyataan-pernyataan lain sebelum dan setelah panggilan rekursif. Jika satu atau lebih dari laporan merupakan panggilan rekursif, maka fungsi multi-rekursif. Tidak ada perbedaan esensial antara Rekursi Kepala, Rekursi Tengah dan Rekursi multi dari sudut pandang efisiensi dan teori algoritma.
    
* Reksa Rekursi: Fungsi X dan Y disebut saling rekursif jika X Y fungsi panggilan fungsi fungsi dan Y pada gilirannya fungsi panggilan X. Ini juga disebut rekursi tidak langsung karena rekursi terjadi dalam dua langkah, bukan secara langsung.


Towers of Hanoi

    
b c

    
| | |
   
# # # | |
  
@ @ @ @ @ | |
 
$ $ $ $ $ $ $ | |---- + ------- + ------- + ----Kami ingin memindahkan menara dari, bergerak satu disk pada suatu waktu, tidak pernah bergerak disk di atas yang lebih kecil.Suatu prosedur sederhana melakukan hal ini, jika menyebut dirinya. Diri ini digunakan adalah rekursi.

   
Algoritma Hanoi (disk, sumber, dest, lainnya)
   
jika disk terkecil kemudian
     
memindahkan disk dari sumber ke tujuan
   
lain
     
Hanoi (disk berikutnya, sumber, lain, dest)
     
memindahkan disk dari sumber ke tujuan
     
Hanoi (disk berikutnya, lain, dest, sumber)
   
fiSebuah jejakDI Hanoi ($ $ $ $ $ $ $, a, b, c)
  
DI Hanoi (@ @ @ @ @, a, c, b)
    
DI Hanoi (# # #, a, b, c)
            
| | |
            
| | |
          
@ @ @ @ @ | |
         
$ $ $ $ $ $ $ # # # |
        
---- + ------- + ------- + ----
    
OUT
            
| | |
            
| | |
            
| | |
         
$ $ $ $ $ $ $ # # # @ @ @ @ @
        
---- + ------- + ------- + ----
    
DI Hanoi (# # #, b, c, a)
            
| | |
            
| | |
            
| | # # #
         
$ $ $ $ $ $ $ | @ @ @ @ @
        
---- + ------- + ------- + ----
    
OUT
  
OUT
            
| | |
            
| | |
            
| | # # #
            
| $ $ $ $ $ $ $ @ @ @ @ @
        
---- + ------- + ------- + ----
  
DI Hanoi (@ @ @ @ @, c, b, a)
    
DI Hanoi (# # #, c, a, b)
            
| | |
            
| | |
            
| | |
           
# # # $ $ $ $ $ $ $ @ @ @ @ @
        
---- + ------- + ------- + ----
    
OUT
            
| | |
            
| | |
            
| @ @ @ @ @ |
           
# # # $ $ $ $ $ $ $ |
        
---- + ------- + ------- + ----
    
DI Hanoi (# # #, a, b, c)
            
| | |
            
| # # # |
            
| @ @ @ @ @ |
            
| $ $ $ $ $ $ $ |
        
---- + ------- + ------- + ----
    
OUT
  
OUTOUTContoh BergunaAlice: Saya tidak ingin dunia berakhir! Apakah rekursi masih berguna?Algoritma Fast-Exponentiate (x, n)jika n = 0 maka
  
mengembalikan 1lain jika n adalah bahkan kemudian
  
kembali Fast-Exponentiate (x ^ 2, n / 2)lain
  
kembali x * Fast-Exponentiate (x ^ 2, (n - 1) / 2)fiDI Cepat-Exponentiate (2, 10)10 bahkan:
  
DI Cepat-Exponentiate (4, 5)
  
5 adalah aneh:
    
DI Cepat-Exponentiate (16, 2)
    
5 adalah aneh:
      
DI Cepat-Exponentiate (256, 1)
      
5 adalah aneh:
        
DI Cepat-Exponentiate (32768, 0)
        
mengembalikan 1
      
kembali 256
    
kembali 256
  
kembali 1024kembali 1024Tentang Fast-ExponentiateKebenaran: Kami membuktikan ini menggunakan induksi pada n. Kasus dasar, ketika n adalah 0, adalah mudah: Fast-Exponentiate (x, 0) = 1 = x ^ 0. Mengatakan itu bekerja untuk semua n lebih kecil dari k. Apakah bekerja untuk k? Jika k adalah genap, maka k / 2 lebih kecil dari k, sehingga

  
Cepat-Exponentiate (x, k) = Cepat-Exponentiate (x ^ 2, k / 2)
                          
= (X ^ 2) ^ (k / 2)
                          
= X ^ (2 (k / 2))
                          
= X ^ kJika k adalah ganjil, maka (k - 1) / 2 lebih kecil dari k, sehingga

  
Cepat-Exponentiate (x, k) = x * Fast-Exponentiate (x ^ 2, (k - 1) / 2)
                          
= X * (x ^ 2) ^ ((k - 1) / 2)
                          
= X * x ^ (2 ((k - 1) / 2))
                          
= X * x ^ (k - 1)
                          
= X ^ kWaktu terikat: Kami menggunakan kekambuhan.

  
T (1) = 1
  
T (n)
Menggunakan Teorema Master (lihat lampiran buku), kita melihat bahwa

  
T (n) = O (n log_2)Rekursi dan InduksiRekursi dan induksi matematika memiliki banyak kesamaan.Seperti bukti induktif, algoritma rekursif harus memiliki kasus dasar - beberapa situasi di mana efunction th tidak menyebut dirinya.Jika program ini tidak akan pernah sampai ke jawaban!Alice: Tapi ini adalah hal yang baik dengan Menara Hanoi!Rekursi di Jawapublic static int faktorial (int n) {
  
if (n == 0) {
    
mengembalikan 1;
  
} Else {
    
kembali n * faktorial (n - 1);
  
}}Makin banyak Java rekursiUrutan Fibonacci adalah sebagai berikut:

 
1 1 2 3 5 8 13 21 34 55 ...Setiap angka adalah jumlah dari dua angka sebelumnya dalam urutan. Kami menghitung jumlah fibonacci n.public static int Fibonacci (int n) {
  
if (n <2) {
    
mengembalikan 1;
  
} Else {
    
kembali Fibonacci (n - 1) + Fibonacci (n - 2);
  
}}Kami dapat grafik apa yang terjadi menggunakan pohon panggilan.

                
n = 4
            
___ / \ ___
           
/ \
        
n = 3 n = 2
       
/ \ / \
    
n = 2 n = 1 n = 1 n = 1
   
/ \n = 1 n = 1Perhatikan bahwa ini memakan Fibonacci (n) tambahan! Sejak Fibonacci (n) = O (1,618 ^ n), ini adalah waktu yang berjalan sangat miskin. Bahkan seseorang dapat menghitungnya dalam O (n).Contoh lainMasalah kelas FIND_IN_SORTED_ARRAYInput: sebuah arr array diurutkan dalam urutan meningkat, n bilangan bulatOutput: index n di arr, -1 jika tidak adaAlgoritma Binary-Search (arr, n, rendah, tinggi)jika tinggi
  
jika arr [rendah] = n maka
    
kembali rendah
  
lain
    
kembali -1
  
filain
  
jika arr [(rendah + tinggi) / 2]
    
kembali Binary-Search (arr, n, rendah, (rendah + tinggi) / 2)
  
lain jika arr [(rendah + tinggi) / 2]> n maka
    
kembali Binary-Search (arr, n, (rendah + tinggi) / 2 + 1, tinggi)
  
lain
    
kembali (rendah + tinggi) / 2
  
fifiHal ini membutuhkan O (log_2 n). Ini adalah solusi untuk relasi rekursi

  
T (n)
Sebuah Jejak

      
+ ---- + ---- + ---- + ---- + ---- + ---- + ---- + ---- +arr = | 2 | 3 | 5 | 7 | 11 | 13 | 17 | 19 |
      
+ ---- + ---- + ---- + ---- + ---- + ---- + ---- + ---- +

  
n = 13DI Binary-Search (arr, 13, 0, 8)11 <13:
  
DI Binary-Search (arr, 13, 5, 8)
  
17> 13:
    
DI Binary-Search (arr, 13, 5, 6)
    
13 = 13:
    
RETURN 5
  
RETURN 5RETURN 5Tentang VariabelSetiap panggilan ke fungsi rekursif mendapat salinan sendiri variabel.Mengubah variabel tidak berubah untuk panggilan rekursif yang lebih tinggi.public int SumSquares statis (int n) {
  
int n_squared;
  
int lain;

  
if (n <1) {
    
kembali 0;
  
} Else {
    
n_squared = n * n;
    
orang lain = SumSquares (n - 1);
    
kembali n_squared + orang lain;
  
}}Pohon panggilan terlihat seperti ini.

        
kembali 5
    
n = 2n_squared = 4
      
|
      
| Kembali 1
    
n = 1n_squared = 1
      
|
      
| Kembali 0
    
n = 0Bila panggilan dengan n = 1 n_squared perubahan, itu hanya perubahan salinannya dari n_squared. Para n_squared untuk panggilan dengan n = 2 tetap tidak berubah.


Daftar Pustaka
http://www.danzig.us/java_class/recursion.html
http://www.cs.cmu.edu/~cburch/pgss97/slides/0716-recurse.html




Sabtu, 14 Januari 2012

Cara Root dan Instal XRecovery SE Xperia X8

6
Sebenernya niat awal adalah mau update baseband sama Enclair  biar keren eh ndak nding tapi biar bisa diinstal Froyo ato GB. Ada 2 pilihan cara untuk upgrade ini alien, yang pertama via SEUS yang online, dan kedua via flashing biasa manual. Berhubung koneksi dewa lagi ngambek ya udah flashing secara offline aja deh
Langkah pertama donglot file2nya gitu. Setelah persiapan selesai tinggal flash manual. Eh oh..baru sampai setengah jalan proses malah terhenti . Dengan perasaan yang deeg2duer saya coba hidupkan, dan cuma bergetar aja. Waduh..mati..mati..mati..Shakiraku matek.
Yap..bener sekali..yang didapat malah mati suri, alias  tu hape ga menyala. Jadi cuma bergetar sekali doang..Karena udah malam dan ngantuk beud akhirnya tertidur deh.
Subuh terbangun dan melanjutkan misi menghidupkan ponsel. Kali ini dengan bantuan dragon ball kaskus akhirnya bisa menyala juga. Enclair versi Rusia yang saya pakai kali ini. Kata diporum2 sih kl cuma diflash2 ga bakalan matot.Kesalahan yang kulakukan sehingga mematikan ponsel adalah ketika memencet tombol backnya langsung ku lepas sebelum proses selesai..mungkin.

OK…upgrade baseband udah selesai, kini saatnya root aka rooting sebelum instal x recovery. Saya menggunakan SuperOneClick atau sering orang menyebut SOC. Karena ini saya anggap paling mudah. Untuk file2nya siapkan bahan2 seperti berikut :
Langkah2nya :
  1. Ekstrak file SOC  yang sudah anda donglot tadi. Ingat drivers x8 harus sudah terinstal yah.
  2. Buka/Klik file SOC exe-nya, itu lho yang icon androidnya.
  3. Sebelumnya centang usb debuging  pada ponsel, masuk setting-application-development-usb debugging
  4. Kl udah terbuka programnya SOC silahkan konekkan X8 anda menggunakan kabel data ke komputer.
  5. Nanti dilayar x8 ada notifikasi mount sd card, tekan back aja.
  6. Kembali ke program SOC, klik ROOT.
  7. Proses rooting akan berjalan kurang lebih 2-3menit sampai akan ada pemberitahuan “Device is Rooted!”
  8. Kl ga mau konek ato waiting for device ato rooting failed ato ada masalah lain, reboot komputer sama x8 anda.
  9. Selamat x8 anda sudah ter-root dengan baik.
Itu tadi cara rooting, sekarang menginjak ke acara selanjutnya yaitu instal x recovey. Hmm..sebenernya buat apa sih kudu instal x recovey ? OK..saya jelaskan dikit buat apa itu x recovey.
X Recovey ini berguna untuk mengembalikan data, ya iyalah namanya kan recovery. Data disini yang dimaksud adalah OS alias Android yang sudah diback up. Jadi kalo kita instal ROM terus error ga mau nyala ato booting gagal maka kita tinggal aja recovery. Bukan hanya itu, aplikasi ini juga berfungsi untuk gonta-ganti pasangan ROM Android.  Udah taukan fungsi aplkasi ini. Terus bagaimana cara instal di Androidnya.
Cara Instal X Recovery
  1. X8 Udah ter-Root
  2. Ekstrak file x Recovery terus copy ke Micro Sd X8
  3. Instal Root Explorer diatas di X8
  4. Buka Root Explorer kemudian cari file X Recovery tadi  copy-kan semua ke dalam folder system-bin
  5. Pastikan pada atas aksesnya dignti jadi R/W dari R/O
  6. Ubah permision ketiga file tadi dengan cara klik tahan pada file yang mau diganti permisionnya, centang semua.
  7. Selamat x8 anda telah terinstal X Recovery dengan selamat..
Untuk dapat masuk ke aplikasi x recovery silahkan restart ponsel anda kemudian saat tulisan Sony Ericsson muncul silahkan pencet berulang2 tombol back, nanti akan ada beberapa pilihan. Huftt…selesai juga sharing tentang bagaimana root dan instal recovery. Untuk bagaimana cara ganti Androidnya ke Gingerbread ato Froyo atau yang lain nantikan di episode berikutnya..

Janin 15 Minggu yang Berjuang untuk Hidup

Hanover, jerman – Gambar yang anda lihat diatas ini adalah gambar janin yang dilahirkan ketika umurnya baru sahaja 15 minggu. Hanya dengan sekecil dan semerah itu, dan mempunyai berat 10.5 ounce, janin yang diberi nama Kimberly Mueller. Apakah harapan ayah dan ibunya ketika itu?
Janin ini dibenarkan bersama ayah ibunya seketika selama beberapa saat sahaja sebelum dibawa pergi oleh pakar penyelamat yang bertungkus-lumus menyelamatkannya. Apa yang boleh dibisikkan oleh ayahnya hanyalah ‘Kimberly, you can do it baby”….
Harapan cuma 1:1000. Doktor pakar jantung yang merawatnya berkata, peluang untuk hidupnya sangat tipis. Namun begitu, bayi ini terus meredah liku-liku hidupnya dengan penuh tabah.
Selepas 6bulan dipantau rapi, janin ini sudah boleh dipanggil bayi. Bayi ini dibenarkan pulang ke rumahnya. Begitulah kekuasaan Tuhan Yang Maha Esa bukan?