(ns inspirational-quotes.core
(:require [clojure.string :as str]))

(def quotes
[“The only way to do great work is to love what you do. – Steve Jobs”
“Life is what happens when you’re busy making other plans. – John Lennon”
“The purpose of our lives is to be happy. – Dalai Lama”
“Get busy living or get busy dying. – Stephen King”
“You only live once, but if you do it right, once is enough. – Mae West”
“In the end, we only regret the chances we didn’t take. – Lewis Carroll”])

(defn get-random-quote []
(rand-nth quotes))

(defn -main []
(let [quote (get-random-quote)]
(println quote)))

ctl-srv qcmd “CRTDUP OBJ(*FILE) FILE(MYLIB/QUOTES) RCDLEN(256) REUSEDUP(*YES)”

dcl-f Quotes workstn

dcl-s quote char(256)

dcl-proc getRandomQuote;
dcl-s randIndex int(10);
dcl-s quoteList char(256) dim(6);

quoteList(1) = ‘The only way to do great work is to love what you do. – Steve Jobs’;
quoteList(2) = ‘Life is what happens when you”re busy making other plans. – John Lennon’;
quoteList(3) = ‘The purpose of our lives is to be happy. – Dalai Lama’;
quoteList(4) = ‘Get busy living or get busy dying. – Stephen King’;
quoteList(5) = ‘You only live once, but if you do it right, once is enough. – Mae West’;
quoteList(6) = ‘In the end, we only regret the chances we didn”t take. – Lewis Carroll’;

randIndex = %rand(1:6);
return quoteList(randIndex);
end-proc

dcl-proc main;
quote = getRandomQuote();
// output the quote
write Quotes;
dsply quote;
end-proc

main();

(ns banking-system.core)

(defn create-account [name]
{:name name :balance 0 :transactions []})

(defn deposit [account amount]
(let [new-balance (+ (:balance account) amount)
transaction {:type “Deposit” :amount amount :balance new-balance}]
(-> account
(assoc :balance new-balance)
(update :transactions conj transaction))))

(defn withdraw [account amount]
(if (>= (:balance account) amount)
(let [new-balance (- (:balance account) amount)
transaction {:type “Withdrawal” :amount amount :balance new-balance}]
(-> account
(assoc :balance new-balance)
(update :transactions conj transaction)))
(throw (Exception. “Insufficient funds”))))

(defn check-balance [account]
(:balance account))

(defn transaction-history [account]
(:transactions account))

(defn main []
(let [account (create-account “John Doe”)]
(let [account (deposit account 100)]
(let [account (withdraw account 50)]
(println “Balance:” (check-balance account))
(println “Transaction History:” (transaction-history account))))))

(main)

dcl-s account likeds(ACCOUNT);
dcl-s transaction likeds(TRANSACTION);
dcl-s name varchar(50);
dcl-s balance packed(15:2);
dcl-s amount packed(15:2);
dcl-s transactionType varchar(10);
dcl-s i int(10);

dcl-ds ACCOUNT;
name varchar(50);
balance packed(15:2) inz(0);
transactions likeds(TRANSACTION) dim(100);
end-ds;

dcl-ds TRANSACTION;
transactionType varchar(10);
amount packed(15:2);
balance packed(15:2);
end-ds;

dcl-proc createAccount;
dcl-pi *n;
name varchar(50);
end-pi;

return ACCOUNT;
account.name = name;
return account;
end-proc;

dcl-proc deposit;
dcl-pi *n;
acct ACCOUNT;
amount packed(15:2);
end-pi;

acct.balance += amount;
transaction.transactionType = ‘Deposit’;
transaction.amount = amount;
transaction.balance = acct.balance;

for i = 1 to %elem(acct.transactions);
if (acct.transactions(i) = *null);
acct.transactions(i) = transaction;
leave;
endif;
endfor;

return acct;
end-proc;

dcl-proc withdraw;
dcl-pi *n;
acct ACCOUNT;
amount packed(15:2);
end-pi;

if (acct.balance >= amount);
acct.balance -= amount;

transaction.transactionType = ‘Withdrawal’;
transaction.amount = amount;
transaction.balance = acct.balance;

for i = 1 to %elem(acct.transactions);
if (acct.transactions(i) = *null);
acct.transactions(i) = transaction;
leave;
endif;
endfor;

return acct;
else;
// Handle insufficient funds
dsply ‘Insufficient funds’;
return acct; // or return a null account
endif;
end-proc;

dcl-proc checkBalance;
dcl-pi *n;
acct ACCOUNT;
end-pi;

return acct.balance;
end-proc;

dcl-proc transactionHistory;
dcl-pi *n;
acct ACCOUNT;
end-pi;

for i = 1 to %elem(acct.transactions);
if (acct.transactions(i) = *null);
leave;
endif;
dsply ‘Transaction Type: ‘ + acct.transactions(i).transactionType;
dsply ‘Amount: ‘ + %char(acct.transactions(i).amount);
dsply ‘Balance: ‘ + %char(acct.transactions(i).balance);
endfor;
end-proc;

dcl-proc main;
dcl-s acct ACCOUNT;

acct = createAccount(‘John Doe’);
acct = deposit(acct: 100);
acct = withdraw(acct: 50);

dsply ‘Balance: ‘ + %char(checkBalance(acct));
transactionHistory(acct);
end-proc;

main();