Otomata Dan Pengantar Kompilasi - Laporan Tugas UTS

OTOMATA dan PENGANTAR KOMPILASI

Nama Kelompok :

1. Rico Andry (B/09120006)

2. Tara braja (B/09120020)

3. Erfan R S (B/09120073)

BAB I

Pertanyaan :

Carilah artikel melalui koran / internet mengenai mesin automaton?

Jawaban:

Ini merupakan deskripsi informasi dari automata :

Sebuah robot seharusnya dijalankan pada beberapa urutan yang diberikan atau

string masukan dalam langkah waktu diskrit. Pada setiap langkah waktu, robot

mendapat satu masukan yang diambil dari satu set simbol/huruf yang disebut alphabet.

Pada waktu, simbol sejauh diumpankan ke otomat sebagai bentuk masukan suatu finite

simbol, yang disebut kata. Sebuah robot berisi satu set hingga negara. Pada setiap

langkah saat otomat membaca simbol, melompat atau transit ke negara berikutnya

tergantung pada keadaan saat ini dan simbol dibaca. Fungsi lebih dari keadaan saat ini.

Simbol input disebut dengan fungsi transisi. Kata robot membaca masukan satu

simbol demi satu urutan dan transit dari negara ke negara sesuai dengan fungsi transisi,

sampai kata dibaca sepenuhnya. Setelah kata masukan dibaca, otomat dikatakan telah

berhenti dan keadaan dimana robot telah berhenti disebut keadaan akhir. Tergantung

pada keadaan akhir, dikatakan bahwa otomat baik menerima atau menolak kata

masukan. Ada bagian dari negara bagian otomat, yang didefinisikan sebagai satu set

negara penerima. Jika keadaan akhir adalah menerima negara, maka otomat menerima

kata. Jika tidak, kata ditolak. Himpunan semua kata diterima oleh robot ini disebut

bahasa diakui oleh otomat tersebut.

Dalam definisi formal, automaton robot diwakili secara resmi oleh 5-tuple Q [], ∑, δ ,

dimana:

- Q adalah himpunan terhingga negara

- ∑ adalah himpunan terbatas dari simbol, yang disebut alfabet dari otomat

tersebut.

- δ adalah fungsi transisi, yaitu , δ: Q x ∑ = Q

- F adalah seperangkat negara Q yang disebut menerima negara

Masukan kata

Sebuah robot membaca hingga string simbol a1, a 2, a 3,... ,a n dimana i ∑,

yang disebut kata masukan. Set semua kata dilambangkan dengan ∑*.

Menjalankan

Sebuah run robot pada kata w input = a1, a2, ..., n * ∑, merupakan urutan

negara-negara q0, q1, q3,....,qn, Dimana q1 Q seperti yang q0 adalah negara mulai

dan qi = δ (qi-1,i) untuk 0 ≤ i ≤n. Dengan kata, pada awalnya robot berada pada negara

awal q 0 dan kemudian automaton membaca simbol dari kata input secara berurutan.

Ketika robot membaca simbol ai maka itu melompat ke negara i q= δ (a i-1,i). q n

dikatakan sebagai keadaan akhir yang dijalankan.

Menerima kata

Sebuah kata w ∑* diterima oleh otomat jika n q F.

Diakui bahasa

Sebuah robot dapat mengenali bahasa formal. Bahasa diakui L∑ oleh robot

adalah himpunan semua kata yang diterima oleh otomat tersebut.

Dikenali bahasa

Ini bahasa dikenali adalah set dari bahasa yang diakui oleh beberapa otomat.

Untuk definisi di atas, otomata bahasa dikenali adalah bahasa reguler. Untuk definisi

yang berbeda dari automata, bahasa yang dikenali berbeda.

Variansi dalam definisi automata

Automata didefinisikan untuk belajar mesin berguna dalam formalisme

matematis. Jadi, definisi robot terbuka untuk variasi sesuai dengan “ mesin dunia nyata”

yang kita ingin model menggunakan robot tersebut. Orang-orang telah mempelajari

banyak variasi automata. Di atas, standar varian paling dijelaskan, yang disebut otomat

hingga deterministik. Berikut ini adalah beberapa variasi populer dalam definisi

komponen yang berbeda dari automata.

Input

- Hingga input : Sebuah robot yang hanya menerima hingga urutan kata-kata.

Definisi pendahuluan di atas menggambarkan automata dengan nomor hingga negara.

- Infinite menyatakan : sebuah robot yang mungkin tidak memiliki jumlah yang

terbatas dari negara, atau bahkan dapat dihitung sejumlah negara. Sebuah contoh,

hingga otomat kuantum atau otomat topologi memiliki tak terhingga ta terhitung negara,

- Memori Stack: sebuah otomat juga dapat mengandung beberapa memori

tambahan dalam bentuk stack dimana simbol dapat didorong dan muncul. Semacam ini

disebut otomat push down.

Fungsi transisi

- Deterministik: Untuk kondisi saat ini diberikan dan simbol input, jika robot

hanya dapat melompat ke satu dan hanya satu negara maka itu adalah otomat

deterministik.

- Sebuah robot yang setelah membaca sebuah simbol input, dapat melompat ke

salah satu dari sejumlah negara, seperti yang dilisensi oleh hubungan transisi.

Perhatikan bahwa fungsi transisi istilah digantikan oleh hubungan transisi: otomat non-

- deterministik memutuskan untuk melompat ke salah satu pilihan yang diizinkan

robot seperti ini disebut otomat nondeterministic,

- Alternatif : gagasan ini sangat mirip dengan robot pohon , tetapi orthogonal.

Robot mungkin menjalankan beberapa salinan terhadap membaca simbol berikutnya

yang sama. Automata seperti ini disebut bolak otomat. Kondisi Penerimaan harus

memenuhi semua berjalan salinan tersebut untuk menerima input.

Penerimaan kondisi

- Penerimaan kata-kata hingga: Sama seperti yang dijelaskan dalam definisi

informal diatas.

- Penerimaan kata-kata yang tak terbatas: omega robot tidak dapat memiliki

negara akhir, seperti kata-kata yang tidak terbatas tidak pernah berakhir. Sebaliknya,

penerimaan dari kata tersebut telah ditetapkan dengan melihat urutan yang tidak terbatas

negara-negara yang dikunjungi selama menjalankan.

- Penerimaan Probabilistik: sebuah robot tidak perlu benar-benar menerima atau

menolak masukan. Ini mungkin menerima input dengan beberapa probabilitas antara nol

dan satu. Misalnya robot kuantum terbatas, robot geometrik, automaton metrik memiliki

penerimaan probabilistik.

Kombinasi yang berbeda dari berbagai variansi di atas menghasilkan banyak otomata.

Aplikasi

Kebanyakan implementasi robot yang digunakan untuk membuat perangkat lunak

mengakui tertentu bahasa, contoh umum adalah compiler dan mesin ekspresi reguler.

Kelas automata

Automata Bahasa yang dikenali

Deterministik finite automata (DFA) Reguler bahasa

Non deterministic hingga otomata(NFA) Reguler bahasa

Non deterministic hingga automata dengan e transisi (FND –e atau e- NFA)

Reguler bahasa

Pushdown automata (PDA) Bebas konteks bahasa

Linear bounded automata (LBA) Konteks bahasa

Mesin turing Rekursif enumerable bahasa

Jangka waktu automata -

Mesin Pengenal Bahasa

Untuk setiap kelas bahasa Chomsky, terdapat sebuah mesin pengenal bahasa.

Masing-masing mesin tersebut adalah :

Kelas Bahasa Mesin Pengenal Bahasa

Unrestricted Grammar (UG) Mesin Turing (Turing Machine), TM

Context Sensitive Grammar (CSG) Linear Bounded Automata, LBA

Context Free Gammar (CFG) Pushdown Automata, PDA

Regular Grammar, RG Finite State Automata, FSA

BAB II

Pertanyaan :

Diketahui REA = ab (a+b)*

1) Rancang mesin FA-nya ?

2) Buat program FA tersebut

3) Uji coba program

(min 5 string rejected dan accepted)

Jawaban:

∑ = {a,b} L= {ab,aba,abaa..,abab,...}

S = {A,B,C,D,E)

Sₒ= {A}

NFA:

δ ( {A} , a) = {B} δ ( {C}, b) = {E}

δ ( {A} , b) = { } δ ( {D}, a) = {D}

δ ( {B} , a) = { } δ ( {D}, b) = {E}

δ ( {B} , b) = {C} δ ( {E}, a) = {D}

δ ( { }, a) = { } δ ( {E}, b) = {E}

δ ( { }, b) = { }

δ ( {C}, a) = {D}

DFA :

Accepted

String 1 : ab String 3 = abab

1) S₀ : {A} 3) S₀= {A} = ᵹ ( ᵹ(C,a), ”b”)

= ᵹ (A,”ab”) = ᵹ ( A, ”abab”) = ᵹ ( δ(C,a), ”b”)

= ᵹ ( ᵹ(A,a),”b”) = ᵹ ( ᵹ(A,a), ”bab”) = ᵹ ( D, ”b”)

= ᵹ ( δ(A,a),”b”) = ᵹ ( δ(A,a), ”bab”) = ᵹ ( ᵹ(D,b))

= ᵹ( B,”b”) = ᵹ ( B, ”bab”) = ᵹ ( δ(D,b))

= ᵹ( ᵹ(B,b)) = ᵹ ( ᵹ(B,b), ”ab”) E ϵ Final state

= ᵹ( δ(B,b)) = ᵹ ( δ(B,b), ”ab”)

C ϵ Final state = ᵹ ( C, ”ab”)

String 2 : aba String 4 : abb

2) S₀ : {A} 4) S₀= {A} = ᵹ (C, ”b”)

= ᵹ (A,”aba”) = ᵹ ( A, ”abb”) = ᵹ (ᵹ (C,b))

= ᵹ ( ᵹ(A,a),”ba”) = ᵹ ( ᵹ(A,a), ”bb”) = ᵹ (δ (C,b))

= ᵹ ( δ(A,a),”ba”) = ᵹ ( δ(A,a), ”bb”) E ϵ Final state

= ᵹ( B,”ba”) = ᵹ ( B, ”bb”)

= ᵹ( ᵹ(B,b,”a”)) = ᵹ ( ᵹ(B,b), ”b”)

= ᵹ( δ(B,b,”a”)) = ᵹ (δ (B,b), ”b”)

= ᵹ ( C,”a”)

= ᵹ( ᵹ(C,a))

= ᵹ( δ(C,a))

D ϵ Final state

String 5 : abaa

5. S₀ : {A}

= ᵹ (A,”abaa”)

= ᵹ ( ᵹ(A,a),”baa”)

= ᵹ ( δ(A,a),”baa”)

= ᵹ( B,”baa”)

= ᵹ( ᵹ(B,b),”aa”))

= ᵹ( δ(B,b),”aa”))

= ᵹ( C,”aa”))

= ᵹ( ᵹ(C,a),”aa”))

= ᵹ( δ(C,a),”aa”))

= ᵹ( D,”a”))

= ᵹ( ᵹ(D,a))

= ᵹ( δ(D,a))

D ϵ Final state

Non accepted

String 1 : aa String 3 = b

1) S₀ : {A} 3) S₀= {A}

= ᵹ (A,”aa”) = ᵹ ( A, ”b”)

= ᵹ ( ᵹ(A,a),”a”) = ᵹ ( ᵹ(A,b))

= ᵹ ( δ(A,a),”a”) = ᵹ ( δ(A,b))

= ᵹ( B,”a”) {} ɇ Final state

= ᵹ( ᵹ( B,a))

= ᵹ( δ( B,a))

{} ɇ Final state

String 2 : aaa String 4 : aab

2) S₀ : {A} 4) S₀= {A} = ᵹ ( { }, ”b”)

= ᵹ (A,”aaa”) = ᵹ ( A, ”aab”) = ᵹ (ᵹ ( { },b))

= ᵹ ( ᵹ(A,a),”aa”) = ᵹ ( ᵹ(A,a), ”ab”) = ᵹ (δ ( { },b))

= ᵹ ( δ(A,a),”aa”) = ᵹ ( δ(A,a), ”ab”) { } ɇ Final state

= ᵹ( B,”aa”) = ᵹ ( B, ”ab”)

= ᵹ( ᵹ(B,a,”a”)) = ᵹ ( ᵹ(B,a), ”b”)

= ᵹ( δ(B,a),”a”)) = ᵹ (δ (B,a), ”b”)

= ᵹ ( { },”a”)

= ᵹ( ᵹ( {},a))

= ᵹ( δ( {},a))

{ } ɇ Final state

String 5 : bab

5. S₀ : {A}

= ᵹ (A,”bab”)

= ᵹ ( ᵹ(A,b),”ab”)

= ᵹ ( δ(A,b),”ab”)

= ᵹ( { },”ab”)

= ᵹ( ᵹ( { },a),”b”))

= ᵹ( δ( { },a),”b”))

= ᵹ( { },”b”))

= ᵹ( ᵹ({ },b))

= ᵹ( δ( { },b))

{ } ɇ Final state

Flowchart Program DFA Bab 2

Kode Program

D:\Project Java~!\OPK\src\DFA2.java 1 /** 2 * 3 * @author Erfan 4 */ 5 public class DFA2 { 6 //REGULAR EXPRESSION = ab(a+b)* 7 //deklarasi STATE dalam bentuk variabel 8 private final int A=0; 9 private final int B=1;10 private final int C=2;11 private final int D=3;12 private final int E=4;13 private final int F=5;14 15 16 //definisi is_final untuk setiap state yang ada17 private boolean final_state[]={false,false,true,true,true,false};18 19 //Variable penyimpan uji string20 private String Uji;21 22 //Variabel kursor State23 private int state;24 25 public DFA2(String input_string){26 Uji=input_string;27 //menghilangkan spasi pada string input28 Uji=Uji.trim();29 //membuat char input menjadi alphabet kecil30 Uji=Uji.toLowerCase();31 this.State_Awal();32 this.Proses_Uji();33 }34 35 //function untuk menguji state pada diagram DFA36 private int DFA(int x, char c){37 switch(x){38 case A: switch(c){39 case 'a': return B;40 case 'b':return F;41 }42 case B: switch(c){43 case 'a': return F;44 case 'b': return C;45 }46 case C: switch(c){47 case 'a': return D;48 case 'b': return E;49 }50 case D: switch(c){51 case 'a': return D;52 case 'b': return E;53 }54 case E: switch(c){55 case 'a': return D;56 case 'b': return E;57 }

58 case F: switch(c){59 case 'a': return F;60 case 'b': return F;61 }62 63 64 }65 return 0;66 }67 68 private void Proses_Uji(){69 70 for (int i=0;i < Uji.length();i++){71 char c=Uji.charAt(i);72 state=DFA(state,c);73 }74 75 }76 77 private void State_Awal(){78 state=0;79 }80 81 public boolean hasil_akhir(){82 return final_state[state];83 }84 85 86 87 }88 89 90 91 92

Uji coba dengan program

1. ab

Hasil :

2. aba

3. abab

4. abb

5. abaa

6. aa

7. aaa

8. b

9. aab

10. bab

BAB III

Pertanyaan :

Pembuktian String 1 Extend transisi (∑)

∑(So, Word)

Stringnya

DFA state a, b :

Jelaskan dan buktikan mengenai soal di bawah ini apakah diterima/ditolak?

1) String 2= bba

2) String 3= abaa

Jawab:

1) S₀ : {A} 2) S₀= {A} = ᵹ ( ᵹ(B,a))

= ᵹ (A,”bba”) = ᵹ ( A, ”abaa”) = ᵹ ( δ(B,a))

= ᵹ ( ᵹ(A,b),”ba”) = ᵹ ( ᵹ(A,a), ”baa”) C ϵ Final state(accepted)

= ᵹ ( δ(A,b),”ba”) = ᵹ ( δ(A,a), ”baa”)

= ᵹ( D,”ba”) = ᵹ ( B, ”baa”)

= ᵹ( ᵹ(D,b),”a”) = ᵹ ( ᵹ(B,b), ”aa”)

= ᵹ( δ(D,b),”a”) = ᵹ ( δ(B,b), ”aa”)

= ᵹ( F,”a”) = ᵹ ( E, ”aa”)

= ᵹ( ᵹ(F,a)) = ᵹ ( ᵹ(E,a), ”a”)

= ᵹ( δ(F,a)) = ᵹ ( δ(E,a), ”a”)

F ɇ Final state (not accepted) = ᵹ ( B, ”a”)

BAB IV

Diketahui:

REA = ab (a+b)*

A =

NFA:

Pertanyaan :

1) Konversikan NFA ini menjadi DFA?

Jawaban :

∑ : {a,b} S : {A, B,C,D} S₀ : {A} F : {B,D}

A BA B , D -B - C , DC C B , DD B -

δ ( {A} , a) = { B , D} δ ( {B}, b) = {C , D } δ( {B,C,D}, a) = {C , B}

δ ( {A} , b) = { } δ ( {C,D}, a) = {C,B} δ( {B,C,D}, b} = {C , D ,B}

δ ( {B,D} , a) = {B} δ ( {C,D}, b) = {B,D}

δ ( {B,D} , b) = {C,D} δ ( {C,B}, a) = {C}

δ ( { }, a) = { } δ ( {C,B}, b) = {B,C,D}

δ ( { }, b) = { } δ ( {C}, a) = {C}

δ ( {B}, a) = { } δ ( {C}, b) = {B,D}

DFA :

2) Lakukan test menggunakan string dengan program dan ekstend transisia) abbbaa d) abbabbb) babba e) aabababc) babab f) abbab

Jawaban:a) S₀ : {A} b) So : {A}

= ᵹ (A,”abbbaa”} = ᵹ (A,”babba”}

= ᵹ (ᵹ (A,a),”bbbaa”) = ᵹ (ᵹ (A,b),”abba”)

= ᵹ (δ (A,a),”bbbaa”) = ᵹ (δ (A,b),”abba”)

= ᵹ (B,”bbbaa”} = ᵹ (C,”abba”)

= ᵹ (ᵹ (B,b),”bbaa”) = ᵹ (ᵹ (C,a),”bba”)

= ᵹ (δ (B,b),”bbaa”) = ᵹ (δ (C,a),”bba”)

= ᵹ (E,”bbaa”} = ᵹ (C,”bba”)

= ᵹ (ᵹ (E,b),”baa”) = ᵹ (ᵹ (C,b),”ba”)

= ᵹ (δ (E,b),”baa”) = ᵹ (δ (C,b),”ba”)

= ᵹ (B,”baa”} = ᵹ (C,”ba”)

= ᵹ (ᵹ (B,b),”aa”) = ᵹ (ᵹ (C,b),”a”)

= ᵹ (δ (B,b),”aa”) = ᵹ (δ (C,b),”a”)

= ᵹ (E,”aa”} = ᵹ (C,”a”)

= ᵹ (ᵹ (E,a),”a”) = ᵹ (ᵹ (C,a))

= ᵹ (δ (E,a),”a”) = ᵹ (δ (C,a))

= ᵹ (F,”a”} C ɇ Final state (not accepted)

= ᵹ (ᵹ (F,a))

= ᵹ (δ (F,a))

G ɇ Final state (not accepted)

c)S₀ : {A} d) S₀ : {A}

= ᵹ (A,”babab”} = ᵹ (A,”abbabb”}

= ᵹ (ᵹ (A,b),”abab”) = ᵹ (ᵹ (A,a),”bbabb”)

= ᵹ (δ (A,b),”abab”) = ᵹ (δ (A,a),”bbabb”)

= ᵹ (C,”abab”} = ᵹ (B,”bbabb”)

= ᵹ (ᵹ (C,a),”bab”) = ᵹ (ᵹ (B,b),”babb”)

= ᵹ (δ (C,a),”bab”) = ᵹ (δ (B,b),”babb”)

= ᵹ (C,”bab”} = ᵹ (E,”babb”)

= ᵹ (ᵹ (C,b),”ab”) = ᵹ (ᵹ (E,b),”abb”)

= ᵹ (δ (C,b),”ab”) = ᵹ (δ (E,b),”abb”)

= ᵹ (C,”ab”} = ᵹ (B,”abb”)

= ᵹ (ᵹ (C,a),”b”) = ᵹ (ᵹ (B,a),”bb”)

= ᵹ (δ (C,a),”b”) = ᵹ (δ (B,a),”bb”)

= ᵹ (C,”b”} = ᵹ (D,”bb”)

= ᵹ (ᵹ (C,b)) = ᵹ (ᵹ (D,b) ”b”)

= ᵹ (δ (C,b)) = ᵹ (δ (D,b) “b”)

C ɇ Final state (not accepted) = ᵹ (E,”b”)

= ᵹ (ᵹ (E,b))

= ᵹ (ᵹ (E,b))

B ϵ Final state(accepted)

e). S₀ : {A} f) S₀ : {A}

= ᵹ (A,”aababab”} = ᵹ (A,”abbab”}

= ᵹ (ᵹ (A,a),”ababab”) = ᵹ (ᵹ (A,a),”bbab”)

= ᵹ (δ (A,a),”ababab”) = ᵹ (δ (A,a),”bbab”)

= ᵹ (B,”ababab”} = ᵹ (B,”bbab”)

= ᵹ (ᵹ (B,a),”babab”) = ᵹ (ᵹ (B,b),”bab”)

= ᵹ (δ (B,a),”babab”) = ᵹ (δ (B,b),”bab”)

= ᵹ (D,”babab”} = ᵹ (E,”bab”)

= ᵹ (ᵹ (D,b),”abab”) = ᵹ (ᵹ (E,b),”ab”)

= ᵹ (δ (D,b),”abab”) = ᵹ (δ (E,b),”ab”)

= ᵹ (E,”abab”} = ᵹ (B,”ab”)

= ᵹ (ᵹ (E,a),”bab”) = ᵹ (ᵹ (B,a),”b”)

= ᵹ (δ (E,a),”bab”) = ᵹ (δ (B,a),”b”)

= ᵹ (F,”bab”} = ᵹ (D,”b”)

= ᵹ (ᵹ (F,b),”ab”) = ᵹ (ᵹ (D,b))

= ᵹ (δ (F,b),”ab”) = ᵹ (δ (D,b))

= ᵹ (H,”ab”} E ϵ Final state(accepted)

= ᵹ (ᵹ (H,a),”b”)

= ᵹ (δ (H,a),”b”)

= ᵹ (F,”bab”}

= ᵹ (ᵹ (F,b),”ab”)

= ᵹ (δ (F,b),”ab”)

= ᵹ (H,”ab”}

= ᵹ (ᵹ (H,a),”b”)

= ᵹ (δ (H,a),”b”)

= ᵹ (F,”b”)

= ᵹ (ᵹ (F,b))

= ᵹ (δ (F,b))

H ϵ Final state(accepted)

Flowchart program DFA bab IV

Kode Program

D:\Project Java~!\OPK\src\DFA1.java 1 /** 2 * 3 * @author Erfan 4 */ 5 public class DFA1 { 6 7 //REGULAR EXPRESSION = ab(a+b)* 8 //deklarasi STATE dalam bentuk variabel 9 private final int A=0;10 private final int B=1;11 private final int C=2;12 private final int D=3;13 private final int E=4;14 private final int F=5;15 private final int G=6;16 private final int H=7;17 18 //definisi is_final untuk setiap state yang ada19 private boolean final_state[]={false,true,false,true,true,true,false,true};20 21 //Variable penyimpan uji string22 private String Uji;23 24 //Variabel kursor State25 private int state;26 27 public DFA1(String input_string){28 Uji=input_string;29 //menghilangkan spasi pada string input30 Uji=Uji.trim();31 //membuat char input menjadi alphabet kecil32 Uji=Uji.toLowerCase();33 this.State_Awal();34 this.Proses_Uji();35 }36 private void State_Awal(){37 state=0;38 }39 40 //function untuk menguji state pada diagram DFA41 private int DFA(int x, char c){42 switch(x){43 case A: switch(c){44 case 'a': return B;45 case 'b': return C;46 }47 case B: switch(c){48 case 'a': return D;49 case 'b': return E;50 }51 case C: switch(c){52 case 'a': return C;

53 case 'b': return C;54 }55 case D: switch(c){56 case 'a': return C;57 case 'b': return E;58 }59 case E: switch(c){60 case 'a': return F;61 case 'b': return B;62 }63 case F:switch(c){64 case 'a': return G;65 case 'b': return H;66 }67 case G:switch(c){68 case 'a': return G;69 case 'b': return B;70 }71 case H:switch(c){72 case 'a':return F;73 case 'b':return H;74 }75 }76 return 0;77 }78 79 private void Proses_Uji(){80 81 for (int i=0;i < Uji.length();i++){82 char c=Uji.charAt(i);83 state=DFA(state,c);84 }85 86 }87 public boolean hasil_akhir(){88 return final_state[state];89 }90 }91 92

Tampilan Uji Coba Program

1. abbbaa

Hasil :

Not Accepted

2. babba

Hasil :

Not Accepted

3. babab

Hasil :

Not Accepted

4. abbabb

Hasil :

Accepted

5. aababab

Hasil :

Accepted

6. abbab

Hasil :

Accepted