E-Sources Informatics

import jeliot.io.*;

public class kpk {
  
         
      
          int a,b,nilai;


          public void masukan() { 
          System.out.print("Menghitung KPK"); 
          
          nilai=0;
           System.out.print("Masukkan A: "); a=Input.readInt();
          System.out.print("Masukkan B: "); b=Input.readInt();
          for (int z=1; z<=b; z++) {
          nilai=nilai+a;
          if (nilai%b==0) {
          System.out.print("KPK dari ");
          System.out.print(a);
        System.out.print(" dan ");
         System.out.print(b);
          System.out.print(" adalah ");
          System.out.print(nilai);
       

          }
          }
    }

          public static void main () {
          kpk X = new kpk();  
         X.masukan();

          }

}

//This example shows the possible use
//of Scanner methods, and basic object
//oriented features.
import java.util.Scanner;

//This class defines a basic bank account
class BankAccount{
  String ownerName;
  long accountID;
  double balance;

  //Default constructor that asks for missing information
  BankAccount(){
    Scanner read = new Scanner(System.in);
    this.ownerName = read.next();
    this.accountID = read.nextLong();
    this.balance = read.nextDouble(); 
  }
  //Constructor with parameters
  BankAccount(String name, long accountID, double balance){
    this.ownerName = name;
    this.accountID = accountID;
    this.balance = balance; 
  }
  //Deposit adds an amount to the balance
  public void deposit(double amount){
     this.balance += amount;
  }
  //Withdraw an amount to the balance, 
  //and returns a boolean indicating
  //the success of the operation  
  public boolean withdraw(double amount){
     boolean withdrawn = false;
     if (balance > amount){
       balance -= amount;
       withdrawn = true;
       System.out.println("Amount withdrew succesfully");
    } else {
       System.out.println("Not enough funds");
    }
    return withdrawn;
  }
}


public class MyClass {
  public static void main() {
    Scanner read = new Scanner(System.in);
    String name = read.next();
    long accountID = read.nextLong();
    double initialDeposit = read.nextDouble(); 
    BankAccount ba = new BankAccount(
            name, accountID, initialDeposit); 
    ba.withdraw(read.nextDouble());
  }
    
}

jeliot.io import .*;

public class Numbers {
     public Num (int x) {/ / constructor
         a = x;
     }
     public static void swap (Num a, Num b) {
          int temp;
          temp = a.a;
          a.a = b.a;
          b.a = temp;
     }
     public final void output () {
          System.out.println ("number:" + a);
     }
     private int a;

public static void main () {
        System.out.println ("\ nUsing class \ n");
        Numbers x1 = new Numbers (5);
        Numbers y1 = new Numbers (6);
        x1.output ();
        y1.output ();
        swap (x1, y1);
        System.out.println ("\ nAfter swap disposable class: \ n");
        x1.output ();
        y1.output ();
    }
}

import jeliot.io.*;

public class Statistik {

public static int nilai_Maksimum(int data[]) {
    int maks = data[0];
    int n = data.length;
    int modus;
    
    for (int i=1; i<n; i++)
        if (maks < data[i]) { 
            maks = data[i];
            modus = i;        
        }
    System.out.println("Modusnya adalah " + modus);
    return maks;
}

public static void hitung_Frekuensi() {
     int data[] = {1,1,2,2,2,2,2,3,3,4,5,5,5,5};
     int i, n = data.length;     
     int [] f = new int[10];
     int nilai_terbesar;

     for (i=0; i<n; i++) ++f[data[i]];
     for (i=0; i<10; i++) 
         System.out.println("Data " + i + " sebanyak " + f[i]);
     nilai_terbesar = nilai_Maksimum(f);
     System.out.println("Dengan frekuensi = " + nilai_terbesar);
}

    public static void main() {
    hitung_Frekuensi();

    }
}

import java.util.scaner.io.*;

public class modus{
public static void main(String[]args){
    int banyak;
    int data[];
    int temp;
    int jumlah = 0;

    System.out.print("Banyaknya data : ");
    banyak =Input.nextInt();
    data = new int[banyak];
    for(int i=0;i<=banyak-1;i++){
        System.out.print("Data ke-"+(i+1)+": ");
        data[i]=Input.nextInt();
    }
    
    System.out.print("Data sudah diurut : ");
    for(int i=0; i<=banyak-1; i++) {
        System.out.print(data[i]+" ");
        jumlah=jumlah + data[i];
    }

    int hasil=0;
    int besar=0;
    for (int i=0; i<data.length ;i++){
        if(data[i]==banyak){
        System.out.print(data[i]+" ");
        System.out.print(++temp);
            if(temp>besar){
                besar=temp;
                hasil=banyak;
            }
        }
        else{
            banyak=data[i];
            temp=1;
            System.out.print(data[i]+" ");
            System.out.print(temp);
            }
        }
        System.out.print("Modus ="+hasil);
    }
}

import jeliot.io.*;

public class mergeSort{
  public static void main(String a[]){
    int i;
    int array[] = {12,9,4,7,15,1,3,10};
    System.out.println("\n\n       RoseIndia\n\n");
    System.out.println("       Merge Sort\n\n");
    System.out.println("Values Before the sort:\n");
    //for(i = 0; i < array.length; i++)
      //System.out.print( array+"  ");
    System.out.println();
    mergeSort_srt(array,0, array.length-1);
    System.out.print("Values after the sort:\n");
    for(i = 0; i <array.length; i++)
      System.out.print(array+"  ");
    System.out.println();
    System.out.println("PAUSE");
  }

  public static void mergeSort_srt(int array[],int lo, int n){
    int low = lo;
    int high = n;
    if (low >= high) {
      return;
    }

    int middle = (low + high) / 2;
    mergeSort_srt(array, low, middle);
        mergeSort_srt(array, middle + 1, high);
    int end_low = middle;
    int start_high = middle + 1;
    while ((lo <= end_low) && (start_high <= high)) {
      if (array[low] < array[start_high]) {
        low++;
            } else {
        int Temp = array[start_high];
        for (int k = start_high- 1; k >= low; k--) {
          array[k+1] = array[k];
        }
                array[low] = Temp;
                low++;
                end_low++;
                start_high++;
            }
        }
    }  
}

import jeliot.io.*;

public class Sorting {
    public static void main() {
       
int []a = new int [20];
int cur,x,temp,cur2,temp2;

System.out.print("Banyak Data : ");
x=Input.readInt();
    for(int i=0;i<x;i++){
    System.out.print("Data [");
    System.out.print(i+1);
    System.out.print("] : ");
    a[i]=Input.readInt();
    }
    for(int i=0;i<x;i++){
    cur=i;
    cur2=x;
    for(int k=i+1;k<x;k++){
            if(a[cur]>a[k]){
            cur=k;
            }
    }
    for(int t=x;t<x;t--){
            if(a[cur2]<a[t]){
            cur2=t;
            }
    
    temp2=a[t];
    a[t]=a[cur2];
    a[cur2]=temp2;
    }
    
    temp=a[i];
    a[i]=a[cur];
    a[cur]=temp;
    }
    for(int i=0;i<x;i++){
    System.out.print(" ");
    System.out.print(a[i]);
    }

System.out.print(" \n ");



    }
}

import jeliot.io.*;

public class QuickSort{
  public static void main(String a[]){
    int i;
    int array[] = {12,9,4,29,7,1,3,10};
    System.out.println("Values Before the sort:\n");
    //for(i = 0; i < array.length; i++)
      //System.out.print( array+"  ");
    System.out.println();
    quickSort(array,0,7);
    System.out.print("Values after the sort:\n");
    for(i = 0; i <array.length; i++)
      System.out.print(array+"  ");
    System.out.println();
    System.out.println("PAUSE");
  }

 public static int partition(int arr[], int left, int right) { 
      int i = left, j = right; 
      int tmp; 
      int pivot = arr[(left + right) / 2]; 

      while (i <= j) { 
            while (arr < pivot) 
                  i++; 
            while (arr[j] > pivot) 
                  j--; 
            if (i <= j) { 
                  tmp = arr; 
                  arr = arr[j]; 
                  arr[j] = tmp; 
                  i++; 
                  j--; 
            } 
      }; 
      return i; 
    } 

 *    the area of the intersection of two spots.
 */
public class Spot {
    //instance variables
    public int x, y;
    private double radius;
    private double area;
    //constructor
    public Spot() {
    }

    public Spot(int x, int y, double radius){
        this.x = x;
        this.y = y;
        this.radius = radius;
        this.setArea();
    }
    
    //methods for access to the size instance variable    
    public void setRadius(double newRadius) {
        if (newRadius >= 0.0) {
            radius = newRadius;
            this.setArea();
        }        
    } 
    
    public int getRadius() {
        return radius;
    }
    
    private void setArea(){
        this.area = Math.PI * Math.pow(radius,2.0);
    }
    public double getArea() {
        return area;
    }
        
    public static void main(String[] argv){
        Spot outter = new Spot();
        outter.setRadius(3.0);
        Spot inner = new Spot (0,0,2.0);

        double intersection = outter.getArea()-inner.getArea();
        System.out.println(intersection);
    }
}

import jeliot.io.*;

public class MyClass {

public static boolean isPalindrome(String word) {
    int left  = 0;                 // index of leftmost unchecked char
    int right = word.length() -1;  // index of the rightmost
  
    while (left < right) {         // continue until they reach center
        if (word.charAt(left) != word.charAt(right)) {
            return false;          // if chars are different, finished
        }
        left++;                    // move left index toward the center
        right--;                   // move right index toward the center
    }
  
    return true;                   // if finished, all chars were same
}

    public static void main() {
    if (isPalindrome("Kasr"))
        System.out.println("Palindrome");
    else
        System.out.println("Bukan Palindrome");

    }
}

Berikut ini adalah program Big Integer versi Jeliot. Semoga bermanfaat :)

import jeliot.io.*;

public class bigInteger {
    int []A = new int [1,2,3,4,5,6,7,8,9];
    int []B = new int [1,2,3,4,5,6,7,8,9];
    int n,m;
    int []jumlah = new int [20];
    
   
      
    public void cetak_big(){
     System.out.print("masukkan jumlah bilangan = ");
     n=Input.readInt();
     System.out.print("\nbilangan 1 \n");
     for (int i=0;i<n;i++){
     System.out.print("angka ke - [ ");
     System.out.print(i+1);
     System.out.print("] = ");
     A[i]=Input.readInt();
     }
     
     System.out.print("\nbilangan 2 \n");
     for (int i=0;i<n;i++){
     System.out.print("angka ke - [ ");
     System.out.print(i+1);
     System.out.print("] = ");
     B[i]=Input.readInt();
     }
     }
     
    public void cetak_jumlahbig(){
     for(int i=n; i>=0; i--){
     jumlah[i]=A[i]+B[i];
     if(jumlah[i]>9){
     jumlah[i]=x % 10;
     jumlah[i-1]=jumlah[i-1]+1;
     System.out.print(jumlah[i]);
     }
     
     if(jumlah[i]<=9){
     System.out.print(jumlah[i]);
     }
     }
     }
    
    public static void main() {
     bigInteger x = new bigInteger();
     x.cetak_big();
     x.cetak_jumlahbig();
     
   
}
}

Program Mencari Luas Lingkaran

import jeliot.io.*;

public class luas_lingkaran {
       
      public void masukan()
      {
           System.out.print("masukkan r = ");
           r = Input.readInt();
      }
      public void hitung_luas() {
          
           System.out.print("luas lingkaran =  ");
           System.out.print(Luas=3.14*r*r);
      }

private int r;
private float Luas;
        
    public static void main() {
        luas_lingkaran x = new luas_lingkaran();
        x.masukan();
        x.hitung_luas();
    }
}

import jeliot.io.*;

public class volume_bola {
       
      public void masukan()
      {
           System.out.print("masukkan r = ");
           r = Input.readInt();
      }
      public void hitung_volume() {
          
           System.out.print("volume bole =  ");
           System.out.print(v=4/3*(3.14*r*r*r));
      }

private int r;
private float v;
        
    public static void main() {
        volume_bola x = new volume_bole();
        x.masukan();
        x.hitung_volume();
    }
}

Program menentukan tahun kabisat versi Jeliot :

import jeliot.io.*;

public class MyClass {
    public static void main() {
        int n;
        
        System.out.print("masukkan tahun : ");
        n=Input.readInt();
        
        if (n % 4==0)
        {
        System.out.print("tahun ");
        System.out.print(n);
        System.out.print(" adalah ");
        System.out.print("tahun kabisat");}
        else
        {
        System.out.print("tahun ");
        System.out.print(n);
        System.out.print(" bukan kabisat");}

    }
}

import jeliot.io.*;

public class MyClass {
    public static void main() {
int i;
int n;
int faktor=0;

System.out.print("Masukan bilangan n= ");
n=Input.readInt();

for(i=1;i<=n;i++){
if(n%i==0)
{faktor++;}
}
if(faktor==2)
{System.out.print("bilangan ");
System.out.print(n);
System.out.print(" bilangan prima");}

else
{System.out.print("bilangan ");
System.out.print(n);
System.out.print(" bukan bilangan prima");}

}
}

import jeliot.io.*;

public class Strings{
  //Scramble returns a string with the scrambled characters of the
  //two strings
  public static String scramble(String s1, String s2){
    String result = new String();
    int length = (s1.length() < s2.length())? s1.length():s2.length();
    for(int i=0; i < length; i++){
	result += String.valueOf(s1.charAt(i)) + String.valueOf(s2.charAt(i));
    }
    return result;
  }

  public static void main(String [] argv){
      //Enter two, preferably short, strings to be scrambled
      String s1 = Input.readString();
      String s2 = Input.readString();
      
      System.out.println(scramble(s1,s2));
  }
}

import jeliot.io.*;

public class MergeSortAlgorithm {

    public static void main() {
        int [] data  = new int [5];
        for (int i=0; i < data.length; i++) {
            data[i] = (int) (20 * Math.random());
        }
        sort(data, 0, data.length - 1);
    }
    

    public static void sort(int a[], int lo, int hi) {
        if (lo >= hi) {
            return;
        }
        int mid = (lo + hi) / 2;
    
        sort(a, lo, mid);
        sort(a, mid + 1, hi);
    
        int end_lo = mid;
        int start_hi = mid + 1;
    
        while ((lo <= end_lo) && (start_hi <= hi)) {
            if (a[lo] < a[start_hi]) {
                lo++;
            } else {
                int T = a[start_hi];
        
                for (int k = start_hi - 1; k >= lo; k--) {
                    a[k+1] = a[k];
                }
                a[lo] = T;
                lo++;
                end_lo++;
                start_hi++;
            }
        }
    }
}

import jeliot.io.*;

public class Polygon {
    int sides;

    Polygon() {
    }

    Polygon(int s) {
        sides = s;
    }

    public int getSides() {
        return sides;
    }
}

public class Rectangle extends Polygon {
    int width, heigth;

    Rectangle() {
        super(4);
        width = 0;
        heigth = 0;
    }

    Rectangle(int w, int h) {
        super(4);
        width = w;
        heigth = h;
    }

    public int getArea() {
        return width * heigth;
    }
}

public class Square extends Rectangle {
    int side;

    Square() {
        side = 0;
    }

    Square(int s) {
        super(s, s);
        side = s;
    }
}

public class MyClass {
    public static void main() {
        Square square;
        square = new Square(3);
        int area = square.getArea();
        System.out.println("The area of the square is " + area);
    }
}