#BEGIN SCRIPT
echo

#0 – COMMENT – Variables

counter=0
rotate_counter=0
rotate_signal=0
string=$1
array_letter=()
LENGTH_STRING=${#string}
WORD_LENGTH=4

#1 – COMMENT – Functions

rotate()
{
rotate_letter=${array_letter[$USE_ARRAY_LENGTH]}
ROTATE_ARRAY=( $rotate_letter ${array_letter[@]} )
unset ROTATE_ARRAY[$WORD_LENGTH]
array_letter=( ${ROTATE_ARRAY[@]} )
}

switch()
{
A=$1
B=$2
temp_a=$A
temp_b=$B
A=$temp_b
B=$temp_a
echo “$A $B”
}

get_three()
{

three_letter_array=( ${array_letter[@]} )
unset three_letter_array[0]
echo “3 LETTERS: ${three_letter_array[@]}”

#COMMENT – test the word against dictionary

test_word=$(echo ${three_letter_array[@]} | sed ‘s/ //g’)
echo “TEST WORD: $test_word”
is_word $test_word
two_letter_array=( ${three_letter_array[@]} )
unset two_letter_array[0]
echo “2 LETTERS: ${two_letter_array[@]}”

#COMMENT – test the word against dictionary

test_word=$(echo ${two_letter_array[@]} | sed ‘s/ //g’)
echo “TEST WORD: $test_word”
is_word $test_word

}

get_three_test()
{
three_letter_array=( ${array_letter_test[@]} )
unset three_letter_array[0]
echo “3 LETTERS: ${three_letter_array[@]}”

#COMMENT – test the word against dictionary

test_word=$(echo ${three_letter_array[@]} | sed ‘s/ //g’)
echo “TEST WORD: $test_word”
is_word $test_word
two_letter_array=( ${three_letter_array[@]} )
unset two_letter_array[0]
echo “2 LETTERS: ${two_letter_array[@]}”

#COMMENT – test the word against dictionary

test_word=$(echo ${two_letter_array[@]} | sed ‘s/ //g’)
echo “TEST WORD: $test_word”
is_word $test_word
}

is_word()
{
grep ^$1$ /usr/share/dict/words && TRUE=1
if [ $TRUE -eq 1 ] 2>/dev/null
then
echo “WORD is VALID”
VALID_WORDS=( ${VALID_WORDS[@]} $1 )
else
echo “WORD is NOT in the Dictionary”
fi
TRUE=0
}

#2 – COMMENT – Check if file or arguments exist

if [[ $# -eq 0 || $# -gt 1 ]]
then
echo “Please enter a word as an argument.”
echo
exit 1
fi

if [ $LENGTH_STRING -ne $WORD_LENGTH ]
then
echo “Word must be 4 letters long.”
echo
exit 1
fi

#3 – COMMENT – Body of script

while [ $counter -ne $WORD_LENGTH ]
do
letter=${string:$counter:1}
echo “$letter”
array_letter=( ${array_letter[@]} $letter )
((counter++))
done
echo

#3b – COMMENT – rotate array to get word_array_2

let “USE_ARRAY_LENGTH=$LENGTH_STRING-1″
echo “ARRAY LENGTH: $USE_ARRAY_LENGTH”
echo

while [ $rotate_counter -ne $LENGTH_STRING ]
do
#3b.1 – COMMENT – rotate word

rotate
WORD_ARRAY[rotate_counter]=${array_letter[@]}
echo “WORD MAIN $rotate_counter: ${WORD_ARRAY[$rotate_counter]}”

#COMMENT – test the word against dictionary

test_word=$(echo ${WORD_ARRAY[$rotate_counter]} | sed ‘s/ //g’)
echo “TEST WORD: $test_word”
is_word $test_word

#3b.1a – COMMENT – get 3 letter combinations

get_three
array_switch=$(switch ${array_letter[2]} ${array_letter[3]})
array_letter_test=( ${array_letter[0]} ${array_letter[1]} $array_switch )
echo “ARRAY SWITCH: ${array_letter_test[@]}”

#COMMENT – test the word against dictionary

test_word=$(echo ${array_letter_test[@]} | sed ‘s/ //g’)
echo “TEST WORD: $test_word”
is_word $test_word

#3b.1b – COMMENT – get 3 letter combinations

get_three_test
WORD_ARRAY_TEST=( ${WORD_ARRAY[$rotate_counter]} )
WORD_ARRAY_RETURN=( ${WORD_ARRAY[$rotate_counter]} )
count=0
while [ $count -ne 2 ]
do
FIRST_LETTER=${WORD_ARRAY_TEST[0]}
unset WORD_ARRAY_TEST[0]
array_letter=( ${WORD_ARRAY_TEST[@]} )
#echo “3 ARRAY_LETTER: ${array_letter[@]}”
((USE_ARRAY_LENGTH–))
rotate
((USE_ARRAY_LENGTH++))
array_letter=( $FIRST_LETTER ${array_letter[@]} )
unset array_letter[$LENGTH_STRING]
WORD_ARRAY_TEST[$count]=${array_letter[@]}
echo “WORD IN $rotate_counter: ${WORD_ARRAY_TEST[$count]}”

#3b.1c – COMMENT – get 3 letter combinations

get_three
WORD_ARRAY_TEST=( ${WORD_ARRAY_TEST[$count]} )

#3b.2 – COMMENT – switch last 2 contents of array

array_switch=$(switch ${array_letter[2]} ${array_letter[3]})
array_letter_test=( ${array_letter[0]} ${array_letter[1]} $array_switch )
echo “ARRAY SWITCH: ${array_letter_test[@]}”

#COMMENT – test the word against dictionary

test_word=$(echo ${array_letter_test[@]} | sed ‘s/ //g’)
echo “TEST WORD: $test_word”
is_word $test_word

#3b.1d – COMMENT – get 3 letter combinations

get_three_test
if [ $count -eq 1 ]
then
array_letter=( ${WORD_ARRAY_TEST[@]} )
fi
((count++))
done
array_letter=( ${WORD_ARRAY_RETURN[@]} )
echo
((rotate_counter++))
done

#3c – COMMENT – list all the valid words

final_words=$(echo ${VALID_WORDS[@]} | sed ‘s/ /\n/g’ | sort | uniq )
echo “ANAGRAM OF $1:”
echo “$final_words”

#4 – COMMENT – Clean up code

echo
exit 0

#END SCRIPT

#BEGIN SCRIPT
echo

#0 – COMMENT – Arrays & variables

counter=0
array_counter=0
RANGE_LETTER=26
RANGE_ROW=10
RANGE_COL=10
RANGE_VHD=3
array_random=( a b c d e f g h i j k l m n o p q r s t u v w x y z )

#1 – COMMENT – Functions

get_letter()
{
random_letter=$RANDOM
let “random_letter %= $RANGE_LETTER”
letter=$(echo ${array_random[$random_letter]})
array_main=( “${array_main[@]}” “$letter”)
}

get_row()
{
random_row=$RANDOM
let “random_row %= $RANGE_ROW”
echo “ROW: $random_row”
}

get_col()
{
random_col=$RANDOM
let “random_col %= $RANGE_COL”
echo “COL: $random_col”
}

get_vhd()
{
random_vhd=$RANDOM
let “random_vhd %= $RANGE_VHD”
case $random_vhd in
0) vhd=0
echo “VERTICAL: $vhd”
;;
1) vhd=1
echo “HORIZONTAL: $vhd”
;;
2) vhd=2
echo “DIAGONAL: $vhd”
;;
esac
}

define_array_row()
{
array_row_0=( ${dest[0]} )
echo “D_0: ${array_row_0[@]}”

array_row_1=( ${dest[1]} )
echo “D_1: ${array_row_1[@]}”

array_row_2=( ${dest[2]} )
echo “D_2: ${array_row_2[@]}”

array_row_3=( ${dest[3]} )
echo “D_3: ${array_row_3[@]}”

array_row_4=( ${dest[4]} )
echo “D_4: ${array_row_4[@]}”

array_row_5=( ${dest[5]} )
echo “D_5: ${array_row_5[@]}”

array_row_6=( ${dest[6]} )
echo “D_6: ${array_row_6[@]}”

array_row_7=( ${dest[7]} )
echo “D_7: ${array_row_7[@]}”

array_row_8=( ${dest[8]} )
echo “D_8: ${array_row_8[@]}”

array_row_9=( ${dest[9]} )
echo “D_9: ${array_row_9[@]}”
}

array_update()
{
echo “D_0: ${array_row_0[@]}”
echo “D_1: ${array_row_1[@]}”
echo “D_2: ${array_row_2[@]}”
echo “D_3: ${array_row_3[@]}”
echo “D_4: ${array_row_4[@]}”
echo “D_5: ${array_row_5[@]}”
echo “D_6: ${array_row_6[@]}”
echo “D_7: ${array_row_7[@]}”
echo “D_8: ${array_row_8[@]}”
echo “D_9: ${array_row_9[@]}”
}

#2 – COMMENT – Check if file or arguments exist

if [ $# -gt 1 ]
then
echo “Arguments are not required for this script.”
echo
exit 1
fi

#3 – COMMENT – Body of script

echo “Please enter words to hide within the 10×10 matrix.”

read words

#3a – COMMENT – place words in an array

word_counter=0
word_array=( $words )
let “word_array_count= ${#word_array[@]} – 1″
echo “$word_array_count”

for word in ${word_array[@]}
do
string=$word
echo “WORD ARRAY $word_counter. LENGTH: ${#string} -> $word”
((word_counter++))
done

#3b – COMMENT – set each line to dest[i] array

for ((i=0; i<10; i++))
do
array_main=()

#3b.1 – COMMENT – get 10 random letters in a row

for ((j=0; j<10; j++))
do

#3b.2 – COMMENT – call get_letter function to get random letters in a 10×10 matrix

get_letter
done

#3b.3 – COMMENT – put 10 random letters in dest[i] array variable
dest[i]=${array_main[@]}
done

echo

#3c – COMMENT – call define_array function to set dest[i] to array_row array
define_array_row

echo

#3d – COMMENT – get random row and column to place hidden words

rc_counter=0

while [ $rc_counter -le $word_array_count ]
do
#3d.0 – COMMENT – variables and array within while counter

converted_word=()
TOTAL_LETTERS=10
extract_counter=0
word_counter=0
letter_space=
insert_word=${word_array[$rc_counter]}
length_word_main=${#word_array[$rc_counter]}
length_word_1=${#word_array[$rc_counter]}
length_word_2=${#word_array[$rc_counter]}
length_word_3=${#word_array[$rc_counter]}

echo “TEST: $rc_counter”

#3d.1 – COMMENT – functions to get random placement of word

get_row
get_col
get_vhd

array_location=array_row_$random_row[$random_col]

case $vhd in
# VERTICAL
0) let “letter_space = $TOTAL_LETTERS – $random_row”
echo “LETTER SPACE: $letter_space”
echo “LENGTH WORD: $length_word_main”
;;
# HORIZONTAL
1) let “letter_space = $TOTAL_LETTERS – $random_col”
echo “LETTER SPACE: $letter_space”
echo “LENGTH WORD: $length_word_main”
;;
# DIAGONAL
2) let “letter_space_col = $TOTAL_LETTERS – $random_col”
let “letter_space_row = $TOTAL_LETTERS – $random_row”
if [ $letter_space_col -lt $length_word_main ]
then
let “letter_space = $TOTAL_LETTERS – $random_col”
else
let “letter_space = $TOTAL_LETTERS – $random_row”
fi
echo “LETTER SPACE: $letter_space”
echo “LENGTH WORD: $length_word_main”
;;
esac

if [ $letter_space -gt $length_word_main ]
then
string_insert=$(echo ${insert_word[@]})
until [ $length_word_main -eq 0 ]
do
extract_string=${string_insert:$extract_counter:1}
converted_word=( “${converted_word[@]}” “$extract_string” )
((extract_counter++))
((length_word_main–))
done
echo “CONVERTED WORD: ${converted_word[@]}”

#3d.2 – COMMENT – place word in matrix vertically

if [ $vhd -eq 0 ]
then
until [ $length_word_1 -eq 0 ]
do
word_test=${converted_word[$word_counter]}
echo “LETTER TEST: $word_test”
array_test_1=$(echo -n ‘array_row_’
echo -n “$((random_row=$random_row + $word_counter))”
echo -n “[$random_col]=$word_test”)
declare “$array_test_1″
((length_word_1–))
((word_counter++))
done
fi

#3d.3 – COMMENT – place word in matrix horizontally

if [ $vhd -eq 1 ]
then
until [ $length_word_2 -eq 0 ]
do
word_test=${converted_word[$word_counter]}
echo “LETTER TEST: $word_test”
array_test_1=$(echo -n ‘array_row_’
echo -n “$random_row”
echo -n “[$((random_col=$random_col + $word_counter))]=$word_test”)
declare “$array_test_1″
((length_word_2–))
((word_counter++))
done
fi

#3d.4 – COMMENT – place word in matrix diagonally

if [ $vhd -eq 2 ]
then
until [ $length_word_3 -eq 0 ]
do
word_test=${converted_word[$word_counter]}
echo “LETTER TEST: $word_test”
array_test_1=$(echo -n ‘array_row_’
echo -n “$((random_row=$random_row + $word_counter))”
echo -n “[$((random_col=$random_col + $word_counter))]=$word_test”)
declare “$array_test_1″
((length_word_3–))
((word_counter++))
done
fi

echo “ARRAY BEGIN: ${array_location[@]}”
echo “ARRAY END: $array_test_1″
array_update
else
echo “MESSAGE: NOT ENOUGH SPACE FOR WORD LENGTH.”
echo “STATUS: ADJUSTED ROW AND COL TO COMPENSATE FOR WORD.”

if [ $vhd -eq 0 ]
then
let “adjust_row = $length_word_main – $letter_space”
let “random_row = $random_row – $adjust_row”
echo “RANDOM_ROW: $random_row”
fi

if [ $vhd -eq 1 ]
then
let “adjust_col = $length_word_main – $letter_space”
let “random_col = $random_col – $adjust_col”
echo “RANDOM_COL: $random_col”
fi

if [ $vhd -eq 2 ]
then
let “adjust_dia = $length_word_main – $letter_space”
let “random_row = $random_row – $adjust_dia”
if [ $random_row -lt 0 ]
then
random_row=0
fi
let “random_col = $random_col – $adjust_dia”
if [ $random_col -lt 0 ]
then
random_col=0
fi
echo “RANDOM_DIA: $random_row AND $random_col”
fi

string_insert=$(echo ${insert_word[@]})

until [ $length_word_main -eq 0 ]
do
extract_string=${string_insert:$extract_counter:1}
converted_word=( “${converted_word[@]}” “$extract_string” )
((extract_counter++))
((length_word_main–))
done

echo “CONVERTED WORD: ${converted_word[@]}”

#3d.5 – COMMENT – place word in matrix vertically

if [ $vhd -eq 0 ]
then
until [ $length_word_1 -eq 0 ]
do
word_test=${converted_word[$word_counter]}
echo “LETTER TEST: $word_test”
array_test_1=$(echo -n ‘array_row_’
echo -n “$((random_row=$random_row + $word_counter))”
echo -n “[$random_col]=$word_test”)
declare “$array_test_1″
((length_word_1–))
((word_counter++))
done
fi

#3d.6 – COMMENT – place word in matrix horizontally

if [ $vhd -eq 1 ]
then
until [ $length_word_2 -eq 0 ]
do
word_test=${converted_word[$word_counter]}
echo “LETTER TEST: $word_test”
array_test_1=$(echo -n ‘array_row_’
echo -n “$random_row”
echo -n “[$((random_col=$random_col + $word_counter))]=$word_test”)
declare “$array_test_1″
((length_word_2–))
((word_counter++))
done
fi

if [ $vhd -eq 2 ]
then
until [ $length_word_3 -eq 0 ]
do
word_test=${converted_word[$word_counter]}
echo “LETTER TEST: $word_test”
array_test_1=$(echo -n ‘array_row_’
echo -n “$((random_row=$random_row + $word_counter))”
echo -n “[$((random_col=$random_col + $word_counter))]=$word_test”)
declare “$array_test_1″
((length_word_3–))
((word_counter++))
done
fi

array_location=array_row_$random_row[$random_col]

echo “ARRAY BEGIN: ${array_location[@]}”
echo “ARRAY END: $array_test_1″

array_update
fi

echo
((rc_counter++))
done

#4 – COMMENT – Clean up code

echo
exit 0
#END SCRIPT

#BEGIN SCRIPT
echo

#0 – COMMENT – Variables and Arrays

counter=0
array_counter=0
d_counter=0
array_number=1

#1 – COMMENT – Functions

#1a – COMMENT – change array elements to get 3×3 matrix determinant

variable_func_3()
{
array_1=( -2 2 -3 )
array_2=( -1 1 3 )
array_3=( 2 0 -1 )
array_1_length=${#array_1[@]}
array_2_length=${#array_2[@]}
array_3_length=${#array_3[@]}
}

#1b – COMMENT – change array elements to get 4×4 matrix determinant

variable_func_4()
{
array_1=( 0 0 0 1 )
array_2=( -1 1 3 1 )
array_3=( 2 0 -1 1 )
array_4=( -1 0 1 -1 )
array_1_length=${#array_1[@]}
array_2_length=${#array_2[@]}
array_3_length=${#array_3[@]}
array_4_length=${#array_4[@]}
}

while_func()
{
echo “COUNTER PLUS: $counter_plus”
echo $array_plus
unset array_$array_plus[$array_in_counter]
((counter_plus++))
((array_plus++))
}

get_inner_d()
{
a=${array_x[0]}
b=${array_x[1]}
c=${array_y[0]}
d=${array_y[1]}

echo “$a $b $c $d”
let “determinant=$a*$d – $b*$c”
echo “$determinant”
}

get_d_1()
{

array_d=()
local array_in_counter=0
local array_d_counter=0
local inv=1
local neg_inv=-1
local array_1_length=${#array_1_a[@]}
local d_1=

local array_1=( ${array_1_a[@]} )
local array_2=( ${array_2_a[@]} )
local array_3=( ${array_3_a[@]} )

until [ $array_d_counter -eq $array_1_length ]
do

local counter_plus=0
echo $array_d_counter
local array_plus=2
let “array_counter_length_1=$array_1_length – 1″

while [ $counter_plus -lt $array_counter_length_1 ]
do
while_func
done
if [ ${#array_2[@]} -eq 2 ]
then
array_x=( ${array_2[@]} )
echo ${array_x[@]}
array_y=( ${array_3[@]} )
echo ${array_y[@]}
get_inner_d
echo “ARRAY 1: ${array_1[$array_d_counter]}”
((d_1 += $inv*${array_1[$array_d_counter]}*$determinant))
echo “D_1: $d_1″
array_d=( $d_1 )
((inv=$inv*$neg_inv))
fi
array_1=( ${array_1_a[@]} )
array_2=( ${array_2_a[@]} )
array_3=( ${array_3_a[@]} )
((array_in_counter++))
((array_d_counter++))
echo
done
}

#1c – COMMENT – calculate determinant of 4×4 array

get_d()
{

#1d – COMMENT – variable_func_3 = 3×3 matrix or variable_func_4 = 4×4 matrix

variable_func_4

local array_in_counter=0
local array_d_counter=0
local array_1_length=${#array_1[@]}
local inv=1
local neg_inv=-1

until [ $array_d_counter -eq $array_1_length ]
do

local counter_plus=0
local array_plus=2
echo $array_d_counter
let “array_counter_length=$array_1_length – 1″

echo “ARRAY_1: ${array_1[$array_d_counter]}”

while [ $counter_plus -lt $array_counter_length ]
do
while_func
done

if [ ${#array_2[@]} -eq 2 ]
then
array_x=( ${array_2[@]} )
echo ${array_x[@]}
array_y=( ${array_3[@]} )
echo ${array_y[@]}
get_inner_d
echo “ARRAY 1: ${array_1[$array_d_counter]}”
((d_1 += $inv*${array_1[$array_d_counter]}*$determinant))
echo “D_1: $d_1″
((inv=$inv*$neg_inv))
echo
echo “The determinant of this 3×3 matrix is: $d_1.”
fi

if [ ${#array_2[@]} -eq 3 ]
then
array_1_a=( ${array_2[@]} )
echo ${array_1_a[@]}
array_2_a=( ${array_3[@]} )
echo ${array_2_a[@]}
array_3_a=( ${array_4[@]} )
echo ${array_3_a[@]}
get_d_1
echo “INV: $inv”
echo “ARRAY_1: ${array_1[$array_d_counter]}”
echo “ARRAY_D: ${array_d[@]}”
((final_d += $inv*${array_1[$array_d_counter]}*${array_d[@]}))
((inv=$inv*$neg_inv))
echo
echo “The determinant of this 4×4 matrix is: $final_d.”
fi

#1e – COMMENT – variable_func_3 = 3×3 matrix or variable_func_4 = 4×4 matrix

variable_func_4

((array_in_counter++))
((array_d_counter++))
done
}

#2 – COMMENT – Check if file or arguments exist

if [ $# -gt 1 ]
then
echo “Arguments are not required for this script.”
echo
exit 1
fi

#3 – COMMENT – Body of script

get_d

#4 – COMMENT – Clean up code

echo
exit 0
#END SCRIPT

#BEGIN SCRIPT
echo

#0 – COMMENT – Variables and Arrays

counter=0
array_counter=0
array_number=1
shift_array_counter=1

array_1=( -2 2 -3 )
array_2=( -1 1 3 )
array_3=( 2 0 -1 )

array_1_length=${#array_1[@]}
array_2_length=${#array_2[@]}
array_3_length=${#array_3[@]}

#1 – COMMENT – Functions

get_inner_d()
{
a=${array_x[0]}
b=${array_x[1]}
c=${array_y[0]}
d=${array_y[1]}

echo “$a $b $c $d”
let “determinant=$a*$d – $b*$c”
echo “$determinant”
}

#1b – COMMENT – get 3×3 array

array_in_counter=0
inv=1
neg_inv=-1

get_d()
{
array_1_length=${#array_1[@]}
array_d_counter=0
until [ $array_d_counter -eq $array_1_length ]
do
array_1=( -2 2 -3 )
array_2=( -1 1 3 )
array_3=( 2 0 -1 )

counter_plus=0
echo $array_d_counter
array_plus=2
let “array_counter_length=$array_1_length – 1″
while [ $counter_plus -lt $array_counter_length ]
do
echo “COUNTER PLUS: $counter_plus”
echo $array_plus
unset array_1
unset array_$array_plus[$array_in_counter]
((counter_plus++))
((array_plus++))
done
if [ ${#array_2[@]} -eq 2 ]
then
array_x=( ${array_2[@]} )
echo ${array_x[@]}
array_y=( ${array_3[@]} )
echo ${array_y[@]}
get_inner_d
fi
array_1=( -2 2 -3 )
echo “ARRAY 1: ${array_1[$array_d_counter]}”
((final_d += $inv*${array_1[$array_d_counter]}*$determinant))
echo “$final_d”
((inv=$inv*$neg_inv))
((array_in_counter++))
((array_d_counter++))
echo
done
}

#2 – COMMENT – Check if file or arguments exist

if [ $# -gt 1 ]
then
echo “Arguments are not required for this script.”
echo
exit 1
fi

#3 – COMMENT – Body of script

get_d

echo “The determinant of this 3×3 matrix is: $final_d”

#4 – COMMENT – Clean up code

echo
exit 0
#END SCRIPT

#BEGIN SCRIPT
echo

#0 – COMMENT – Variables

counter=0
FILE=$1
HEX_TO_ASCII=hex_to_ascii_FORMATTED

#1 – COMMENT – Functions

#2 – COMMENT – Check if file or arguments exist

if [[ $# -eq 0 || $# -gt 1 ]]
then
echo “Please enter a binary file \(regular .txt file in unix will do\) as an argument.”
echo
exit 1
fi

if [ ! -e $1 ]
then
echo “$FILE binary file does not exist.”
echo
exit 1
fi

#3 – COMMENT – Body of script

od_file=$(od -x $FILE)

echo “$od_file” | sed ‘s/^[a-zA-Z0-9]*$//’ | sed ‘/^$/d’ |
while read line
do
count_array=2
array=( “$line” )
array_1=()
array_ascii=()
until [ "$count_array" -eq 10 ]
do
count_string=0
insert_array=$(echo “${array[@]}” | cut -d” ” -f$count_array)
string_insert=$insert_array
length_insert=${#insert_array}
if [ -z "$insert_array" ]
then
array=( “${array[@]}” ” ” )
fi
while [ $count_string -le 4 ]
do
two_hex=${string_insert:$count_string:2}
stnd_out=$(echo $two_hex | grep $two_hex $HEX_TO_ASCII | cut -d’ ‘ -f2)
array_ascii=( ${array_ascii[@]} $stnd_out )
((count_string=$count_string + 2))
done
((count_array++))
done
array_1=( “${array[@]}” “${array_ascii[@]}”)
echo “${array_1[@]}”
done

#4 – COMMENT – Clean up code

echo
exit 0
#END SCRIPT

#BEGIN SCRIPT
echo

#0 – COMMENT – Variables

counter=0
count_8=0
count_8_left=0
count_8_right=0
shift_left_counter=1
shift_right_counter=1
register_pointer=$register_count
register_array=
register_exist=0
test_count=0
RIGHT_LOW_LIMIT=0
REGISTER_COUNT=64
REGISTER_RANGE=2
TEMP_ARRAY=tmp_file.$$
FILE=binary_to_ascii_FORMATTED

#1 – COMMENT – Functions

#1a – COMMENT – load 64-bit register, random for now

load_register()
{
until [ $counter -eq $REGISTER_COUNT ]
do
register_number=$RANDOM
let “register_number %= $REGISTER_RANGE”
echo -n “$register_number ” #space is important to separate elements”
((counter++))
done > $TEMP_ARRAY

register_array=( $(cat $TEMP_ARRAY) )
register_array_count=${#register_array[@]}
register_left_count=`expr $register_array_count – 1`
register_right_count=`expr $register_array_count – 1`
register_shift_array=$(echo ${register_array[@]})

#1.5a – COMMENT – ascii conversion

grep_register=$(echo “${register_array[@]}” | sed ‘s/ *//g’)

string_conversion

echo
rm $TEMP_ARRAY
register_exist=1
}

#1b – COMMENT – shift left

shift_left()
{
register_shift_left=(${register_array[@]:$shift_left_counter:$REGISTER_COUNT})
register_test=`expr $REGISTER_COUNT – $register_left_count`

while [ $register_test -gt 0 ]
do
register_shift_left=( “${register_shift_left[@]}” “0″)
((register_test–))
done

if [ $register_left_count -gt 0 ]
then
echo “$register_left_count: remaining in the register.”
echo ${register_shift_left[@]}
grep_register_left=$(echo ${register_shift_left[@]} | sed ‘s/ *//g’)
string_left=”$grep_register_left”
str_length_left=${#grep_register_left}
echo
until [ "$count_8_left" -eq "$str_length_left" ]
do
conversion=${string_left:$count_8_left:8}
echo “$conversion”
ascii_char
let “count_8_left=$count_8_left + 8″
done
((shift_left_counter++))
((register_left_count–))
else
echo “Register is completely shifted to the left.”
echo
echo “REMINDER: need to restart script after shifting or rotating.”
echo
fi
}

#1c – COMMENT – shift right

shift_right()
{
array_1=( ${register_shift_array[@]} )
array_2=()

if [ $REGISTER_COUNT -gt 0 ]
then
let “right_shift= $register_array_count – $register_right_count”
while [ $right_shift -gt 0 ]
do
array_2=( “${array_2[@]}” “0″ )
((right_shift–))
done
array_1=( ${array_2[@]} ${register_shift_array[@]} )
((test_count++))
echo “$register_right_count: remaining in the register.”
echo “${array_1[@]:$RIGHT_LOW_LIMIT:$register_array_count}”
register_shift_right=(${array_1[@]:$RIGHT_LOW_LIMIT:$register_array_count})
grep_register_right=$(echo ${register_shift_right[@]} | sed ‘s/ *//g’)
string_right=”$grep_register_right”
str_length_right=${#grep_register_right}
echo
until [ "$count_8_right" -eq "$str_length_right" ]
do
conversion=${string_right:$count_8_right:8}
echo “$conversion”
ascii_char
let “count_8_right=$count_8_right + 8″
done
echo
((register_right_count–))
((REGISTER_COUNT–))
else
echo “Register is completely shifted to the right.”
echo
echo “REMINDER: need to restart script after shifting or rotating.”
echo
fi
}

#1d – COMMENT – rotate register

rotate()
{
array_1=( ${register_shift_array[@]} )
array_2=()

if [ $REGISTER_COUNT -gt 0 ]
then
test1=${array_1[$register_right_count]}
array_2=( “${array_2[$test_count]}” “$test1″ )
if [ $test_count -eq 0 ]
then
array_1=( ${array_2[@]} ${register_shift_array[@]} )
else
array_1=( ${array_2[@]} ${register_shift_array_1[@]} )
fi
((test_count++))
echo “$register_right_count: remaining in the register.”
echo -n “${array_1[@]:$RIGHT_LOW_LIMIT:$register_array_count}”
register_shift_array_1=(“${array_1[@]:$RIGHT_LOW_LIMIT:$register_array_count}”)
echo
((register_right_count–))
((REGISTER_COUNT–))
else
echo “Register is completely rotated.”
echo
echo “REMINDER: need to restart script after shifting or rotating.”
echo
fi
}

#1e – COMMENT – function to translate binary to ascii

ascii_char()
{
stnd_out=$(grep “$conversion” $FILE)
ascii=$(echo “$stnd_out” | cut -d’ ‘ -f2)
if [ -z "$stnd_out" ]
then
echo “NO ASCII: binary is out of range.”
else
echo “ASCII: $ascii”
fi
}

string_conversion()
{
string=”$grep_register”
str_length=${#grep_register}
until [ "$count_8" -eq "$str_length" ]
do
conversion=${string:$count_8:8}
echo “$conversion”
ascii_char
let “count_8=$count_8 + 8″
done
}

menu()
{
echo “Please pick a letter to interact with the register.”
echo “A: load register”
echo “B: shift left”
echo “C: shift right”
echo “D: rotate”
echo “R: restart”
echo “X: exit”
echo

read choice

case $choice in
A|a) echo
echo “LOAD REGISTER”
if [ $register_exist -eq 1 ]
then
echo “${register_array[@]}”
else
load_register
echo “${register_array[@]}”
fi
echo
menu
;;
B|b) echo
echo “SHIFT LEFT”
echo “BEFORE:”
echo “${register_array[@]}”
echo “AFTER”
shift_left
echo
menu
;;
C|c) echo
echo “SHIFT RIGHT”
echo “BEFORE:”
echo “${register_array[@]}”
echo “AFTER”
shift_right
echo
menu
;;
D|d) echo
echo “ROTATE”
echo “BEFORE:”
echo “${register_array[@]}”
echo “AFTER”
rotate
echo
menu
;;
R|r) echo
echo “Restarting script…”
./shift_register
;;
X|x|[Ee]xit) echo
echo “EXITING…”
sleep 1
exit 1
;;
*) echo “Please pick a valid letter.”
echo “Restarting script…”
./shift_register
esac
}

#2 – COMMENT – Check if file or arguments exist

if [ $# -gt 1 ]
then
echo “Arguments are not required for this script.”
echo
exit 1
fi

#3 – COMMENT – Body of script

#3a – COMMENT – call menu function

menu

#4 – COMMENT – Clean up code

echo
exit 0
#END SCRIPT

#BEGIN SCRIPT
echo

#0 – COMMENT – Variables

counter=0
XML_FILE=$1
HTML=HTML_CONVERTED_FILE.html
TEXT=TEXT_CONVERTED_FILE.txt

#1 – COMMENT – Functions

element_name()
{
element_grep=$(grep “<.*>.*</.*>” $XML_FILE | sed ‘s/>.*//g’ | sed ‘s/^<//g’ | sort | uniq)
echo “$element_grep” |
while read line
do
echo “document.write(\”<td>\”);”
echo “document.write(x[i].getElementsByTagName(\”$line\”)[0].childNodes[0].nodeValue);”
echo “document.write(\”</td>\”);”
echo
done
}

xml_to_text()
{
text_grep=$(grep “^<” $XML_FILE | sed ‘s/^<[a-zA-Z0-9]*>//g’ | sed ‘s/<\/[a-zA-Z0-9]*>//g’)
echo “$text_grep” > $TEXT
}

#2 – COMMENT – Check if file or arguments exist

if [[ $# -eq 0 || $# -gt 1 ]]
then
echo “Please enter an xml file as an argument.”
exit 1
fi

if [ ! -e $1 ]
then
echo “$1 does not exist.”
exit 1
fi

#3 – COMMENT – Body of script

#3a – COMMENT – Altered XML to HTML document as a here document from –> http://www.w3schools.com/XML/xml_to_html.asp to display all elements of an XML file

cat > $HTML <<HTML_DOC

<html>
<body>

<script type=”text/javascript”>
var xmlDoc=null;
if (window.ActiveXObject)
{// code for IE
xmlDoc=new ActiveXObject(“Microsoft.XMLDOM”);
}
else if (document.implementation.createDocument)
{// code for Mozilla, Firefox, Opera, etc.
xmlDoc=document.implementation.createDocument(“”,”",null);
}
else
{
alert(‘Your browser cannot handle this script’);
}
if (xmlDoc!=null)
{
xmlDoc.async=false;
xmlDoc.load(“$XML_FILE”);

document.write(“<table border=’1′>”);

var x=xmlDoc.getElementsByTagName(“CD”);
for (i=0;i<x.length;i++)
{
document.write(“<tr>”);

$(element_name)

document.write(“</tr>”);
}
document.write(“</table>”);
}
</script>

</body>
</html>
HTML_DOC

#3b – COMMENT – standard output message

if [ -e $HTML ]
then
echo “STATUS: Simple XML file is converted to HTML file.”
echo “REMINDER: XML file is required for HTML to display data.”
echo
else
echo “STATUS: Something is wrong, XML file is not converted to HTML file.”
fi

#3c – COMMENT – call xml to text function and send status of function to standard output.

xml_to_text

if [ -e $TEXT ]
then
echo “STATUS: Simple XML file is converted to TEXT file.”
else
echo “STATUS: Something is wrong, XML file is not converted to TEXT file.”
fi

#4 – COMMENT – Clean up code

echo
exit 0
#END SCRIPT

#BEGIN SCRIPT
echo

#0 – COMMENT – Variables

counter=0

#1 – COMMENT – Functions

#2 – COMMENT – Check if file or arguments exist

if [[ $# -eq 0 || $# -gt 1 ]]
then
echo “Please enter an html file as an argument.”
exit 1
fi

if [ ! -e $1 ]
then
echo “$1 does not exist.”
exit 1
fi

#3 – COMMENT – Body of script

stripped_html=$(sed “s/<[a-zA-Z]*>//g” $1 | sed “s/<\/[a-zA-Z]*>//g” | sed ‘s/ *<[-a-zA-Z0-9=/%,:#.\!"_ ]* *[-a-zA-Z0-9=/\"%,#:!._ ]*> *//g’ | sed “s/<.*’.*>//g” | sed ‘/^[\t ]*$/d’ | sed ‘s/^[\t ]*/\n/’ | fmt -w 70)

if [ $? -eq 0 ]
then
echo “$stripped_html”
echo “$stripped_html” > “$1_STRIPPED_HTML_TAGS”
chmod 0755 “$1_STRIPPED_HTML_TAGS”
else
echo “STATUS: Please check the file or this script”
fi

#4 – COMMENT – Clean up code

echo
exit 0
#END SCRIPT

#BEGIN SCRIPT
echo

#0 – COMMENT – Variables

counter=0
guess=$1
oldguess=0
tolerance=1

#1 – COMMENT – Functions

ABS()
{
RESULT=$(echo “$1-$2″ | bc)
if [ $RESULT -gt 0 ]
then
echo “$RESULT”
else
RESULT=$(echo “($1-$2)*(-1)” | bc)
echo “$RESULT”
fi
}

#2 – COMMENT – Check if file or arguments exist

if [[ $# -eq 0 || $# -gt 1 ]]
then
echo “Please enter a number or argument to find the square root.”
exit 1
fi

#3 – COMMENT – Body of script

ABS_RESULT=$(ABS $guess $oldguess)

while [ "$ABS_RESULT" -gt "$tolerance" ]
do
ABS_RESULT=$(ABS $guess $oldguess)
echo “COUNTER: $counter”
oldguess=$guess
guess=$(echo “($oldguess + ($1/$oldguess))/2.0″ | bc)
guess_screen=$(echo “scale=2; ($oldguess + ($1/$oldguess))/2.0″ | bc)
echo “$guess_screen”
((counter++))
done
#4 – COMMENT – Clean up code

echo
exit 0
#END SCRIPT