Kriptografi Klasik Caesar Cipher dan Implementasinya dengan Pemrograman Python

Kriptografi, sebagai ilmu dan seni mengamankan informasi rahasia, telah menjadi bagian tak terpisahkan dari sejarah manusia. Sebelum era computer modern, algoritma kriptografi disebut sebagai kriptografi klasik. Kriptografi klasik adalah cara orang-orang terdahulu melindungi pesan rahasia mereka dan juga menjadi landasan bagi pengembangan teknik kriptografi modern yang lebih kompleks saat ini. Salah satu bentuk kriptografi klasik yang paling terkenal adalah sandi substitusi. Dalam sandi substitusi, setiap huruf dalam pesan digantikan dengan huruf lain berdasarkan aturan tertentu. Sebagai contoh, salah satu bentuk sandi substitusi yang terkenal adalah sandi Caesar Cipher, yang dinamai dari Julius Caesar. Dalam sandi ini, setiap huruf digeser sejumlah langkah tertentu dalam alfabet. Misalnya, jika geserannya adalah 3, maka huruf A akan digantikan dengan huruf D, huruf B dengan huruf E, dan seterusnya. Pesan yang telah dienkripsi dengan sandi Caesar hanya dapat dibaca oleh orang yang mengetahui aturan geseran tersebut. Namun, sandi substitusi memiliki kelemahan yang dapat dieksploitasi. Jika seseorang berhasil menebak aturan penggantian yang digunakan, mereka dapat dengan mudah membaca pesan yang dienkripsi. Berikut ini implementasi sandi Caesar Cipher dengan pemrograman python.

def encrypt(text, shift):
encrypted_text = ""
for char in text:
if char.isalpha():
if char.islower():
encrypted_text += chr((ord(char) - ord('a') + shift) % 26 + ord('a'))
else:
encrypted_text += chr((ord(char) - ord('A') + shift) % 26 + ord('A'))
else:
encrypted_text += char
return encrypted_text

def decrypt(encrypted_text, shift):
decrypted_text = ""
for char in encrypted_text:
if char.isalpha():
if char.islower():
decrypted_text += chr((ord(char) - ord('a') - shift) % 26 + ord('a'))
else:
decrypted_text += chr((ord(char) - ord('A') - shift) % 26 + ord('A'))
else:
decrypted_text += char
return decrypted_text
plain_text = input("Masukkan pesan: ")
shift_amount = int(input("Masukkan jumlah pergeseran(Sandi): "))
encrypted = encrypt(plain_text, shift_amount)
print("Pesan terenkripsi:", encrypted)
decrypted = decrypt(encrypted, shift_amount)
print("Pesan terdekripsi:", decrypted)

Source Code Python untuk Mencari Luas dan Keliling

Berikut ini source code python untuk contoh mencari luas dan keliling suatu bidang. silakan dikoreksi atau dimodifikasi apabila terdapat kesalaha.

import math

def calculate_area(shape):
if shape == "persegi":
side = float(input("Panjang sisinya yaitu: "))
area = side ** 2
print("Luas persegi ini adalah:", area)
elif shape == "segitiga":
side1 = float(input("Panjang sisi pertama: "))
side2 = float(input("Panjang sisi kedua: "))
side3 = float(input("Panjang sisi ketiga: "))
s = (side1 + side2 + side3) / 2
area = math.sqrt(s * (s - side1) * (s - side2) * (s - side3))
print("Luas segitiga ini adalah:", area)
elif shape == "lingkaran":
radius = float(input("Jari-jari lingkarannya: "))
area = math.pi * radius ** 2
print("Luas lingkaran ini adalah:", area)
else:
print("Maaf kami tidak menemukan bidang yang dimaksud.")

def calculate_circumference(shape):
if shape == "persegi":
side = float(input("Panjang sisinya adalah: "))
circumference = 4 * side
print("Keliling persegi ini adalah:", circumference)
elif shape == "segitiga":
side1 = float(input("Masukkan panjang sisi pertama: "))
side2 = float(input("Masukkan panjang sisi kedua: "))
side3 = float(input("Masukkan panjang sisi ketiga: "))
circumference = side1 + side2 + side3
print("Keliling segitiga ini adalah:", circumference)
elif shape == "lingkaran":
radius = float(input("Jari-jari lingkaran yang akan dihitung kelilingnya: "))
circumference = 2 * math.pi * radius
print("Keliling lingkaran ini adalaha:", circumference)
else:
print("Maaf, kami tidak menemukan bidang ini.")

shape = input("masukkan bidang yang akan dihitung: ")
calculate_area(shape)
calculate_circumference(shape)

Uji ANOVA dengan menggunakan Python

 Berikut ini contoh source code Python untuk uji ANOVA

import scipy.stats as stats

# definisikan data setiap grup
grup1 = [1, 2, 3, 4, 5]
grup2 = [2, 4, 6, 8, 10]
grup3 = [3, 6, 9, 12, 15]

# Lakukan uji ANOVA
f_statistic, p_value = stats.f_oneway(grup1, grup2, grup3)

# definisikan derajat kebebasan
df_between = 2
df_within = 12

# definisikan level signifikansi
alpha = 0.05

# hitung nilai kritis F
f_critical = stats.f.ppf(1 - alpha, df_between, df_within)

# tampilkan hasilnya
print("F-statistic:", f_statistic)
print("p-value:", p_value)
print("Critical F-value:", f_critical)

Jika nilai F-statistik (F-statistic) lebih besar dari nilai F-kritis (critical F-value), hipotesis nol ditolak sehingga tidak ada perbedaan signifikan dalam rata-rata tiap grup.

Source Code Metode Beda Hingga dengan R

Pada code berikut ini persamaan yang dipakai adalah m * d^2x/dt^2 + k * x = 0. Sebelum running program, pastikan sudah menginstall package deSolve.

library(deSolve)
# Function defining the ODE system
ode_function <- function(t, y, parameters) {
  # Extract the variables
  x <- y[1]
  v <- y[2]
  # Extract the parameters
  k <- parameters$k
  m <- parameters$m
  # Definisikan ODEs
  dxdt <- v  # dx/dt = v
  dvdt <- -k/m * x  # dv/dt = -k/m * x
  
  # Return the derivatives
  return(list(c(dxdt, dvdt)))
}

# Tetapkan kondisi awal dan parameter
initial_conditions <- c(x = 1, v = 0)  # posisi awal san kecepatan
parameters <- list(k = 1, m = 1)  # kontstanta pegas dan massa
# Set time points for integration
time_points <- seq(0, 10, by = 0.1)
# Selesaikan sistem ODE dengan metode beda hingga
solution <- ode(initial_conditions, time_points, ode_function, parameters)
# Extract the position values from the solution
positions <- solution[, "x"]
# Plot hasil simulasi
plot(time_points, positions, xlab = "Time", ylab = "Position", type = "l", main = "Simulation Results")

Source Code Algoritma Genetika dengan Python

 import numpy as np

# Inisialisasi populasi awal
def initialize_population(population_size, chromosome_length):
population = np.random.randint(2, size=(population_size, chromosome_length))
return population

# Evaluasi fitness individu
def fitness_function(chromosome):
# Misalkan kita ingin memaksimalkan jumlah bit yang bernilai 1
return np.sum(chromosome)

# Evaluasi fitness populasi
def evaluate_population(population):
fitness_values = np.zeros(len(population))
for i in range(len(population)):
fitness_values[i] = fitness_function(population[i])
return fitness_values

# Seleksi orangtua menggunakan turnamen
def tournament_selection(population, fitness_values, tournament_size):
selected_parents = np.zeros((2, len(population[0])))
for i in range(2):
tournament_indices = np.random.choice(len(population), tournament_size, replace=False)
tournament_fitness = fitness_values[tournament_indices]
winner_index = tournament_indices[np.argmax(tournament_fitness)]
selected_parents[i] = population[winner_index]
return selected_parents

# Crossover menggunakan satu titik potong
def crossover(parents):
crossover_point = np.random.randint(1, len(parents[0]))
child1 = np.concatenate((parents[0][:crossover_point], parents[1][crossover_point:]))
child2 = np.concatenate((parents[1][:crossover_point], parents[0][crossover_point:]))
return child1, child2

# Mutasi dengan probabilitas mutasi
def mutation(chromosome, mutation_rate):
for i in range(len(chromosome)):
if np.random.rand() < mutation_rate:
chromosome[i] = 1 - chromosome[i] # Flip the bit
return chromosome

# Algoritma genetika
def genetic_algorithm(population_size, chromosome_length, tournament_size, mutation_rate, num_generations):
population = initialize_population(population_size, chromosome_length)
best_fitness = np.zeros(num_generations)

for generation in range(num_generations):
fitness_values = evaluate_population(population)
best_fitness[generation] = np.max(fitness_values)

selected_parents = tournament_selection(population, fitness_values, tournament_size)
new_population = np.zeros((population_size, chromosome_length))

for i in range(0, population_size, 2):
child1, child2 = crossover(selected_parents)
new_population[i] = mutation(child1, mutation_rate)
new_population[i+1] = mutation(child2, mutation_rate)

population = new_population

best_chromosome = population[np.argmax(fitness_values)]
return best_chromosome, best_fitness

# Pengaturan parameter
population_size = 100
chromosome_length = 20
tournament_size = 5
mutation_rate = 0.01
num_generations = 100

# Menjalankan algoritma genetika
best_chromosome, best_fitness = genetic_algorithm(population_size, chromosome_length, tournament_size, mutation_rate, num_generations)

# Output hasil
print("Best Chromosome:", best_chromosome)
print("Best Fitness:", np.max(best_fitness))

Source Code Python Metode Beda Hingga

import numpy as np
import matplotlib.pyplot as plt

def finite_difference_method(x_start, x_end, num_points, initial_condition, boundary_condition):
# Inisialisasi parameter
delta_x = (x_end - x_start) / (num_points - 1)
x = np.linspace(x_start, x_end, num_points)
u = np.zeros(num_points)
u[0] = boundary_condition[0]
u[-1] = boundary_condition[1]

# Iterasi menggunakan metode beda hingga
for i in range(1, num_points - 1):
u[i] = u[i-1] + initial_condition(x[i]) * delta_x

return x, u

# Fungsi persamaan diferensial: u'(x) = x^2 + sin(x)
def initial_condition(x):
return x**2 + np.sin(x)

# Contoh batasan: u(0) = 0, u(1) = 1
boundary_condition = (0, 1)

# Parameter untuk grid
x_start = 0
x_end = 1
num_points = 100

# Menggunakan metode beda hingga
x, u = finite_difference_method(x_start, x_end, num_points, initial_condition, boundary_condition)

# Plot hasil solusi numerik
plt.plot(x, u, label='Numerical Solution')
plt.xlabel('x')
plt.ylabel('u(x)')
plt.title('Finite Difference Method')
plt.legend()
plt.grid(True)
plt.show()

Output Program f(x)=x^2+sin(x)

Source Code Python Untuk Menyelesaikan Integral Tentu

 import sympy as sp

# masukkan fungsi yang akan diintegralkan dan batas integralnya
f_input = input("Masukkan fungsi yang akan diintegralkan: ")
a_input = float(input("Masukkan batas bawah Integralnya: "))
b_input = float(input("Masukkan batas atas Integralnya: "))

# definisikan variabel dan fungsi menggunakan input sebelumnya
x = sp.Symbol('x')
f = sp.sympify(f_input)

# hitung integral tentu
integral = sp.integrate(f, (x, a_input, b_input))

# Print hasilnya
print("Integral tentu dari", f, "dari", a_input, "ke", b_input, "adalah:", integral)