Merge branch 'master' into project-euler

Author: ddaniel27

.github/workflows/ci.yml

@@ -21,7 +21,7 @@ jobs:
         with:
           go-version: '^1.18'
       - name: Run Golang CI Lint
-        uses: golangci/golangci-lint-action@v3
+        uses: golangci/golangci-lint-action@v6
         with:
           version: latest
           args: -E gofmt

.github/workflows/citk.yml

@@ -10,11 +10,11 @@ jobs:
     strategy:
       fail-fast: false
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Setup Go
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v5
         with:
           go-version: "^1.18"
       - name: Checkout branch

.github/workflows/stale.yml

@@ -6,7 +6,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v4
+      - uses: actions/stale@v9
         with:
           stale-issue-message: 'This issue is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 5 days.'
           close-issue-message: 'This issue was closed because it has been stalled for 7 days with no activity.'

.github/workflows/upload_coverage_report.yml

@@ -25,13 +25,13 @@ jobs:
           go test -coverprofile="${{ env.REPORT_NAME }}" ./...
       - name: Upload coverage to codecov (tokenless)
         if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name != github.repository
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v5
         with:
           files: "${{ env.REPORT_NAME }}"
           fail_ci_if_error: true
       - name: Upload coverage to codecov (with token)
         if: "! github.event.pull_request.head.repo.fork "
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           files: "${{ env.REPORT_NAME }}"

conversion/hexadecimaltobinary.go

@@ -0,0 +1,78 @@
+/*
+Author: mapcrafter2048
+GitHub: https://github.com/mapcrafter2048
+*/
+
+// This algorithm will convert any Hexadecimal number(0-9, A-F, a-f) to Binary number(0 or 1).
+// https://en.wikipedia.org/wiki/Hexadecimal
+// https://en.wikipedia.org/wiki/Binary_number
+// Function receives a Hexadecimal Number as string and returns the Binary number as string.
+// Supported Hexadecimal number range is 0 to 7FFFFFFFFFFFFFFF.
+
+package conversion
+
+import (
+	"errors"
+	"regexp"
+	"strings"
+)
+
+var isValidHex = regexp.MustCompile("^[0-9A-Fa-f]+$").MatchString
+
+// hexToBinary() function that will take Hexadecimal number as string,
+// and return its Binary equivalent as a string.
+func hexToBinary(hex string) (string, error) {
+	// Trim any leading or trailing whitespace
+	hex = strings.TrimSpace(hex)
+
+	// Check if the hexadecimal string is empty
+	if hex == "" {
+		return "", errors.New("input string is empty")
+	}
+
+	// Check if the hexadecimal string is valid
+	if !isValidHex(hex) {
+		return "", errors.New("invalid hexadecimal string: " + hex)
+	}
+
+	// Parse the hexadecimal string to an integer
+	var decimal int64
+	for i := 0; i < len(hex); i++ {
+		char := hex[i]
+		var value int64
+		if char >= '0' && char <= '9' {
+			value = int64(char - '0')
+		} else if char >= 'A' && char <= 'F' {
+			value = int64(char - 'A' + 10)
+		} else if char >= 'a' && char <= 'f' {
+			value = int64(char - 'a' + 10)
+		} else {
+			return "", errors.New("invalid character in hexadecimal string: " + string(char))
+		}
+		decimal = decimal*16 + value
+	}
+
+	// Convert the integer to a binary string without using predefined functions
+	var binaryBuilder strings.Builder
+	if decimal == 0 {
+		binaryBuilder.WriteString("0")
+	} else {
+		for decimal > 0 {
+			bit := decimal % 2
+			if bit == 0 {
+				binaryBuilder.WriteString("0")
+			} else {
+				binaryBuilder.WriteString("1")
+			}
+			decimal = decimal / 2
+		}
+	}
+
+	// Reverse the binary string since the bits are added in reverse order
+	binaryRunes := []rune(binaryBuilder.String())
+	for i, j := 0, len(binaryRunes)-1; i < j; i, j = i+1, j-1 {
+		binaryRunes[i], binaryRunes[j] = binaryRunes[j], binaryRunes[i]
+	}
+
+	return string(binaryRunes), nil
+}

conversion/hexadecimaltobinary_test.go

@@ -0,0 +1,46 @@
+package conversion
+
+import (
+	"testing"
+)
+
+func TestHexToBinary(t *testing.T) {
+	tests := []struct {
+		hex     string
+		want    string
+		wantErr bool
+	}{
+		{"", "", true},
+		{"G123", "", true},
+		{"12XZ", "", true},
+		{"1", "1", false},
+		{"A", "1010", false},
+		{"10", "10000", false},
+		{"1A", "11010", false},
+		{"aB", "10101011", false},
+		{"0Ff", "11111111", false},
+		{"  1A ", "11010", false},
+		{"0001A", "11010", false},
+		{"7FFFFFFFFFFFFFFF", "111111111111111111111111111111111111111111111111111111111111111", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.hex, func(t *testing.T) {
+			got, err := hexToBinary(tt.hex)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("hexToBinary(%q) error = %v, wantErr %v", tt.hex, err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("hexToBinary(%q) = %v, want %v", tt.hex, got, tt.want)
+			}
+		})
+	}
+}
+
+func BenchmarkHexToBinary(b *testing.B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		_, _ = hexToBinary("7FFFFFFFFFFFFFFF")
+	}
+}

conversion/hexadecimaltodecimal.go

@@ -0,0 +1,57 @@
+/*
+Author: mapcrafter2048
+GitHub: https://github.com/mapcrafter2048
+*/
+
+// This algorithm will convert any Hexadecimal number(0-9, A-F, a-f) to Decimal number(0-9).
+// https://en.wikipedia.org/wiki/Hexadecimal
+// https://en.wikipedia.org/wiki/Decimal
+// Function receives a Hexadecimal Number as string and returns the Decimal number as integer.
+// Supported Hexadecimal number range is 0 to 7FFFFFFFFFFFFFFF.
+
+package conversion
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+var isValidHexadecimal = regexp.MustCompile("^[0-9A-Fa-f]+$").MatchString
+
+// hexToDecimal converts a hexadecimal string to a decimal integer.
+func hexToDecimal(hexStr string) (int64, error) {
+
+	hexStr = strings.TrimSpace(hexStr)
+
+	if len(hexStr) == 0 {
+		return 0, fmt.Errorf("input string is empty")
+	}
+
+	// Check if the string has a valid hexadecimal prefix
+	if len(hexStr) > 2 && (hexStr[:2] == "0x" || hexStr[:2] == "0X") {
+		hexStr = hexStr[2:]
+	}
+
+	// Validate the hexadecimal string
+	if !isValidHexadecimal(hexStr) {
+		return 0, fmt.Errorf("invalid hexadecimal string")
+	}
+
+	var decimalValue int64
+	for _, char := range hexStr {
+		var digit int64
+		if char >= '0' && char <= '9' {
+			digit = int64(char - '0')
+		} else if char >= 'A' && char <= 'F' {
+			digit = int64(char - 'A' + 10)
+		} else if char >= 'a' && char <= 'f' {
+			digit = int64(char - 'a' + 10)
+		} else {
+			return 0, fmt.Errorf("invalid character in hexadecimal string: %c", char)
+		}
+		decimalValue = decimalValue*16 + digit
+	}
+
+	return decimalValue, nil
+}

conversion/hexadecimaltodecimal_test.go

@@ -0,0 +1,52 @@
+package conversion
+
+import (
+	"testing"
+)
+
+func TestHexToDecimal(t *testing.T) {
+	tests := []struct {
+		hex     string
+		want    int64
+		wantErr bool
+	}{
+		{"", 0, true},
+		{"G123", 0, true},
+		{"123Z", 0, true},
+		{"1", 1, false},
+		{"A", 10, false},
+		{"10", 16, false},
+		{"1A", 26, false},
+		{"aB", 171, false},
+		{"0Ff", 255, false},
+		{" 1A ", 26, false},
+		{"0x1A", 26, false},
+		{"0X1A", 26, false},
+		{"1A", 26, false},
+		{"7FFFFFFFFFFFFFFF", 9223372036854775807, false},
+		{"0001A", 26, false},
+		{"0000007F", 127, false},
+		{"0", 0, false},
+		{"0x0", 0, false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.hex, func(t *testing.T) {
+			got, err := hexToDecimal(tt.hex)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("hexToDecimal(%q) error = %v, wantErr %v", tt.hex, err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("hexToDecimal(%q) = %v, want %v", tt.hex, got, tt.want)
+			}
+		})
+	}
+}
+
+func BenchmarkHexToDecimal(b *testing.B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		_, _ = hexToDecimal("7FFFFFFFFFFFFFFF")
+	}
+}

structure/linkedlist/singlylinkedlist.go

@@ -125,14 +125,14 @@ func (ll *Singly[T]) Count() int {
 
 // Reverse reverses the list.
 func (ll *Singly[T]) Reverse() {
-	var prev, Next *Node[T]
+	var prev, next *Node[T]
 	cur := ll.Head
 
 	for cur != nil {
-		Next = cur.Next
+		next = cur.Next
 		cur.Next = prev
 		prev = cur
-		cur = Next
+		cur = next
 	}
 
 	ll.Head = prev