Merge branch 'main' into PradnyaGaitonde-patch-30

Author: ajay-dhangar

blog/Introduction to Cryptography and Cyber security.md

@@ -0,0 +1,84 @@
+---
+title: 'Cryptography and Its Use in Cyber Security'
+sidebar_label: Cryptography and Cyber Security
+authors: [pujan-sarkar]
+tags: [cryptography, cyber security, encryption, technology]
+date: 2024-06-24
+hide_table_of_contents: true
+---
+
+## Introduction
+
+In the realm of cyber security, cryptography stands as a critical tool for protecting information. As digital data exchange grows exponentially, the importance of cryptography in ensuring data security and privacy cannot be overstated. This blog explores the fundamental concepts of cryptography, its historical significance, and its contemporary applications in cyber security.
+
+## Understanding Cryptography
+
+Cryptography is the science of encoding and decoding information to protect it from unauthorized access. It involves various techniques and algorithms that transform readable data, known as plaintext, into an unreadable format, known as ciphertext. Only those who possess the appropriate decryption key can convert the ciphertext back into plaintext.
+
+### Key Concepts in Cryptography
+
+1. **Encryption and Decryption**: The process of converting plaintext into ciphertext is called encryption, while the process of converting ciphertext back into plaintext is called decryption.
+2. **Symmetric Key Cryptography**: The same key is used for both encryption and decryption. Examples include AES and DES.
+3. **Asymmetric Key Cryptography**: Uses a pair of keys - a public key for encryption and a private key for decryption. Examples include RSA and ECC.
+4. **Hash Functions**: Take an input and produce a fixed-size string of characters, which is typically a hash value. Hash functions are used for data integrity and password storage.
+
+## Historical Significance of Cryptography
+
+Cryptography has been used for centuries to secure communication. Some historical milestones include:
+
+- **Caesar Cipher**: Used by Julius Caesar to protect military messages, this substitution cipher shifts letters by a fixed number of positions in the alphabet.
+- **Enigma Machine**: Used by the Germans during World War II, this electromechanical device encrypted messages. The successful decryption of Enigma-encrypted messages by the Allies significantly impacted the war's outcome.
+- **Diffie-Hellman Key Exchange**: Introduced in 1976, this method allowed secure key exchange over a public channel, laying the groundwork for modern public-key cryptography.
+
+## Cryptography in Modern Cyber Security
+
+In today's digital world, cryptography is essential for securing data and maintaining privacy. Its applications are vast and varied:
+
+### Secure Communication
+
+Cryptography ensures that communication between parties remains confidential and secure. Protocols like SSL/TLS use cryptographic techniques to protect data transmitted over the internet, such as during online banking and shopping.
+
+### Data Integrity
+
+Hash functions play a crucial role in ensuring data integrity. When data is transmitted or stored, hash functions can verify that the data has not been altered. This is particularly important for software distribution and digital signatures.
+
+### Authentication
+
+Cryptographic methods are used to verify the identities of users and devices. Passwords are typically stored as hash values, and public-key infrastructure (PKI) systems use digital certificates to authenticate entities.
+
+### Blockchain Technology
+
+Cryptography is the backbone of blockchain technology. Cryptographic hashing ensures the integrity of data blocks, while asymmetric cryptography secures transactions and verifies identities. This technology underpins cryptocurrencies like Bitcoin and has applications in various fields, including supply chain management and healthcare.
+
+### Secure Storage
+
+Encrypting data at rest ensures that even if unauthorized individuals gain access to storage media, they cannot read the data without the decryption key. This is crucial for protecting sensitive information on devices and in cloud storage.
+
+## Challenges in Cryptography
+
+While cryptography is a powerful tool, it is not without challenges:
+
+- **Key Management**: Securely generating, storing, and distributing cryptographic keys is complex and critical for maintaining security.
+- **Performance Overheads**: Cryptographic operations can be computationally intensive, affecting system performance, especially in resource-constrained environments.
+- **Quantum Computing**: Emerging quantum computers have the potential to break many of the cryptographic algorithms currently in use, necessitating the development of quantum-resistant algorithms.
+
+## Future Directions in Cryptography
+
+The field of cryptography is continuously evolving to address emerging threats and challenges. Some future directions include:
+
+### Post-Quantum Cryptography
+
+With the advent of quantum computing, researchers are developing cryptographic algorithms that are resistant to quantum attacks. These algorithms aim to provide security even in the presence of powerful quantum computers.
+
+### Homomorphic Encryption
+
+This advanced form of encryption allows computations to be performed on encrypted data without decrypting it. Homomorphic encryption has significant implications for data privacy, particularly in cloud computing and data analysis.
+
+### Zero-Knowledge Proofs
+
+Zero-knowledge proofs enable one party to prove to another that a statement is true without revealing any information beyond the validity of the statement. This concept has applications in authentication, privacy-preserving protocols, and blockchain technology.
+
+## Conclusion
+
+Cryptography is a cornerstone of cyber security, providing the means to protect data and maintain privacy in an increasingly interconnected world. As technology advances and new threats emerge, the field of cryptography will continue to evolve, offering innovative solutions to ensure the security and integrity of our digital lives. By understanding and implementing cryptographic techniques, individuals and organizations can safeguard their information and build a secure future.
+

docusaurus.config.js

@@ -143,8 +143,10 @@ const config = {
                   <a href="/docs/category/python/" class="nav__icons"> <img src="/icons/py.svg" title="Python" alt="Python" /> </a>
                   <a href="/docs/category/java/" class="nav__icons"> <img src="/icons/java.svg" title="Java" alt="Java" /> </a>
                   <a href="/docs/category/tailwind/" class="nav__icons"> <img src="/icons/tailwind-css.svg" title="Tailwind CSS" alt="Tailwind" /> </a>
-                  <a href="/docs/category/cpp/" class="nav__icons"> <img src="/icons/cpp.svg" title="CPP" alt="CPP" /> </a>
-                  <a href="/docs/category/NextJs/" class="nav__icons"> <img src="/icons/next-js.svg" title="NextJs" alt="Next" /> </a>
+                  <a href="/docs/category/cpp/" class="nav__icons"> <img src="/icons/cpp.svg" title="CPP" alt="CPP" /> </a>      
+                  <a href="/docs/category/NextJs/" class="nav__icons"> <img src="/icons/next-js.svg" title="NextJs" alt="Next" /> </a>    
+                  <a href="/docs/category/MATLAB/" class="nav__icons"> <img src="/icons/matlab.svg" title="MATLAB" alt="MATLAB" /> </a> 
+                  <a href="/docs/category/Julia/" class="nav__icons"> <img src="/icons/julia.svg" title="Julia" alt="Julia" /> </a> 
                 </div>
               </div>`,
               },

dsa-solutions/lc-solutions/0000-0099/0065-valid-number.md

@@ -0,0 +1,124 @@
+---
+id: valid-number
+title: Valid Number(LeetCode)
+sidebar_label: 0065-Valid Number
+tags:
+  - String
+description: Given a string s, return whether s is a valid number.
+---
+
+## Problem Statement
+
+Given a string `s`, return whether `s` is a valid number.
+
+For example, all the following are valid numbers: `"2", "0089", "-0.1", "+3.14", "4.", "-.9", "2e10", "-90E3", "3e+7", "+6e-1", "53.5e93", "-123.456e789"`, while the following are not valid numbers: `"abc", "1a", "1e", "e3", "99e2.5", "--6", "-+3", "95a54e53"`.
+
+Formally, a valid number is defined using one of the following definitions:
+
+1. An integer number followed by an optional exponent.
+2. A decimal number followed by an optional exponent.
+An integer number is defined with an optional sign `'-'` or `'+'` followed by digits.
+
+A decimal number is defined with an optional sign `'-'` or `'+'` followed by one of the following definitions:
+
+1. Digits followed by a dot `'.'`.
+2. Digits followed by a dot `'.'` followed by digits.
+3. A dot `'.'` followed by digits.
+An exponent is defined with an exponent notation `'e'` or `'E'` followed by an integer number.
+
+The digits are defined as one or more digits.
+
+### Examples
+
+**Example 1:**
+
+```plaintext
+Input: s = "0"
+Output: true
+```
+
+**Example 2:**
+
+```plaintext
+Input: s = "e"
+Output: false
+```
+
+**Example 3:**
+
+```plaintext
+Input: s = "."
+Output: false
+```
+
+### Constraints
+
+- `1 <= s.length <= 20`
+- `s` consists of only English letters (both uppercase and lowercase), digits (`0-9`), plus `'+'`, minus `'-'`, or dot `'.'`.
+
+## Solution
+
+### Approach 
+
+#### Algorithm
+
+1. Trim the Input String: Remove leading and trailing whitespace using `s.trim()`.
+2. Initialize Flags:
+* `pointSeen`: Tracks if a decimal point has been encountered.
+* `eSeen`: Tracks if an exponent 'e' has been encountered.
+* `numberSeen`: Tracks if at least one digit has been encountered.
+* `numberAfterE`: Tracks if at least one digit exists after an 'e'.
+3. Iterate Over Each Character:
+* If the character is a digit (`0-9`), set `numberSeen` and `numberAfterE` to `true`.
+* If the character is a decimal point (`.`), ensure no 'e' or previous decimal point has been seen.
+* If the character is an exponent (`e`), ensure no previous 'e' has been seen and that at least one digit has been encountered before it. Set numberAfterE to false.
+* If the character is a sign (`+` or `-`), ensure it appears at the beginning or immediately after an 'e'.
+* If any other character is encountered, return `false`.
+4. Final Check: Ensure that at least one digit has been encountered (`numberSeen` is `true`) and if an 'e' was encountered, ensure there is at least one digit after it (`numberAfterE` is `true`).
+
+#### Implementation
+
+```Java
+public boolean isNumber(String s) {
+    s = s.trim();
+    
+    boolean pointSeen = false;
+    boolean eSeen = false;
+    boolean numberSeen = false;
+    boolean numberAfterE = true;
+    for(int i=0; i<s.length(); i++) {
+        if('0' <= s.charAt(i) && s.charAt(i) <= '9') {
+            numberSeen = true;
+            numberAfterE = true;
+        } else if(s.charAt(i) == '.') {
+            if(eSeen || pointSeen) {
+                return false;
+            }
+            pointSeen = true;
+        } else if(s.charAt(i) == 'e') {
+            if(eSeen || !numberSeen) {
+                return false;
+            }
+            numberAfterE = false;
+            eSeen = true;
+        } else if(s.charAt(i) == '-' || s.charAt(i) == '+') {
+            if(i != 0 && s.charAt(i-1) != 'e') {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+    
+    return numberSeen && numberAfterE;
+}
+```
+
+### Complexity Analysis
+
+- **Time complexity**: $O(N)$
+- **Space complexity**: $O(1)$
+
+### Conclusion
+
+The solution effectively validates if a string represents a valid number by processing it in a single pass and using flags to ensure the correct format. The key checks include ensuring correct placement of decimal points, exponents, and signs, as well as ensuring the presence of digits both before and after an exponent if present. This approach is efficient with a linear time complexity and constant space complexity.

dsa-solutions/lc-solutions/2500 - 3000/2548-Maximum Price to Fill a Bag.md

@@ -0,0 +1,113 @@
+---
+id: maximum-price-to-fill-a-bag
+title: Maximum Price to Fill a Bag
+sidebar_label: 2548 Maximum Price to Fill a Bag
+tags:
+  - Array
+  - Maths
+  - sort
+  - LeetCode
+  - java
+description: "This is a solution to the Maximum Price to Fill a Bag problem on LeetCode."
+---
+
+## Problem Description
+
+You are given a 2D integer array items where items[i] = [pricei, weighti] denotes the price and weight of the ith item, respectively.
+
+You are also given a positive integer capacity.
+
+Each item can be divided into two items with ratios part1 and part2, where part1 + part2 == 1.
+
+The weight of the first item is weighti * part1 and the price of the first item is pricei * part1.
+Similarly, the weight of the second item is weighti * part2 and the price of the second item is pricei * part2.
+Return the maximum total price to fill a bag of capacity capacity with given items. If it is impossible to fill a bag return -1. Answers within 10-5 of the actual answer will be considered accepted.
+
+
+### Examples
+
+**Example 1:**
+
+```
+Input: items = [[50,1],[10,8]], capacity = 5
+Output: 55.00000
+Explanation: 
+We divide the 2nd item into two parts with part1 = 0.5 and part2 = 0.5.
+
+```
+
+**Example 2:**
+
+```
+Input: items = [[100,30]], capacity = 50
+Output: -1.00000
+Explanation: It is impossible to fill a bag with the given item.
+ 
+```
+
+
+### Constraints
+
+- `1 <= items.length <= 105`
+- `items[i].length == 2`
+- `1 <= pricei, weighti <= 104`
+- `1 <= capacity <= 109` 
+
+### Approach 
+
+We sort the items in descending order by unit price, and then take out the items one by one until the backpack is full.
+
+If the backpack is not full in the end, return $-1$, otherwise return the total price.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(\log n)$, where $n$ is the number of items.
+
+#### Python3
+
+```python
+class Solution:
+    def maxPrice(self, items: List[List[int]], capacity: int) -> float:
+        ans = 0
+        for p, w in sorted(items, key=lambda x: x[1] / x[0]):
+            v = min(w, capacity)
+            ans += v / w * p
+            capacity -= v
+        return -1 if capacity else ans
+
+```
+
+#### Java
+
+```java
+class Solution {
+    public double maxPrice(int[][] items, int capacity) {
+        Arrays.sort(items, (a, b) -> a[1] * b[0] - a[0] * b[1]);
+        double ans = 0;
+        for (var e : items) {
+            int p = e[0], w = e[1];
+            int v = Math.min(w, capacity);
+            ans += v * 1.0 / w * p;
+            capacity -= v;
+        }
+        return capacity > 0 ? -1 : ans;
+    }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+    double maxPrice(vector<vector<int>>& items, int capacity) {
+        sort(items.begin(), items.end(), [&](const auto& a, const auto& b) { return a[1] * b[0] < a[0] * b[1]; });
+        double ans = 0;
+        for (auto& e : items) {
+            int p = e[0], w = e[1];
+            int v = min(w, capacity);
+            ans += v * 1.0 / w * p;
+            capacity -= v;
+        }
+        return capacity > 0 ? -1 : ans;
+    }
+};
+```