F# on Brian Braatz Blog

Bubble Sort BATTLE!

Sun, 22 Sep 2024 00:00:00 +0000

Updated Blog Image is from the amazing Dall-e
https://openai.com/index/dall-e-2

BUBBBLE BATTLE!

A Bubble Sort is a very simple sorting algorithm that repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order.

And you just keep repeating until you dont find anymore swaps. Thats the algorithm.

NOTE - you have no idea how long it will take to finish - since it keeps looping over the same elements until its done

I found a great visualization of a bubblesort here:

https://www.hackerearth.com/practice/algorithms/sorting/bubble-sort/visualize/

Pretty cool site BTW!
Click through the arrows and you can watch the algorithm on each iteration .

SO.. on with the show:

For fun, here is basic bubble sort implemented in several languages.

Its kind of interesting, at least in this case, to compare the languages

Python Bubble Sort

Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


def bubble_sort(arr):
 n = len(arr)
 for i in range(n):
 swapped = False
 for j in range(0, n-i-1):
 if arr[j] > arr[j+1]:
 arr[j], arr[j+1] = arr[j+1], arr[j]
 swapped = True
 if not swapped:
 break
 return arr

# Example usage
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = bubble_sort(arr)
print("Sorted array is:", sorted_arr)

C Sharp

https://en.wikipedia.org/wiki/C_Sharp_(programming_language)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


using System;

class Program
{
 static void BubbleSort(int[] arr)
 {
 int n = arr.Length;
 for (int i = 0; i < n; i++)
 {
 bool swapped = false;
 for (int j = 0; j < n - i - 1; j++)
 {
 if (arr[j] > arr[j + 1])
 {
 // Swap arr[j] and arr[j + 1]
 int temp = arr[j];
 arr[j] = arr[j + 1];
 arr[j + 1] = temp;
 swapped = true;
 }
 }
 if (!swapped) break;
 }
 }

 static void Main(string[] args)
 {
 int[] arr = { 64, 34, 25, 12, 22, 11, 90 };
 BubbleSort(arr);

 Console.WriteLine("Sorted array is:");
 foreach (int value in arr)
 {
 Console.Write(value + " ");
 }
 }
}

Go Language

https://en.wikipedia.org/wiki/Go_(programming_language)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


package main

import (
 "fmt"
)

func bubbleSort(arr []int) {
 n := len(arr)
 for i := 0; i < n; i++ {
 swapped := false
 for j := 0; j < n-i-1; j++ {
 if arr[j] > arr[j+1] {
 arr[j], arr[j+1] = arr[j+1], arr[j]
 swapped = true
 }
 }
 if !swapped {
 break
 }
 }
}

func main() {
 arr := []int{64, 34, 25, 12, 22, 11, 90}
 bubbleSort(arr)
 fmt.Println("Sorted array is:", arr)
}

Javascript

https://en.wikipedia.org/wiki/JavaScript

Why is JavaScript called JavaScript, since it has nothing to do with Java?
“”"
From an interview made to its creator Brendan Eich:

InfoWorld: As I understand it, JavaScript started out as Mocha, then became LiveScript and then became JavaScript when Netscape and Sun got together. But it actually has nothing to do with Java or not much to do with it, correct?

Eich: That’s right. It was all within six months from May till December (1995) that it was Mocha and then LiveScript. And then in early December, Netscape and Sun did a license agreement and it became JavaScript. And the idea was to make it a complementary scripting language to go with Java, with the compiled language.

""""

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


function bubbleSort(arr) {
 let n = arr.length;
 for (let i = 0; i < n; i++) {
 let swapped = false;
 for (let j = 0; j < n - i - 1; j++) {
 if (arr[j] > arr[j + 1]) {
 [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
 swapped = true;
 }
 }
 if (!swapped) break;
 }
 return arr;
}

// Example usage
let arr = [64, 34, 25, 12, 22, 11, 90];
let sortedArr = bubbleSort(arr);
console.log("Sorted array is:", sortedArr);

Java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


public class BubbleSort {
 static void bubbleSort(int[] arr) {
 int n = arr.length;
 boolean swapped;
 for (int i = 0; i < n; i++) {
 swapped = false;
 for (int j = 0; j < n - i - 1; j++) {
 if (arr[j] > arr[j + 1]) {
 // Swap arr[j] and arr[j + 1]
 int temp = arr[j];
 arr[j] = arr[j + 1];
 arr[j + 1] = temp;
 swapped = true;
 }
 }
 if (!swapped) break;
 }
 }

 public static void main(String[] args) {
 int[] arr = { 64, 34, 25, 12, 22, 11, 90 };
 bubbleSort(arr);
 System.out.println("Sorted array is:");
 for (int value : arr) {
 System.out.print(value + " ");
 }
 }
}

Objective-C

https://en.wikipedia.org/wiki/Objective-C

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#import <Foundation/Foundation.h>

void bubbleSort(NSMutableArray *arr) {
 NSUInteger n = [arr count];
 BOOL swapped;
 for (NSUInteger i = 0; i < n; i++) {
 swapped = NO;
 for (NSUInteger j = 0; j < n - i - 1; j++) {
 if ([arr[j] intValue] > [arr[j + 1] intValue]) {
 [arr exchangeObjectAtIndex:j withObjectAtIndex:j + 1];
 swapped = YES;
 }
 }
 if (!swapped) break;
 }
}

int main(int argc, const char * argv[]) {
 @autoreleasepool {
 NSMutableArray *arr = [@[@64, @34, @25, @12, @22, @11, @90] mutableCopy];
 bubbleSort(arr);
 NSLog(@"Sorted array is: %@", arr);
 }
 return 0;
}

Swift

https://en.wikipedia.org/wiki/Swift_(programming_language)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


func bubbleSort(_ arr: inout [Int]) {
 let n = arr.count
 for i in 0..<n {
 var swapped = false
 for j in 0..<n-i-1 {
 if arr[j] > arr[j + 1] {
 arr.swapAt(j, j + 1)
 swapped = true
 }
 }
 if !swapped { break }
 }
}

var arr = [64, 34, 25, 12, 22, 11, 90]
bubbleSort(&arr)
print("Sorted array is: \(arr)")

Rust

https://en.wikipedia.org/wiki/Rust_(programming_language)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


fn bubble_sort(arr: &mut [i32]) {
 let n = arr.len();
 for i in 0..n {
 let mut swapped = false;
 for j in 0..n - i - 1 {
 if arr[j] > arr[j + 1] {
 arr.swap(j, j + 1);
 swapped = true;
 }
 }
 if !swapped {
 break;
 }
 }
}

fn main() {
 let mut arr = [64, 34, 25, 12, 22, 11, 90];
 bubble_sort(&mut arr);
 println!("Sorted array is: {:?}", arr);
}

Perl

https://en.wikipedia.org/wiki/Perl

An old friend and coworker used to say to me “Perl is the only language where its much easier to just re-write some code, vs trying to READ it.. " hahaha

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


sub bubble_sort {
 my ($arr) = @_;
 my $n = @$arr;
 for my $i (0 .. $n-1) {
 my $swapped = 0;
 for my $j (0 .. $n-$i-2) {
 if ($arr->[$j] > $arr->[$j+1]) {
 ($arr->[$j], $arr->[$j+1]) = ($arr->[$j+1], $arr->[$j]);
 $swapped = 1;
 }
 }
 last unless $swapped;
 }
}

my @arr = (64, 34, 25, 12, 22, 11, 90);
bubble_sort(\@arr);
print "Sorted array is: @arr\n";

8051 Assembly language:

https://www.campuscomponent.com/blogs/post/getting-started-with-8051-microcontroller

From above site

"”""

The 8051 Microcontroller Features:

8-bit CPU
4 KB ROM
128 bytes RAM
32 I/O pins
Two 16-bit timers
Full duplex UART for serial communication

Understanding 8051 Microcontroller Architecture

""""

Back - in the 1990s I did a lot of projects with the 8051.

very very simple embedded controller with very little memory.

The assembly here is not too far off from 6502 assembly which was another popular embedded CPU.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


; 8051 Assembly Language Bubble Sort

ORG 0H

START: MOV DPTR, #ARRAY ; Point DPTR to the start of the array
 MOV R0, #LENGTH ; Load the length of the array
 DEC R0 ; Decrement R0 since we will use it in the loop

OUTER_LOOP: MOV R1, R0 ; R1 = R0
 MOV R2, #0 ; R2 = 0 (swapped flag)

INNER_LOOP: MOVX A, @DPTR ; Load A with the current element
 MOV R3, A ; Store the current element in R3
 INC DPTR ; Point to the next element
 MOVX A, @DPTR ; Load A with the next element

 CJNE A, R3, NOT_EQUAL
 SJMP NO_SWAP

NOT_EQUAL: JNC NO_SWAP ; If the current element is less than or equal to the next, skip
 MOVX @DPTR, R3 ; Otherwise swap
 DEC DPTR
 MOVX @DPTR, A
 INC DPTR
 MOV R2, #1 ; Set swapped flag

NO_SWAP: DJNZ R1, INNER_LOOP ; Decrease R1 and continue inner loop if not zero

 JNZ R2, OUTER_LOOP ; If no swaps happened, the array is sorted
 DEC R0 ; Decrement R0 for the next pass
 JNZ OUTER_LOOP ; Repeat the outer loop if not zero

END

ARRAY: DB 64H, 34H, 25H, 12H, 22H, 11H, 90H ; Example array
LENGTH: EQU $ - ARRAY ; Length of the array

END START

DPTR is used to point to the elements of the array.
R0 and R1 - loop counters.
R2 flag to check if any swaps occurred during a pass.
The MOVX instruction is used to access external memory where the array is stored.

COBOL

https://en.wikipedia.org/wiki/COBOL
My farther-in-law spent his whole career writing COBOL..

its interesting..

I did a project that involved EDI with COBOL years ago.. It was interesting.. but not something I would want to do every day.

I like languages with formal datatypes.. COBOL has this weird PIC field..

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


IDENTIFICATION DIVISION.
PROGRAM-ID. BubbleSort.

DATA DIVISION.
WORKING-STORAGE SECTION.
01 ARRAYS.
 05 ARR PIC 99 OCCURS 7 TIMES VALUE 64, 34, 25, 12, 22, 11, 90.
01 COUNT PIC 9(2).
01 SWAP-FLAG PIC 9(1).
01 I PIC 9(2).
01 J PIC 9(2).
01 TEMP PIC 9(2).

PROCEDURE DIVISION.
 PERFORM VARYING I FROM 1 BY 1 UNTIL I > 6
 MOVE 0 TO SWAP-FLAG
  PERFORM VARYING J FROM 1 BY 1 UNTIL J > 7 - I
  IF ARR (J) > ARR (J + 1)
  MOVE ARR (J) TO TEMP
  MOVE ARR (J + 1) TO ARR (J)
  MOVE TEMP TO ARR (J + 1)
  MOVE 1 TO SWAP-FLAG
  END-IF
  END-PERFORM
  IF SWAP-FLAG = 0
 EXIT PERFORM
  END-IF
  END-PERFORM

DISPLAY "Sorted array is:".
PERFORM VARYING COUNT FROM 1 BY 1 UNTIL COUNT > 7
 DISPLAY ARR (COUNT)
END-PERFORM.

STOP RUN.

Foxpro

https://en.wikipedia.org/wiki/FoxPro
OH I miss this language…. in a way..

In the early 1990s I had a job doing component level repair of 386 and 486 motherboards.. I kind of “made my own” software job, by offering to spend my weekends coding a database system to run the repair department on.

The language I did this in was foxpro!

Good times

This was DOS btw… AND it was multi-user (!!!)

I really loved the blue color.. It just made me want to make some coffee and write some code..

Later Foxpro came out with a newer version that supported SQL queries..

At my first look of that- I determined this was dumb (my young brain did not appreciate the set theory value of queries). SQL would never take on !

Also- to be fair- the SQL query engine in that first version was very slow..

It was much more fun to write a foxpro loop and loop over the table.. and the print out the lines to the report , as you found them ..

good times..

in anycase- back to the show

below is a Foxpro bubble sort.
It has a BASIC feel to it.

for the those not familiar, Foxpro is based on the dbase language

Dbase

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


* Foxpro BubbleSort.prg

PUBLIC ARRAY arr(7)
arr(1) = 64
arr(2) = 34
arr(3) = 25
arr(4) = 12
arr(5) = 22
arr(6) = 11
arr(7) = 90

n = ALEN(arr)

FOR i = 1 TO n - 1
 swapped = .F.
 FOR j = 1 TO n - i
  IF arr(j) > arr(j + 1)
  temp = arr(j)
  arr(j) = arr(j + 1)
  arr(j + 1) = temp
  swapped = .T.
  ENDIF
 ENDFOR
 IF .NOT. swapped
  EXIT
  ENDIF
ENDFOR

? "Sorted array is:"
FOR k = 1 TO n
 ? arr(k)
ENDFOR

SQL Bubblesort

https://en.wikipedia.org/wiki/SQL

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


CREATE PROCEDURE BubbleSort
AS
BEGIN
 DECLARE @i INT, @j INT, @swapped BIT, @temp INT
 DECLARE @Array TABLE (ID INT)

 -- Populate the table with example data
 INSERT INTO @Array VALUES (64), (34), (25), (12), (22), (11), (90)

 SET @i = 0
 SET @swapped = 1

 WHILE @swapped = 1
 BEGIN
 SET @swapped = 0
 SET @j = 0

 WHILE @j < (SELECT COUNT(*) FROM @Array) - @i - 1
 BEGIN
 DECLARE @currentValue INT, @nextValue INT
 SET @currentValue = (SELECT TOP 1 ID FROM @Array ORDER BY ID OFFSET @j ROWS FETCH NEXT 1 ROW ONLY)
 SET @nextValue = (SELECT TOP 1 ID FROM @Array ORDER BY ID OFFSET @j + 1 ROWS FETCH NEXT 1 ROW ONLY)

 IF @currentValue > @nextValue
 BEGIN
 -- Swap positions
 UPDATE @Array SET ID = @temp WHERE ID = @currentValue
 UPDATE @Array SET ID = @currentValue WHERE ID = @nextValue
 UPDATE @Array SET ID = @nextValue WHERE ID = @temp
 SET @swapped = 1
 END

 SET @j = @j + 1
 END

 SET @i = @i + 1
 END

 SELECT * FROM @Array
END

Yes- this is stupid… An sql engine natively has much better ways to sort things :)

Forth

Forth (programming language)

I was kind of geeky about this when I was younger
its a stack based language..

Later in life I met a friend who was hired to work on an Accounting system written in forth..
the good and bad of it is this- with Forth- you are constantly making new
“words” and then more words on top of those and so on and so on..

so the application code is “readable” to a human..

the complexity is hidden

but the problem is - all these forth programs build up all their own words for their app.. and they ar all very different..

If you hire a forth programmer to work on your system- they will have to read all the code in the system to understand it..

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


: SWAP ( n1 n2 -- n1 n2 )
 DUP ROT ROT
 >R SWAP R> ;

: BUBBLE-SORT ( addr u )
 0 DO
 FALSE
 0 DO
 2DUP I CELLS + @ SWAP I CELLS + @ >
 IF
 2DUP I CELLS + @ I 1+ CELLS + @ SWAP
 I CELLS + ! I 1+ CELLS + ! TRUE
 THEN
 LOOP
 2DROP
 SWAP
 1+ SWAP
 >R R> 1- DUP 0= IF LEAVE THEN
 LOOP ;

: PRINT-ARRAY ( addr u )
 0 DO
 DUP I CELLS + @ . SPACE
 LOOP DROP ;

CREATE ARRAY 7 ,
 64 , 34 , 25 , 12 , 22 , 11 , 90 ,

ARRAY 7 BUBBLE-SORT
." Sorted array is: " ARRAY 7 PRINT-ARRAY

Eiffel

Eiffel (programming language))

I dig this language

back in the 2000’s I went to ALOT of conferences..

I was lucky to attend an all day workshop on the Eiffel language.
I got to meet the very interesting Bertrand Meyer and have a lunch with him.

from the wiki
""""""

The design of the language is closely connected with the Eiffel programming method. Both are based on a set of principles, including design by contract, command–query separation, the uniform-access principle, the single-choice principle, the open–closed principle, and option–operand separation.

"""""

As a younger person , I feel in love with Design by Contract as a pattern. I still dig it, but at the time it blew my mind..

Also at the time- I was working at a company where we were climbing through 1,000,000 plus lines of C++ that didnt have very good separation.. so the Eiffel language struck a chord with me

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


class
 BUBBLE_SORT

create
 make

feature -- Initialization

 make
 local
 arr: ARRAY[INTEGER]
 do
 arr := <<64, 34, 25, 12, 22, 11, 90>>
 bubble_sort(arr)
 io.put_string("Sorted array is: ")
 across
 arr as elem
 loop
 io.put_integer(elem.item)
 io.put_string(" ")
 end
 end

feature -- Sorting

 bubble_sort(array: ARRAY[INTEGER])
 local
 swapped: BOOLEAN
 temp: INTEGER
 do
 across
 array.lower |..| array.upper + 1 as i
 loop
 swapped := False
 across
 array.lower |..| array.upper - i.item - 1 as j
 loop
 if array[j.item] > array[j.item + 1] then
 temp := array[j.item]
 array[j.item] := array[j.item + 1]
 array[j.item + 1] := temp
 swapped := True
 end
 end
 if not swapped then
 exit
 end
 end
 end
end

AutoHotkey

https://en.wikipedia.org/wiki/AutoHotkey

Great scripting language for Windows automation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


arr := [64, 34, 25, 12, 22, 11, 90]
n := arr.MaxIndex()
Loop %n%
{
 swapped := false
 Loop, % n - A_Index
 {
 if (arr[A_Index] > arr[A_Index + 1])
 {
 temp := arr[A_Index]
 arr[A_Index] := arr[A_Index + 1]
 arr[A_Index + 1] := temp
 swapped := true
 }
 }
 if (!swapped)
 break
}
MsgBox, Sorted array is: %arr%

Visual Basic

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


Module BubbleSort
 Sub Main()
 Dim arr As Integer() = {64, 34, 25, 12, 22, 11, 90}
 Dim n As Integer = arr.Length

 For i As Integer = 0 To n - 1
 Dim swapped As Boolean = False

 For j As Integer = 0 To n - i - 2
 If arr(j) > arr(j + 1) Then
 Dim temp As Integer = arr(j)
 arr(j) = arr(j + 1)
 arr(j + 1) = temp
 swapped = True
 End If
 Next

 If Not swapped Then
 Exit For
 End If
 Next

 Console.WriteLine("Sorted array is:")
 For Each value In arr
 Console.Write(value & " ")
 Next

 Console.ReadLine()
 End Sub
End Module

C++

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


#include <iostream>
#include <vector>
using namespace std;

void bubbleSort(vector<int>& arr) {
 int n = arr.size();
 for (int i = 0; i < n; i++) {
 bool swapped = false;
 for (int j = 0; j < n - i - 1; j++) {
 if (arr[j] > arr[j + 1]) {
 swap(arr[j], arr[j + 1]);
 swapped = true;
 }
 }
 if (!swapped) break;
 }
}

int main() {
 vector<int> arr = {64, 34, 25, 12, 22, 11, 90};
 bubbleSort(arr);

 cout << "Sorted array is: ";
 for (int value : arr) {
 cout << value << " ";
 }
 cout << endl;

 return 0;
}

GWBASIC

https://en.wikipedia.org/wiki/GW-BASIC
From the good old days of dos.

always number your lines in 10’s .. so you can add more in the middle later haha….

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


10 DIM arr(7)
20 DATA 64, 34, 25, 12, 22, 11, 90

30 FOR i = 1 TO 7
40 READ arr(i)
50 NEXT i

60 FOR i = 1 TO 6
70 swapped = 0
80 FOR j = 1 TO 7 - i
90 IF arr(j) > arr(j + 1) THEN
100 temp = arr(j)
110 arr(j) = arr(j + 1)
120 arr(j + 1) = temp
130 swapped = 1
140 END IF
150 NEXT j
160 IF swapped = 0 THEN EXIT FOR
170 NEXT i

180 PRINT "Sorted array is: "
190 FOR i = 1 TO 7
200 PRINT arr(i);
210 NEXT i
220 END

Apple II BASIC

https://en.wikipedia.org/wiki/Applesoft_BASIC

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


10 DIM ARR(7)
20 DATA 64, 34, 25, 12, 22, 11, 90
30 FOR I = 1 TO 7
40 READ ARR(I)
50 NEXT I
60 FOR I = 1 TO 6
70 SWAPPED = 0
80 FOR J = 1 TO 7 - I
90 IF ARR(J) > ARR(J + 1) THEN
100 TEMP = ARR(J)
110 ARR(J) = ARR(J + 1)
120 ARR(J + 1) = TEMP
130 SWAPPED = 1
140 END IF
150 NEXT J
160 IF SWAPPED = 0 THEN GOTO 200
170 NEXT I
200 PRINT "SORTED ARRAY IS:"
210 FOR I = 1 TO 7
220 PRINT ARR(I)" ";
230 NEXT I
240 END

Commodore 64 BASIC

NOTE: Apple and C64 look similar- hahah - probably because basic was liscenced by Microsoft

Apple’s first basic was Integer Basic - Written by Woz I believe

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


10 DIM ARR(7)
20 DATA 64, 34, 25, 12, 22, 11, 90
30 FOR I = 1 TO 7
40 READ ARR(I)
50 NEXT I
60 FOR I = 1 TO 6
70 SWAPPED = 0
80 FOR J = 1 TO 7 - I
90 IF ARR(J) > ARR(J + 1) THEN
100 TEMP = ARR(J)
110 ARR(J) = ARR(J + 1)
120 ARR(J + 1) = TEMP
130 SWAPPED = 1
140 END IF
150 NEXT J
160 IF SWAPPED = 0 THEN GOTO 200
170 NEXT I
200 PRINT "SORTED ARRAY IS:"
210 FOR I = 1 TO 7
220 PRINT ARR(I);
230 NEXT I
240 END

DOS Batch Scripting

https://en.wikipedia.org/wiki/DOS
https://en.wikipedia.org/wiki/Batch_file

Ahh the good old days..

who needs fancy powershell?

(haha actually BAT programming will drive you nuts- its very very hack- but it worked )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


@echo off
setlocal EnableDelayedExpansion

rem Initialize the array
set arr[0]=64
set arr[1]=34
set arr[2]=25
set arr[3]=12
set arr[4]=22
set arr[5]=11
set arr[6]=90
set n=7

rem Bubble Sort
for /L %%i in (0,1,!n!-1) do (
 set swapped=0
 for /L %%j in (0,1,!n!-!i!-2) do (
 set /A next=%%j+1
 call set "a=%%arr[%%j]%%"
 call set "b=%%arr[!next!]%%"
 if !a! gtr !b! (
 call set "temp=%%arr[%%j]%%"
 call set "arr[%%j]=%%arr[!next!]%%"
 call set "arr[!next!]=%%temp%%"
 set swapped=1
 )
 )
 if !swapped! equ 0 (
 goto sorted
 )
)

:sorted
echo Sorted array is:
for /L %%i in (0,1,!n!-1) do (
 echo !arr[%%i]!
)

endlocal

Powershell

https://en.wikipedia.org/wiki/PowerShell
Compared to BAT files- Looks like a normal language eh?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


# Bubble Sort in PowerShell

$arr = @(64, 34, 25, 12, 22, 11, 90)

$n = $arr.Length
for ($i = 0; $i -lt $n; $i++) {
 $swapped = $false
 for ($j = 0; $j -lt $n - $i - 1; $j++) {
 if ($arr[$j] -gt $arr[$j + 1]) {
 $temp = $arr[$j]
 $arr[$j] = $arr[$j + 1]
 $arr[$j + 1] = $temp
 $swapped = $true
 }
 }
 if (-not $swapped) {
 break
 }
}

Write-Output "Sorted array is:"
$arr

Bash

Bash is macho

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


#!/bin/bash

# Bubble Sort in Bash

# Initialize the array
arr=(64 34 25 12 22 11 90)

# Get the length of the array
n=${#arr[@]}

# Bubble Sort
for ((i = 0; i < n; i++)); do
 swapped=0
 for ((j = 0; j < n - i - 1; j++)); do
 if [ ${arr[j]} -gt ${arr[j + 1]} ]; then
 # Swap
 temp=${arr[j]}
 arr[j]=$[arr[j + 1]}
 arr[j + 1]=$temp
 swapped=1
 fi
 done
 if [ $swapped -eq 0 ]; then
 break
 fi
done

# Print sorted array
echo "Sorted array is: ${arr[@]}"

Visual Basic Script

https://en.wikipedia.org/wiki/VBScript
20+ years ago, most of my automation scripting was written in VB Script , with usually bat files on top of them .. .

you COULD actually spawn visual studio and debug these things..

it was good..

and then after Microsoft locked down the security of the OS- VBScript was too powerful, and so it was much less easy to just run a vbscript

a common trick was hackers would email an unsuspecting person a VB Script- and then they run that - and now the bad guys have full access to your system ..

so for your enjoyment- VB Script Bubblesort:

NOTE VB script compared to VB- has less formal types-they are compatible but not 100%

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


' BubbleSort.vbs

Dim arr(6)
arr(0) = 64
arr(1) = 34
arr(2) = 25
arr(3) = 12
arr(4) = 22
arr(5) = 11
arr(6) = 90

Dim n, i, j, temp, swapped
n = UBound(arr) + 1

For i = 0 To n - 1
 swapped = False

 For j = 0 To n - i - 2
 If arr(j) > arr(j + 1) Then
 temp = arr(j)
 arr(j) = arr(j + 1)
 arr(j + 1) = temp
 swapped = True
 End If
 Next

 If Not swapped Then
 Exit For
 End If
Next

WScript.Echo "Sorted array is:"
For i = 0 To n - 1
 WScript.Echo arr(i)
Next

TCL (Tool Command Language) Scripting

https://en.wikipedia.org/wiki/Tcl
A good friend became a TCL geek- I never got 100% into the koolaide- but I still find it interesting..
This was an early system people would put into C and C++ programs to expose parts of the system to be scriptable in TCL.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


proc bubble_sort {arr} {
 set n [llength $arr]

 for {set i 0} {$i < $n} {incr i} {
 set swapped 0

 for {set j 0} {$j < $n - $i - 1} {incr j} {
 if {[lindex $arr $j] > [lindex $arr [expr {$j + 1}]]} {
 set temp [lindex $arr $j]
 set arr [lreplace $arr $j [expr {$j + 1}] [lindex $arr [expr {$j + 1}]] $temp]
 incr swapped
 }
 }

 if {$swapped == 0} {
 break
 }
 }

 return $arr
}

# Example usage
set arr [list 64 34 25 12 22 11 90]
set sorted_arr [bubble_sort $arr]
puts "Sorted array is: $sorted_arr"

Erlang

Erland

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


-module(bubble_sort).
-export([sort/1]).

sort(List) ->
 bubble_sort(List, []).

bubble_sort([], Sorted) ->
 Sorted;
bubble_sort([H|T], Sorted) ->
 bubble_sort_pass(T, H, [], Sorted).

bubble_sort_pass([], Max, L, Sorted) ->
 bubble_sort(L, [Max|Sorted]);
bubble_sort_pass([H|T], Max, L, Sorted) when H > Max ->
 bubble_sort_pass(T, H, [Max|L], Sorted);
bubble_sort_pass([H|T], Max, L, Sorted) ->
 bubble_sort_pass(T, Max, [H|L], Sorted).

Call this module by calling the sort function with a list of numbers that you want to sort. For example:

1
2
3
4
5


c(bubble_sort).
{ok,bubble_sort}

bubble_sort:sort([5, 3, 8, 4, 2]).
[2,3,4,5,8]

Note the “c()” business is “compile” in Erlangs interactive shell.

Erlang came out of Ericsson..

Its designed to be very stable - to run phone systems

from the wikipedia link

“”""
Erlang applications are built of very lightweight Erlang processes in the Erlang runtime system. Erlang processes can be seen as “living” objects (object-oriented programming), with data encapsulation and message passing, but capable of changing behavior during runtime. The Erlang runtime system provides strict process isolation between Erlang processes (this includes data and garbage collection, separated individually by each Erlang process) and transparent communication between processes (see Location transparency) on different Erlang nodes (on different hosts).

Joe Armstrong, co-inventor of Erlang, summarized the principles of processes in his PhD thesis:\[18\]

Everything is a process.
Processes are strongly isolated.
Process creation and destruction is a lightweight operation.
Message passing is the only way for processes to interact.
Processes have unique names.
If you know the name of a process you can send it a message.
Processes share no resources.
Error handling is non-local.
Processes do what they are supposed to do or fail.

Joe Armstrong remarked in an interview with Rackspace in 2013: “If Java is ‘write once, run anywhere’, then Erlang is ‘write once, run forever’.”\[19\]

"""

F#

Here’s an implementation of Bubble Sort in F#:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


let bubbleSort (arr: int array) =
 let swap (a: int array) i j =
 let temp = a.[i]
 a.[i] <- a.[j]
 a.[j] <- temp

 let mutable swapped = true
 let n = arr.Length

 while swapped do
 swapped <- false
 for i in 0 .. n - 2 do
 if arr.[i] > arr.[i + 1] then
 swap arr i (i + 1)
 swapped <- true
 arr

let numbers = [| 5; 3; 8; 4; 2 |]
let sortedNumbers = bubbleSort numbers
printfn \"%A\" sortedNumbers

This implementation:

Uses a while loop to keep sorting until no swaps are needed.
Iterates through the array, swapping adjacent elements if they’re out of order.
Modifies the array in-place for simplicity.

It’s a simple and readable way to sort a list using the classic (but inefficient) Bubble Sort algorithm in F#.

F# in a Nutshell

Wed, 14 Sep 2016 00:00:00 +0000

What is F#?

F# is a functional-first programming language that runs on .NET.

It’s like that one friend who insists on doing everything in a more “mathematically pure” way while the rest of your group happily hacks away in imperative C#.

Why Should You Care About F#?

Concise and Expressive – F# lets you do more with less code. No more endless curly braces and semicolons. Just pure, readable beauty.
Immutability by Default – In F#, variables are immutable unless you explicitly make them mutable. This means fewer bugs due to unintended side effects.
Pattern Matching – This is where F# really shines. Instead of writing a dozen if-else statements, you can elegantly destructure data with pattern matching.
Interoperability – It runs on .NET, so you can use all your favorite C# libraries if you must.
It Makes You Look Smart – Let’s be honest, telling people you code in a functional language makes you sound 10x more intelligent.

A Taste of F#

Let’s take a look at some basic F# code and how it compares to C#.

Hello, Functional World!

1

printfn "Hello, F#!"

Compare that to the C# version:

1
2
3
4
5
6


using System;
class Program {
 static void Main() {
 Console.WriteLine("Hello, F#!");
 }
}

F# wins on brevity.

Functions in F#

1
2


let square x = x * x
printfn "%d" (square 5) // Prints 25

That’s it. No return types, no explicit public static nonsense. Just clean, pure function definition.

Pattern Matching Magic

1
2
3
4
5
6
7


let describeNumber x =
 match x with
 | 0 -> "Zero"
 | 1 -> "One"
 | _ -> "Something else"

printfn "%s" (describeNumber 42) // Prints "Something else"

Tell me that doesn’t look cleaner than a bunch of if-statements!

When to Use F#

F# isn’t for everything, but it shines in:

Data Science and Analytics – It has great libraries for numerical computing.
Finance – Banks love F# for its precision and reliability.
Domain-Driven Design – Functional programming fits well with event-driven architectures.
Writing Less Code – If you’re tired of boilerplate and just want to get stuff done.

When Not to Use F#

If You Hate Indentation-Based Syntax – F# relies on whitespace, so if you’re a {} fanatic, you might struggle.
If You Live in the C# World – If your team is all-in on C#, switching to F# might be more pain than it’s worth.
If You Need to Work With GUI Apps – F# is better suited for backend work.

The Future of F#

F# isn’t going anywhere. It’s actively developed and maintained, with strong support from Microsoft and the open-source community. Plus, with .NET evolving rapidly, F# is only getting better.

If you haven’t tried F# yet, give it a shot. Worst case? You learn something new. Best case? You discover your new favorite language.

Key Ideas

Concept	Summary
Functional Programming	F# is a functional-first language on .NET.
Concise Syntax	Less boilerplate compared to C#.
Immutability	Variables are immutable by default.
Pattern Matching	A powerful alternative to if-else chains.
Interoperability	F# works seamlessly with .NET libraries.
Use Cases	Great for data science, finance, and DDD.

References

F# Code Snippets

Wed, 14 Sep 2016 00:00:00 +0000

Common F# Code Snippets

1. Printing to the Console

1

printfn "Hello, world!"

No need for Console.WriteLine, just a simple printfn and you’re done!

2. Defining a Function

1
2


let square x = x * x
printfn "%d" (square 5) // Outputs: 25

Functions are first-class citizens in F#, and defining one is a breeze.

3. Piping Data (`|>` Operator)

1
2
3


let square x = x * x
let result = 5 |> square |> string
printfn "%s" result // Outputs: "25"

Piping makes function composition elegant and clean.

4. Pattern Matching

1
2
3
4
5
6
7


let describeNumber x =
 match x with
 | 0 -> "Zero"
 | 1 -> "One"
 | _ -> "Something else"

printfn "%s" (describeNumber 42) // Outputs: "Something else"

Forget those clunky if-else chains. Pattern matching is the way to go!

5. List Comprehensions

1
2
3


let numbers = [1..5]
let squaredNumbers = [for n in numbers -> n * n]
printfn "%A" squaredNumbers // Outputs: [1; 4; 9; 16; 25]

Simple, readable, and efficient.

6. Recursive Functions

1
2
3
4
5


let rec factorial n =
 if n <= 1 then 1
 else n * factorial (n - 1)

printfn "%d" (factorial 5) // Outputs: 120

Because recursion is the functional way!

7. Tuples and Destructuring

1
2
3


let person = ("Alice", 30)
let (name, age) = person
printfn "%s is %d years old." name age

Tuple unpacking makes handling grouped data a breeze.

8. Records (Lightweight Data Structures)

1
2
3


type Person = { Name: string; Age: int }
let bob = { Name = "Bob"; Age = 25 }
printfn "%A" bob // Outputs: { Name = "Bob"; Age = 25 }

Simple, structured data without the C# verbosity.

9. Option Type (No More Nulls!)

1
2
3
4
5
6
7


let divide a b =
 if b = 0 then None
 else Some (a / b)

match divide 10 2 with
| Some result -> printfn "Result: %d" result
| None -> printfn "Cannot divide by zero!"

F# says “nope” to nulls, and we love it.

10. Asynchronous Code

1
2
3
4
5
6
7
8


open System.Threading.Tasks

let asyncExample = async {
 do! Async.Sleep 1000
 printfn "Task Complete!"
}

Async.Start asyncExample

11. Sequences (Lazy Evaluation)

1
2


let infiniteNumbers = Seq.initInfinite (fun x -> x * x)
printfn "%A" (infiniteNumbers |> Seq.take 5 |> Seq.toList) // Outputs: [0; 1; 4; 9; 16]

Need an infinite list but don’t want to destroy your RAM? Sequences to the rescue!

12. Higher-Order Functions

1
2
3


let applyTwice f x = f (f x)
let double x = x * 2
printfn "%d" (applyTwice double 3) // Outputs: 12

Functions that take functions and return functions? Welcome to functional programming!

13. Discriminated Unions

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


type Shape =
 | Circle of float
 | Rectangle of float * float

let area shape =
 match shape with
 | Circle r -> System.Math.PI * r * r
 | Rectangle (w, h) -> w * h

printfn "Circle area: %f" (area (Circle 5.0)) // Outputs: Circle area: 78.54

A clean and powerful way to model data variations.

14. Using the `map` Function

1
2
3


let numbers = [1..5]
let squared = numbers |> List.map (fun x -> x * x)
printfn "%A" squared // Outputs: [1; 4; 9; 16; 25]

Apply a function to every element of a list with zero fuss.

15. Folding (Reduce in Other Languages)

1
2


let sum = List.fold (fun acc x -> acc + x) 0 [1..5]
printfn "%d" sum // Outputs: 15

Folding is just a fancy way of saying “reduce everything to a single value.”

16. Working with Dictionaries

1
2


let dict = dict ["one", 1; "two", 2; "three", 3]
printfn "%d" (dict.["two"]) // Outputs: 2

Need key-value pairs? Dictionaries got you covered.

17. Using `try...with` for Exception Handling

1
2
3
4
5
6
7
8
9


let safeDivide a b =
 try
 Some (a / b)
 with
 | :? System.DivideByZeroException -> None

match safeDivide 10 0 with
| Some result -> printfn "Result: %d" result
| None -> printfn "Oops! Division by zero."

Because sometimes, life (and division) throws you an error.

18. Using `async` Workflows

1
2
3
4
5
6


let asyncJob = async {
 do! Async.Sleep 1000
 printfn "Done sleeping!"
}

Async.Start asyncJob

Non-blocking, super clean asynchronous programming.

19. Partial Application

1
2
3


let multiply x y = x * y
let double = multiply 2
printfn "%d" (double 10) // Outputs: 20

Fix arguments ahead of time for ultimate function reusability!

20. Using `Seq.filter` for Filtering Data

1
2
3


let numbers = [1..10]
let evens = numbers |> List.filter (fun x -> x % 2 = 0)
printfn "%A" evens // Outputs: [2; 4; 6; 8; 10]

Elegant, readable, and functional filtering.

21. Function Composition (`>>` Operator)

1
2
3
4
5


let add2 x = x + 2
let multiply3 x = x * 3
let addThenMultiply = add2 >> multiply3

printfn "%d" (addThenMultiply 4) // Outputs: 18

Think of >> as piping without explicit arguments. Super clean!

22. Defining Custom Operators

1
2


let (++) x y = x + y * 2
printfn "%d" (5 ++ 3) // Outputs: 11

Why use boring old operators when you can make your own?

23. Using the `yield` Keyword in Sequences

1
2
3
4
5
6


let numbers = seq {
 yield 1
 yield 2
 yield! [3; 4; 5]
}
printfn "%A" (numbers |> Seq.toList) // Outputs: [1; 2; 3; 4; 5]

yield! lets you expand another sequence inside your own.

24. Type Providers for Easy Data Access

1
2
3
4
5
6
7
8


#r "nuget: FSharp.Data"
open FSharp.Data

let csv = CsvProvider<"Name,Age\nAlice,30\nBob,25">
let data = csv.GetSample()

for row in data.Rows do
 printfn "%s is %d years old" row.Name row.Age

Type providers give you strongly-typed access to external data. No manual parsing required!

25. Asynchronous Parallel Computation

1
2
3
4
5
6
7


open System.Threading.Tasks

let task1 = async { return 5 }
let task2 = async { return 10 }
let combined = Async.Parallel [task1; task2]

Async.RunSynchronously combined |> printfn "%A" // Outputs: [|5; 10|]

Run multiple async tasks in parallel like a pro.

26. Memoization (Caching Function Results)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


let memoize f =
 let cache = System.Collections.Generic.Dictionary<_, _>()
 fun x ->
 if cache.ContainsKey(x) then cache.[x]
 else
 let result = f x
 cache.[x] <- result
 result

let expensiveComputation = memoize (fun x -> x * x * x)
printfn "%d" (expensiveComputation 10) // Outputs: 1000

Memoization = automatic caching for expensive functions.

27. Active Patterns for Smart Matching

1
2
3
4
5
6
7
8


let (|Even|Odd|) x = if x % 2 = 0 then Even else Odd

let describeNumber x =
 match x with
 | Even -> "Even number"
 | Odd -> "Odd number"

printfn "%s" (describeNumber 5) // Outputs: Odd number

Active patterns let you create custom match cases for cleaner logic.

28. Infinite Lazy Sequences

1
2
3
4
5


let rec fibs a b = seq {
 yield a
 yield! fibs b (a + b)
}
printfn "%A" (fibs 0 1 |> Seq.take 10 |> Seq.toList)

Lazy evaluation lets you generate infinite sequences without crashing your machine.

29. Using `MailboxProcessor` for Actor-Based Concurrency

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


let agent = MailboxProcessor.Start(fun inbox ->
 let rec loop () = async {
 let! msg = inbox.Receive()
 printfn "Received: %s" msg
 return! loop()
 }
 loop()
)

agent.Post "Hello, F#"

MailboxProcessor is a great way to handle message-based concurrency.

30. Dependency Injection with Partial Application

1
2
3
4
5
6
7


let log message = printfn "Log: %s" message
let add x y = x + y
let addWithLogging = fun x y ->
 log (sprintf "Adding %d and %d" x y)
 add x y

printfn "%d" (addWithLogging 3 7) // Outputs: Log: Adding 3 and 7, then 10

Inject dependencies (like logging) into your functions using partial application.

F# on Brian Braatz Blog

Bubble Sort BATTLE!

BUBBBLE BATTLE!

Python Bubble Sort

C Sharp

Go Language

Javascript

Java

Objective-C

Swift

Rust

Perl

8051 Assembly language:

From above site

The 8051 Microcontroller Features:

Understanding 8051 Microcontroller Architecture

COBOL

Foxpro

SQL Bubblesort

Forth

Eiffel

AutoHotkey

Visual Basic

C++

GWBASIC

Apple II BASIC

Commodore 64 BASIC

DOS Batch Scripting

Powershell

Bash

Visual Basic Script

TCL (Tool Command Language) Scripting

Erlang

from the wikipedia link

F#

F# in a Nutshell

What is F#?

Why Should You Care About F#?

A Taste of F#

Hello, Functional World!

Functions in F#

Pattern Matching Magic

When to Use F#

When Not to Use F#

The Future of F#

Key Ideas

References

F# Code Snippets

Common F# Code Snippets

1. Printing to the Console

2. Defining a Function

3. Piping Data (|> Operator)

4. Pattern Matching

5. List Comprehensions

6. Recursive Functions

7. Tuples and Destructuring

8. Records (Lightweight Data Structures)

9. Option Type (No More Nulls!)

10. Asynchronous Code

11. Sequences (Lazy Evaluation)

12. Higher-Order Functions

13. Discriminated Unions

14. Using the map Function

15. Folding (Reduce in Other Languages)

16. Working with Dictionaries

17. Using try...with for Exception Handling

18. Using async Workflows

19. Partial Application

20. Using Seq.filter for Filtering Data

21. Function Composition (>> Operator)

22. Defining Custom Operators

23. Using the yield Keyword in Sequences

24. Type Providers for Easy Data Access

25. Asynchronous Parallel Computation

26. Memoization (Caching Function Results)

27. Active Patterns for Smart Matching

28. Infinite Lazy Sequences

29. Using MailboxProcessor for Actor-Based Concurrency

30. Dependency Injection with Partial Application

References

3. Piping Data (`|>` Operator)

14. Using the `map` Function

17. Using `try...with` for Exception Handling

18. Using `async` Workflows

20. Using `Seq.filter` for Filtering Data

21. Function Composition (`>>` Operator)

23. Using the `yield` Keyword in Sequences

29. Using `MailboxProcessor` for Actor-Based Concurrency