Belajar Pemrograman Python: membuat fractal segitiga (Rekursif)

Postingan ini adalah kelanjutan dari postingan sebelumnya Belajar Pemrograman Python: membuat fractal segitiga. Pembahasan kali ini lebih ke arah penggunaan teknik rekursif untuk pemecahan masalah yang sama. (Sebaiknya pelajari terlebih dahulu postingan sebelumnya tentang Belajar Pemrograman Python: membuat fractal segitiga)

Pada postingan sebelumnya terdapat lima (5) buah function utama untuk bisa menggambar (membuat fractal segitiga). kelima function itu adalah:

      triangle_1(some_pen,size)   #untuk membuat segitiga kecil (level 0)

      triangle_2(some_pen,size)   #untuk membuat segitiga lebih besar (level 1)

      triangle_3(some_pen,size)   #untuk membuat segitiga lebih besar (level 2)

      triangle_4(some_pen,size)   #untuk membuat segitiga lebih besar (level 3)

      draw()                      #untuk setting pena dan menjalankan triangle_4

dari kelima function tersebut, Kita akan fokus pada 4 function utama untuk membuat susunan segitiga fractal yaitu triangle+1, triangle_2, triangle_3, dan triangle_4. Perhatikan lagi bahwa function yang dipanggil adalah triangle_4, dan saat triangle_4 dieksekusi maka dia akan memanggil triangle_3, saat triangle_3 dieksekusi maka akan memanggil triangle_2, dan saat triangle_2 dieksekusi akan memanggil triangle_1. 

Dari sini dapat kita pelajari bahwa function triangle_2, triangle_3, dan triangle_4 sangat identik sehingga dapat diringkas menjadi suatu function yang bersifat rekursif. 

Sedangkan triangle_1 adalah sebagai function paling dasar. Oleh karena itu pada saat membuat function rekursif maka triangle_1 akan menjadi bagian paling ujung (stoping, penyetop fungsi rekursif).

Baik, berikut adalah function rekursif (saya namakan fractal) yg sudah Saya buat berdasar function triangle sebelumnya.

def fractal(level,some_pen,size):
    if (level==0):
        some_pen.begin_fill()
        some_pen.right(60)
        for i in range(1,3):
            some_pen.forward(size)
            some_pen.right(120)
        some_pen.forward(size)
        some_pen.end_fill()
    else:
        fractal(level-1,some_pen,size)
        some_pen.right(120)
        some_pen.forward((2**(level-1))*size)
        some_pen.left(60)
        fractal(level-1,some_pen,size)
        some_pen.left(120)
        some_pen.forward((2**(level-1))*size)
        some_pen.right(180)
        fractal(level-1,some_pen,size)
        some_pen.forward((2**(level-1))*size)


function ini memiliki tiga parameter input yaitu level, some_pen, dan size. Kalo dibandingkan dengan function triangle sebelumnya yang hanya dua parameter maka ada satu parameter tambahan yang berbeda yaitu "level". Parameter "level" ini menentukan mau membuat gambar segitiga fraktal sampai level berapa. Dengan catatan level 0 adalah saat hanya menggambar segitiga kecil saja. sebagai contoh dipostingan sebelumnya Saya hanya menggambar segitiga fraktal sampai dilevel 3 atau sampai di triangle_4.

Perhatikan bahwa if (level==0) berisi barisan perintah persis seperti function triangle_1. Karena ini akan menjadi bagian ujung (tidak lagi memanggil function yang lain saat dijalankan).

Sedangkan pada bagian else, berisi barisan perintah yang hampir sama dengan function triangle_2, triangle_3 dan triangle_4. Yang mana "function fractal" ini juga memanggil "dirinya sendiri" pada level yang lebih rendah. Hal ini juga terjadi pada function triangle_4 yang memanggil triangle_3 dan seterusnya.

Dengan menggunakan "function fractal" ini, jika kita ingin membuat segitiga fraktal level 7 misalnya, maka cukup memanggil function ini dengan menyertakan level 7 sebagai input. Tidak perlu membuat function ulang triangle_7, triangle_6, triangle_5, dan seterunya. Sehingga source code lebih ramping dan lebih mudah dibaca. (Pada contoh kasus ini lebih efisien).

Berikut adalah kode lengkapnya:


import turtle

def fractal(level,some_pen,size):
    if (level==0):
        some_pen.begin_fill()
        some_pen.right(60)
        for i in range(1,3):
            some_pen.forward(size)
            some_pen.right(120)
        some_pen.forward(size)
        some_pen.end_fill()
    else:
        fractal(level-1,some_pen,size)
        some_pen.right(120)
        some_pen.forward((2**(level-1))*size)
        some_pen.left(60)
        fractal(level-1,some_pen,size)
        some_pen.left(120)
        some_pen.forward((2**(level-1))*size)
        some_pen.right(180)
        fractal(level-1,some_pen,size)
        some_pen.forward((2**(level-1))*size)

def draw():
    window = turtle.Screen()
    window.bgcolor("red")

    pen = turtle.Turtle()

    pen.penup()
    pen.sety(200)
    pen.pendown()

    pen.shape("turtle")
    pen.color("blue")
    pen.speed(1)

    fractal(5,pen,10)

    window.exitonclick()

draw()
 

Dan berikut adalah hasil runningnya:

Developed by: 

Muhammad Nurul Puji

Project-H

Belajar Pemrograman Python: membuat fractal segitiga

Saat ini banyak sekali media-media pembelajaran online baik gratis maupun berbayar. Nah saat ini Saya mencoba untuk memanfaatkan pembelajaran online melalui Udacity. Udacity menyediakan kursus gratis maupun paket berbayar. Yang akan Saya share di sini adalah salah satu tugas dari kursus "Programming Foundations with Python" di Udacity, kursus ini gratis kok (sejauh ini gratis.hehe). Nah kira-kira salah satu tugasnya adalah membuat program untuk menggambar segitiga sebagai berikut:

Salah satu tugas di Udacity

Sebenernya di forum diskusi yang disediakan sudah ada peserta lain yang share codenya sih, tapi karena agak ribet maka Saya putuskan untuk mencoba menyelesaikan tugas ini sendiri.

Baik, Kalo kita perhatikan maka komponen dasar pembentuk gambar tersebut adalah segitiga kecil berwarna biru. Kemudian segitiga kecil ini disusun sedemikian hingga, sehigga terbentuk segitiga besar. Oiya abaikan gambar kura-kura dibagian atas, karena itu hanya ujung pena untuk menggambar (library yang digunakan adalah turtle). Intinya library ini digunakan untuk menggambar hehe. Lebih detil silahkan pelajari dokumentasi Library turtle.

Pertama gambar segitiga kecil berikut:

segitiga kesatu

Berikut adalah function tiangle_1 untuk menggambar segitiga biru kecil (segitiga kesatu):

 def triangle_1(some_pen,size):
    some_pen.begin_fill()
    some_pen.right(60)

    some_pen.forward(size)
    some_pen.right(120)

    some_pen.forward(size)
    some_pen.right(120)

    some_pen.forward(size)
    some_pen.end_fill()

Penjelasan: Gambar kura-kura menunjukkan pena/bulpoint. Default awalnya adalah pena menghadap ke kanan secara horisontal. Oiya untuk membuat segitiga diperlukan tiga garis. Dalam program ini Saya menggambar dari atas, samping kanan, bawah, samping kiri, dan balik ke atas. 

Karena awalnya pena menghadap ke kanan, maka perlu Saya putar sebesar 60 derajat kekanan (some_pen.right(60)), kemudian pena saya gerakkan sepanjang ukuran yang dikehendaki (some_pen.forward(size)). Sampai sini terbentuk garis samping kanan.

Untuk melanjutkan pergerakan pena membentuk garis dibagian bawah maka pena diputar 120 derajat kekanan (some_pen.right(120)) dan kemudian pena saya gerakkan sepanjang ukuran yang dikehendaki (some_pen.forward(size)). Sampai sini terbentuk garis bagian bawah.

Sekarang saatnya melanjutkan untuk menggambar garis sebelah kiri. Untuk itu maka pena saya putar lagi sebesar 120 derajat kekanan (some_pen.right(120)) dan kemudian pena saya gerakkan sepanjang ukuran yang dikehendaki (some_pen.forward(size)). Sampai sini terbentuk garis samping kiri.

Posisi pena terakhir adalah di bagian puncak atas menghadap ke atas (miring)

Perhatikan dibagian awal terdapat perintah some_pen.begin_fill() dan dibagian akhir terdapat some_pen.end_fill(). Hal ini untuk membuat segitiga terisi dengan warna (biru) ditengahnya.

Sekali lagi perhatikan bahwa terdapat adanya pengulangan kode dibagian tengah, sehingga kode dapat disimplifikasi menggunakan loop. Berikut kode (function) membuat segitiga menggunakan loop:

def triangle_1(some_pen,size):
    some_pen.begin_fill()
    some_pen.right(60)
    for i in range(1,3):
        some_pen.forward(size)
        some_pen.right(120)
    some_pen.forward(size)
    some_pen.end_fill()

Kedua, Gambar susunan segitiga berikut: 

segitiga kedua

Berikut adalah function untuk menggambar segitiga kedua:

def triangle_2(some_pen,size):
    triangle_1(some_pen,size)
    some_pen.right(120)
    some_pen.forward(size)
    some_pen.left(60)
    triangle_1(some_pen,size)
    some_pen.left(120)
    some_pen.forward(size)
    some_pen.right(180)
    triangle_1(some_pen,size)
    some_pen.forward(size) 

Perhatikan bahwa gambar segitiga kedua tersusun dari tiga segitiga kesatu. Secara umum langkahnya adalah membuat segitiga kecil atas, kemudian kanan bawah, kemudian kiri bawah.

sehingga langkah pertama adalah menggambar segitiga atas dengan memanfaatkan function triangle_1:
    triangle_1(some_pen,size)

kemudian memindahkan pena kebagian bawah kanan dari segitiga kesatu (dan juga setelah sampai dibawah, arahkan pena kembali mendatar kearah kanan, karena untuk menggambar segitiga kecil defaultnya adalah pena mendatar kekanan):

    some_pen.right(120)
    some_pen.forward(size)

    some_pen.left(60)  #untuk mengarahkan pena kembali mendatar arah kanan

Kemudian menggambar segitiga kanan bawah dengan memanfaatkan function triangle_1:

    triangle_1(some_pen,size)

kemudian memindahkan pena kebagian bawah kiri dari segitiga kesatu (dan juga setelah sampai dibawah, arahkan pena kembali mendatar kearah kanan, karena untuk menggambar segitiga kecil defaultnya adalah pena mendatar kekanan):

    some_pen.left(120)
    some_pen.forward(size)
    some_pen.right(180)  #untuk mengarahkan pena kembali mendatar arah kanan

Kemudian menggambar segitiga kiri bawah dengan memanfaatkan function triangle_1:

    triangle_1(some_pen,size)

Untuk memudahkan routing berikutnya maka dibagian akhir, Posisi pena adalah selalu di bagian puncak atas menghadap ke atas (miring):

    some_pen.forward(size)  #untuk memindahkan pena ke puncak atas (miring)

Ketiga, Gambar susunan segitiga berikut:

 

segitiga ketiga

Perhatikan dengan seksama bahwa gambar segitiga kedua tersusun dari tiga segitiga kedua. Secara umum langkahnya adalah membuat segitiga kedua dibagain atas, kemudian kanan bawah, kemudian kiri bawah. Langkah ini sangat mirip dengan langkah pada saat menggambar segitiga kedua.

Jika pada saat menggambar segitiga kedua adalah memanfaatkan segitiga kesatu (triangle_1). Maka untuk menggambar segitiga ketiga ini memanfaatkan segitiga kedua (triangle_2). 

Berikut adalah function untuk menggambar segitiga ketiga:

def triangle_3(some_pen,size):
    triangle_2(some_pen,size)
    some_pen.right(120)
    some_pen.forward(2*size)   #perpindahan masing-masing sisi menjadi dua kali
    some_pen.left(60)
    triangle_2(some_pen,size)
    some_pen.left(120)
    some_pen.forward(2*size)   #perpindahan masing-masing sisi menjadi dua kali

    some_pen.right(180)
    triangle_2(some_pen,size)
    some_pen.forward(2*size)   #perpindahan masing-masing sisi menjadi dua kali

 

Keempat, Gambar susunan segitiga berikut:

 

segitiga keempat

Berikut adalah function untuk menggambar segitiga keempat:

def triangle_4(some_pen,size):
    triangle_3(some_pen,size)
    some_pen.right(120)
    some_pen.forward(2*2*size)
    some_pen.left(60)
    triangle_3(some_pen,size)
    some_pen.left(120)
    some_pen.forward(2*2*size)
    some_pen.right(180)
    triangle_3(some_pen,size)
    some_pen.forward(2*2*size)

##pembahasan sama dengan bagian ketiga

Bagian kelima:

Bagian kelima ini adalah bertugas untuk mempersiapkan pena dan memanggil fungsi untuk menggambar (triangle_4). Disini Saya membuat function bernama draw sebagai berikut:

def draw():
    window = turtle.Screen()   #instansiasi screen (aktivasi screen)
    window.bgcolor("red")      #set background screen berwarna merah

    pen = turtle.Turtle()      #instansiasi pena

    pen.penup()                #angkat pena (supaya bisa dipindahkan posisinya)
    pen.sety(100)              #memindahkan posisi pena (optional)
    pen.pendown()              #menurunkan pena (siap untuk menulis/menggambar)

    pen.shape("turtle")        #set bentuk pena (berbentuk kura-kura)
    pen.color("blue")          #set warna pena
    pen.speed(1)               #set kecepatan gerak pena

    triangle_4(pen,20)         #memanggil fungsi triangle_4 untuk menggambar

    window.exitonclick()       #menutup window hanya jika diklik (setelah selesai menggambar)

Bagian keenam:

Dibagian ini Saya tunjukkan secara utuh source codenya. Termasuk import modul turtle. Dan dibagian akhir adalah dengan memanggil function draw().

Berikut source code keseluruhan:

import turtle

def triangle_1(some_pen,size):
    some_pen.begin_fill()
    some_pen.right(60)
    for i in range(1,3):
        some_pen.forward(size)
        some_pen.right(120)
    some_pen.forward(size)
    some_pen.end_fill()

def triangle_2(some_pen,size):
    triangle_1(some_pen,size)
    some_pen.right(120)
    some_pen.forward(size)
    some_pen.left(60)
    triangle_1(some_pen,size)
    some_pen.left(120)
    some_pen.forward(size)
    some_pen.right(180)
    triangle_1(some_pen,size)
    some_pen.forward(size)

def triangle_3(some_pen,size):
    triangle_2(some_pen,size)
    some_pen.right(120)
    some_pen.forward(2*size)
    some_pen.left(60)
    triangle_2(some_pen,size)
    some_pen.left(120)
    some_pen.forward(2*size)
    some_pen.right(180)
    triangle_2(some_pen,size)
    some_pen.forward(2*size)

def triangle_4(some_pen,size):
    triangle_3(some_pen,size)
    some_pen.right(120)
    some_pen.forward(2*2*size)
    some_pen.left(60)
    triangle_3(some_pen,size)
    some_pen.left(120)
    some_pen.forward(2*2*size)
    some_pen.right(180)
    triangle_3(some_pen,size)
    some_pen.forward(2*2*size)

def draw():
    window = turtle.Screen()
    window.bgcolor("red")

    pen = turtle.Turtle()

    pen.penup()
    pen.sety(100)
    pen.pendown()

    pen.shape("turtle")
    pen.color("blue")
    pen.speed(1)

    triangle_4(pen,20)

    window.exitonclick()

draw()

Berikut adalah hasil runningnya:

Dengan menggunakan kode diatas kita juga dapat memodifikasi untuk membuat segitiga serupa yang lebih besar tingkatannya, namun harus menambah kode misal triangle_5, triangle_6, dst. 

Teman-teman juga dapat menyederhanakan koding tersebut dengan teknik rekursif. Dengan teknik rekursif maka akan lebih simple jika kita menginginkan gambar pada tingkat tertentu.

Developed by: 

Muhammad Nurul Puji

Project-H

Bilangan Prima (SCILAB)

Dalam matematika, bilangan prima adalah bilangan asli yang lebih besar dari angka 1, yang faktor pembaginya adalah 1 dan bilangan itu sendiri. 2 dan 3 adalah bilangan prima. 4 bukan bilangan prima karena 4 bisa dibagi 2. Sepuluh bilangan prima yang pertama adalah 2, 3, 5, 7, 11, 13, 17, 19, 23 dan 29. (https://id.wikipedia.org/wiki/Bilangan_prima)

Kali ini Saya share code untuk memperoleh 100 bilangan prima pertama dengan menggunakan Scilab. Ada beberapa code yang Saya tampilkan di sini, untuk membandingkan seberapa cepat dan efektif code tersebut untuk memperoleh 100 bilangan prima pertama.

code pertama:

1. Asumsi awal semua bilangan dianggap sebagai bilangan prima.

2. Kemudian bilangan tersebut dicek dengan cara dibagi dengan semua bilangan bulat sebelumnya (yang lebih kecil). Jika sisa pembagian (modulo) ada yang sama dengan nol maka bilangan tersebut bukan bilangan prima. Atau Jika sisa pembagian (modulo) tidak ada yang sama dengan nol maka bilangan tersebut adalah bilangan prima.

3. Step 1 dan 2 dilakukan berulang-ulang sampai diperoleh 100 bilangan prima.

clear
clc

tic()

i=1;
x=2;
prima(i)=x
while (i<100)
    i=i+1;
    x=x+1;
    prima(i)=x
    for j=2:(x-1)
        sisa=modulo(x,j);
        if(sisa==0) then
            i=i-1;
            break;
        end
    end
end
disp(prima)

disp(toc())

code kedua:

1. Asumsi awal semua bilangan dianggap sebagai bilangan prima.

2. Kemudian bilangan tersebut dicek dengan cara dibagi dengan semua bilangan prima sebelumnya (yang lebih kecil). Jika sisa pembagian (modulo) ada yang sama dengan nol maka bilangan tersebut bukan bilangan prima. Atau Jika sisa pembagian (modulo) tidak ada yang sama dengan nol maka bilangan tersebut adalah bilangan prima.

3. Step 1 dan 2 dilakukan berulang-ulang sampai diperoleh 100 bilangan prima.

clear
clc

tic()

i=1;
x=2;
prima(i)=x
while (i<100)
    i=i+1;
    x=x+1;
    prima(i)=x
    for j=1:(i-1)
        sisa=modulo(x,prima(j));
        if(sisa==0) then
            i=i-1;
            break;
        end
    end
end
disp(prima)

disp(toc())
 

code ketiga:

1. Asumsi awal semua bilangan dianggap sebagai bilangan prima.

2. Kemudian bilangan tersebut dicek dengan cara dibagi dengan semua bilangan prima sebelumnya yang nilainya maksimal setengah dari bilangan yang dicek. Jika sisa pembagian (modulo) ada yang sama dengan nol maka bilangan tersebut bukan bilangan prima. Atau Jika sisa pembagian (modulo) tidak ada yang sama dengan nol maka bilangan tersebut adalah bilangan prima.

3. Step 1 dan 2 dilakukan berulang-ulang sampai diperoleh 100 bilangan prima.

clear
clc

tic()

i=1;
k=i;
x=2;
prima(i)=x
while (i<100)
    i=i+1;
    x=x+1;
   
    if (ceil(x/2)>prima(k)) then        //ceil==>pembulatan ke atas
        k=k+1;
    end
   
    prima(i)=x
    for j=1:k
        sisa=modulo(x,prima(j));
        if(sisa==0) then
            i=i-1;
            break;
        end
    end
end
disp(prima)

disp(toc())
 

Hasil:

Berikut screenshot hasil 100 bilangan prima pertama yang diperoleh. (setelah di arrange dalam bentuk matriks 10x10, kalo dalam MATLAB bisa menggunakan fungsi reshape)

Hasil Running 100 bilangan prima pertama (setelah di arrange dalam matriks 10x10)

Perbandingan konsumsi waktu untuk ketiga code tersebut: (aproximately)

code pertama: 5.878969 s

code kedua  : 1.398557 s

code ketiga : 0.939001 s

Yang terakhir dibuat dalam bentuk function untuk bisa memperoleh bilangan prima ke n. 

dalam bentuk function:

function [y]= bil_prima(ke)

i=1;
k=i;
x=2;
prima(i)=x
while (i<ke)
    i=i+1;
    x=x+1;
   
    if (ceil(x/2)>prima(k)) then        //ceil==>pembulatan ke atas
        k=k+1;
    end
   
    prima(i)=x
    for j=1:k
        sisa=modulo(x,prima(j));
        if(sisa==0) then
            i=i-1;
            break;
        end
    end
end
y=prima(ke);

endfunction

cara pemanggilan function:

//cara memanggil function

clear
clc

exec('/home/muhammadpuji/Desktop/Scilab/Belajar/05_function_bil_prima.sce', -1)         //mengaktifkan function bil_prima(ke)

tic()
ke=100;
y=bil_prima(ke);
disp(strcat(["Bilangan prima ke ",string(ke)," = ",string(y)],"","c"));

disp(strcat([string(toc()), " s"]));




Developed by:
Muhammad Nurul Puji
Project-G

SCILAB: Aplikasi modifikasi isi file (sederhana)

Scilab is free and open source software for numerical computation providing a powerful computing environment for engineering and scientific applications. Scilab is released as open source under the CeCILL license (GPL compatible), and is available for download free of charge. Scilab is available under GNU/Linux, Mac OS X and Windows XP/Vista/7/8 (see system requirements).

Pada postingan kali ini, Sy share mengenai cara memodifikasi isi file tertentu (misal txt). Kasus awalnya adalah terkadang kita memiliki file dengan isi yang bercampur antara header (judul file) dengan isi file (bagian utama) dari file itu sendiri. Sedangkan untuk proses (misal pengolahan data) yang diperlukan hanya bagian utama dari isi file tersebut saja, sehingga bagian header malah akan mengganggu proses pengolahan data tersebut.

Contoh isi file yang bercampur antara bagian isi dengan header

Oleh karena itu perlu dilakukan penghilangan bagian header dari file itu sendiri. Secara sederhana hal ini dapat dilakukan dengan mengetahui bahwa bagian header selalu di awali dengan non number (bisa huruf atau spasi - bukan number).

Inti dari kode yang Sy buat disini adalah dilakukan pembacaan file yang akan di edit, pembacaan dilakukan baris by baris. Yang mana pada masing masing baris akan dilakukan pengecekan apakah pada bagian pertamanya berupa number atau non number. Dan jika pada bagian pertamanya berupa non number maka baris tersebut akan dicopy ke file baru (file baru untuk menyimpan hasil editan). Hal ini dilakukan sampai akhir baris dari file tersebut.

Berikut adalah source code menggunakan Scilab + GUI.

Desain GUI menggunakan guibuilder (Atoms tambahan di Scilab)

Source code 1

Source code 2

Berikut adalah tampilan saat running:

Tampilan awal

Select file

Loading file

Processing file

Finish

Program ini akan sangat membantu untuk mengedit file dengan jumlah baris yang sangat banyak. Kalo sedikit kan tinggal didelete biasa.hehehe

Berikut adalah hasil output file setelah diedit menggunakan program di atas:

Developed by: 

Muhammad Nurul Puji

Project-G

Sherlock and The Beast (Algorithms)

Sherlock and The Beast

Problem Statement

Sherlock Holmes is getting paranoid about Professor Moriarty, his arch-enemy. All his efforts to subdue Moriarty have been in vain. These days Sherlock is working on a problem with Dr. Watson. Watson mentioned that the CIA has been facing weird problems with their supercomputer, 'The Beast', recently.

This afternoon, Sherlock received a note from Moriarty, saying that he has infected 'The Beast' with a virus. Moreover, the note had the number N printed on it. After doing some calculations, Sherlock figured out that the key to remove the virus is the largest Decent Number having N digits.

A Decent Number has the following properties:

1. 3, 5, or both as its digits. No other digit is allowed.
2. Number of times 3 appears is divisible by 5.
3. Number of times 5 appears is divisible by 3.

Meanwhile, the counter to the destruction of 'The Beast' is running very fast. Can you save 'The Beast', and find the key before Sherlock?
Input Format
The 1^st line will contain an integer T, the number of test cases. This is followed by T lines, each containing an integer N. i.e. the number of digits in the number.
Output Format
Largest Decent Number having N digits. If no such number exists, tell Sherlock that he is wrong and print −1.
Constraints
1≤T≤20
1≤N≤100000

Sample Input

4
1
3
5
11

Sample Output

-1
555
33333
55555533333

Explanation
For N=1, there is no such number.
For N=3, 555 is the only possible number.
For N=5, 33333 is the only possible number.
For N=11, 55555533333 and all permutations of these digits are valid numbers; among them, the given number is the largest one.

Solusi
Setelah beberapa kali coba dan gagal akhirnya berikut ini adalah kode yang diterima (accepted).

#include <iostream>
using namespace std;

int main(){
    int T;
    long int N, buff_N, jumlah_3, jumlah_5;
    bool isTrue;
   
    cin >> T;
    while(T--){
        cin >> N;
        buff_N=N;
        jumlah_3=0;
        jumlah_5=0;
        isTrue=true;
        while(buff_N>0){
            if(buff_N%3==0){
                jumlah_3=buff_N/3;
                buff_N=0;
            }
            else{
                buff_N-=5;
                jumlah_5++;
            }
        }
        if(buff_N<0) isTrue=false;
       
        if(isTrue){
            while(jumlah_3--) cout << "555";
            while(jumlah_5--) cout << "33333";
            cout << endl;
        }else cout << "-1" << endl;
       
    }
    return 0;
}

Penjelasan source code:
Intinya nilai N akan dikurangi dengan angka 5 secara terus menerus apabila N bukan kelipatan dari 3 dan nilai N lebih besar dari 0. Jika ternyata hasil akhirnya tidak 0 (kurang dari 0) berarti salah (isTrue=false).

source: https://www.hackerrank.com/challenges/sherlock-and-the-beast