Merge branch 'main' into main

Author: ajay-dhangar

blog/Introduction to Cyber Security and Web Explosion.md

@@ -46,3 +46,9 @@ nayanikamukherjee:
   title: Full Stack Developer
   url: "https://github.com/Nayanika1402"
   image_url: https://avatars.githubusercontent.com/u/132455412?v=4
+
+pujan-sarkar:
+  name: Pujan Sarkar
+  title: Cyber Security Enthusiast
+  url: "https://github.com/Pujan-sarkar"
+  image_url: https://avatars.githubusercontent.com/u/144250917?v=4

blog/authors.yml

@@ -0,0 +1,163 @@
+---
+id: dictionary-julia
+title: Dictionary
+sidebar_label: Julia Dictionary
+sidebar_position: 7
+tags: [Julia,Dictionary]
+
+---
+Dictionary is a built-in data structure that allows you to associate keys with corresponding values. It is similar to a hash table or hash map in other programming languages. Dictionaries are particularly useful when you need to store and retrieve data quickly based on some unique identifier (the key).
+
+### Creating a Dictionary
+
+You can create a dictionary in Julia using curly braces `{}` and specifying key-value pairs separated by `=>` (called a pair constructor). Here’s how you can create a dictionary:
+
+```julia
+# Creating a dictionary with city names as keys and their populations as values
+city_populations = Dict("New York" => 8336817, "Los Angeles" => 3979576, "Chicago" => 2693976)
+```
+Certainly! Here's an additional important note about dictionaries in Julia:
+
+###  Dictionary Keys and Types
+
+In Julia, keys in a dictionary must be of a type that is both **hashable** and **immutable**. This requirement ensures that dictionaries can efficiently manage and retrieve values based on their keys. 
+
+#### Hashable and Immutable Keys:
+
+1. **Hashable**: This means that the type of the key must have a stable and consistent way to compute its hash value. Most built-in types in Julia, such as `Int`, `String`, `Symbol`, and `Tuple` (if their elements are hashable), are hashable by default.
+
+   Example of hashable types:
+   - `Int`
+   - `String`
+   - `Symbol`
+   - `Tuple` (if elements are hashable)
+
+2. **Immutable**: Once a key is placed in a dictionary, its value should not be able to change. This ensures that the hash value remains consistent. Immutable types in Julia include basic types like `Int`, `Float64`, `String`, and `Tuple`.
+
+   Example of immutable types:
+   - `Int`
+   - `Float64`
+   - `String`
+   - `Tuple`
+
+#### Example 
+
+Some types in Julia are mutable or do not have a stable hash computation, making them unsuitable as dictionary keys:
+
+- `Array`: Arrays are mutable and can change their contents, so they cannot be used as dictionary keys.
+- `Dict`: Dictionaries themselves cannot be keys in other dictionaries due to mutability.
+- Custom mutable types: If you define a custom type that is mutable, you need to ensure it implements proper hashing methods (`hash()` function) for it to be used as a dictionary key.
+
+#### Example 
+
+Here’s an example illustrating the use of types as dictionary keys:
+
+```julia
+# Valid keys
+dict_valid = Dict(1 => "One", "two" => 2.0, (3, "three") => "Tuple key")
+
+# Invalid keys (will throw an error)
+dict_invalid = Dict([1, 2, 3] => "Array key")
+```
+
+In this example:
+- `1`, `"two"`, and `(3, "three")` are valid keys because they are of types that are hashable and immutable.
+- `[1, 2, 3]` is an invalid key because arrays are mutable in Julia.
+
+### Accessing Values in a Dictionary
+
+To access a value in the dictionary, you use square brackets `[]` with the key:
+
+```julia
+println(city_populations["New York"])  # Output: 8336817
+```
+
+If the key doesn't exist in the dictionary, Julia will throw a `KeyError`.
+
+### Adding and Modifying Entries
+
+You can add new entries or modify existing ones in a dictionary using the same square bracket notation:
+
+```julia
+city_populations["Houston"] = 2320268  # Adding a new entry
+city_populations["Chicago"] = 2716000  # Modifying an existing entry
+```
+
+### Removing Entries
+
+To remove an entry from a dictionary, use the `delete!()` function:
+
+```julia
+delete!(city_populations, "Los Angeles")
+```
+
+### Checking Key Existence
+
+You can check if a key exists in a dictionary using the `haskey()` function:
+
+```julia
+if haskey(city_populations, "New York")
+    println("New York is in the dictionary.")
+end
+```
+
+### Iterating Over a Dictionary
+
+You can iterate over all key-value pairs in a dictionary using a `for` loop:
+
+```julia
+for (city, population) in city_populations
+    println("$city has a population of $population")
+end
+```
+
+### Dictionary Methods
+
+Julia provides several useful functions to work with dictionaries:
+
+- `keys(dict)`: Returns an iterator over the keys of the dictionary.
+- `values(dict)`: Returns an iterator over the values of the dictionary.
+- `isempty(dict)`: Returns `true` if the dictionary is empty, `false` otherwise.
+- `merge!(dict1, dict2)`: Merges `dict2` into `dict1`, modifying `dict1`.
+
+### Example Code and Output
+
+Here’s a complete example demonstrating the use of dictionaries in Julia:
+
+```julia
+# Creating a dictionary
+city_populations = Dict("New York" => 8336817, "Los Angeles" => 3979576, "Chicago" => 2693976)
+
+# Accessing a value
+println(city_populations["New York"])  # Output: 8336817
+
+# Adding a new entry
+city_populations["Houston"] = 2320268
+
+# Modifying an existing entry
+city_populations["Chicago"] = 2716000
+
+# Removing an entry
+delete!(city_populations, "Los Angeles")
+
+# Iterating over the dictionary
+for (city, population) in city_populations
+    println("$city has a population of $population")
+end
+
+# Checking key existence
+if haskey(city_populations, "New York")
+    println("New York is in the dictionary.")
+end
+```
+
+#### Output:
+```
+New York has a population of 8336817
+Chicago has a population of 2716000
+Houston has a population of 2320268
+New York is in the dictionary.
+```
+
+### Conclusion 
+ Dictionary data structure in Julia offers a powerful mechanism for associating keys with corresponding values, akin to hash maps or associative arrays in other languages. It allows for efficient storage and retrieval of data pairs, accommodating keys of any immutable type and values of any type. Operations like insertion, deletion, and updating of entries are straightforward and optimized for performance. Iteration over keys and values, along with methods for checking existence and merging dictionaries, further enhance its utility. Overall, Dictionary in Julia is indispensable for managing and manipulating structured data, providing flexibility and efficiency in various programming contexts. Its versatility makes it well-suited for tasks ranging from simple data mappings to complex data aggregation and manipulation operations.

docs/Julia/dicti.md

@@ -0,0 +1,190 @@
+---
+id: set-julia
+title: Set
+sidebar_label: Julia Set
+sidebar_position: 7
+tags: [Julia, Set, Methods of Set]
+---
+
+In Julia, a `Set` is a collection of unique elements where each element can only appear once within the set. Sets are useful when you need to store a collection of items without duplicates and perform operations such as membership testing and set operations (like union, intersection, etc.).
+
+### Creating Sets
+
+You can create a set in Julia using curly braces `{}` and separating elements with commas. Let's create a set with some integers and strings:
+
+```julia
+# Creating a set of integers
+int_set = Set([1, 2, 3, 4, 5, 2, 3])  # Duplicate elements are automatically removed
+println("Integer Set: ", int_set)
+
+# Creating a set of strings
+str_set = Set(["apple", "banana", "orange", "banana"])  # Duplicate "banana" is removed
+println("String Set: ", str_set)
+```
+
+**Output:**
+```julia
+Integer Set: Set([4, 2, 3, 5, 1])
+String Set: Set(["orange", "apple", "banana"])
+```
+
+### Operations on Sets
+
+#### Membership Testing
+You can check if an element is present in a set using the `in` operator:
+
+```julia
+fruit_set = Set(["apple", "banana", "orange"])
+
+println("Is 'apple' in fruit_set? ", "apple" in fruit_set)
+println("Is 'grape' in fruit_set? ", "grape" in fruit_set)
+```
+
+**Output:**
+```julia
+Is 'apple' in fruit_set? true
+Is 'grape' in fruit_set? false
+```
+
+
+In Julia, a `Set` is a collection type that stores unique elements, where each element can only appear once within the set. Sets are useful when you need to ensure uniqueness of elements and perform operations like membership testing, union, intersection, and difference efficiently.
+
+### Methods and Functions for Sets in Julia
+
+#### 1. **Adding and Removing Elements**
+
+Sets in Julia are mutable, which means you can modify them by adding or removing elements.
+
+- **Adding elements**: Use the `push!()` function to add an element to a set.
+
+```julia
+fruits = Set(["apple", "banana", "orange"])
+push!(fruits, "grape")
+```
+
+- **Removing elements**: Use the `pop!()` function to remove an element from a set.
+
+```julia
+pop!(fruits, "banana")
+```
+
+#### 2. **Set Operations**
+
+Julia provides various functions for set operations. These functions can be called directly on sets or by using the infix operators `∪`, `∩`, and `-`.
+
+- **Union**: Combines elements from two sets, removing duplicates.
+
+```julia
+set1 = Set([1, 2, 3])
+set2 = Set([3, 4, 5])
+
+union_set = union(set1, set2)
+```
+
+Alternatively, using infix operator:
+
+```julia
+union_set = set1 ∪ set2
+```
+
+- **Intersection**: Finds common elements between two sets.
+
+```julia
+intersection_set = intersect(set1, set2)
+```
+
+Alternatively, using infix operator:
+
+```julia
+intersection_set = set1 ∩ set2
+```
+
+- **Difference**: Finds elements in one set but not in another.
+
+```julia
+difference_set = setdiff(set1, set2)
+```
+
+#### 3. **Membership Testing**
+
+You can check if an element is present in a set using the `in` keyword or the `in()` function.
+
+```julia
+fruits = Set(["apple", "banana", "orange"])
+
+if "apple" in fruits
+    println("Apple is in the set!")
+end
+```
+
+#### 4. **Set Comparisons**
+
+You can compare sets using `==` and `isequal()` functions to check if two sets contain the same elements.
+
+```julia
+set1 = Set([1, 2, 3])
+set2 = Set([3, 2, 1])
+
+println(set1 == set2)  # true
+println(isequal(set1, set2))  # true
+```
+
+#### 5. **Set Size and Emptiness**
+
+You can get the number of elements in a set using `length()` function and check if a set is empty using `isempty()` function.
+
+```julia
+println(length(set1))
+println(isempty(set1))
+```
+
+### Example
+
+```julia
+set1 = Set([1, 2, 3, 4])
+set2 = Set([3, 4, 5, 6])
+
+println("Set 1: ", set1)
+println("Set 2: ", set2)
+
+union_set = set1 ∪ set2
+println("Union: ", union_set)
+
+intersection_set = set1 ∩ set2
+println("Intersection: ", intersection_set)
+
+difference_set = setdiff(set1, set2)
+println("Difference (Set 1 - Set 2): ", difference_set)
+
+push!(set1, 5)
+println("After adding 5 to Set 1: ", set1)
+
+pop!(set2, 4)
+println("After removing 4 from Set 2: ", set2)
+
+println("Is 3 in Set 1? ", 3 in set1)
+println("Is 7 in Set 2? ", 7 in set2)
+
+println("Length of Set 1: ", length(set1))
+println("Is Set 2 empty? ", isempty(set2))
+```
+
+**Output:**
+```julia
+Set 1: Set([4, 2, 3, 1])
+Set 2: Set([4, 3, 5, 6])
+Union: Set([4, 2, 3, 5, 6, 1])
+Intersection: Set([4, 3])
+Difference (Set 1 - Set 2): Set([2, 1])
+After adding 5 to Set 1: Set([4, 2, 3, 5, 1])
+After removing 4 from Set 2: Set([3, 5, 6])
+Is 3 in Set 1? true
+Is 7 in Set 2? false
+Length of Set 1: 5
+Is Set 2 empty? false
+```
+
+
+### Conclusion
+
+Sets in Julia are versatile data structures for managing unique collections of elements. They offer efficient membership testing and set operations, making them suitable for various computational tasks where uniqueness and set operations are key requirements.