From 9232b054d91d33616c258e3385bd7f1ab595953b Mon Sep 17 00:00:00 2001 From: mitul-bhatia Date: Mon, 28 Oct 2024 19:29:45 +0530 Subject: [PATCH 1/8] Update index-style.css see I added some more css animation to the index , such that it is much more user responsive and effective to the user . --- css/index-style.css | 154 ++++++++++++++++++++++++-------------------- 1 file changed, 83 insertions(+), 71 deletions(-) diff --git a/css/index-style.css b/css/index-style.css index 2a1f0c6..53cdf2d 100644 --- a/css/index-style.css +++ b/css/index-style.css @@ -1,118 +1,130 @@ -/* * { - padding: 0; - margin: 0; -} */ + body { - background-color: whitesmoke; - font-family: outfit, rubik; + background: linear-gradient(135deg, #ece9e6, #ffffff); + font-family: 'Outfit', 'Rubik', sans-serif; + color: #333; } + .container { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); min-height: 80vh; + gap: 1rem; + padding: 2rem; } + .container-item { - background-color: white; - border-radius: 5px; - margin: 1rem; - padding: 1rem; - height: min-content; + background: white; + border-radius: 10px; + overflow: hidden; + box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1); + transition: transform 0.3s ease, box-shadow 0.3s ease; } + +.container-item:hover { + transform: scale(1.05); + box-shadow: 0 8px 16px rgba(0, 0, 0, 0.2); +} + .container-item > .img-wrapper { display: flex; align-items: center; justify-content: center; width: 100%; - height: 13rem; + height: 14rem; + overflow: hidden; + transition: all 0.3s ease; } + .container-item > .img-wrapper > img { - object-fit: contain; + object-fit: cover; width: 100%; - border-radius: 5px; + height: 100%; + transition: transform 0.4s ease; + border-radius: 10px 10px 0 0; } -.container-item > .img-wrapper > img:hover { + +.container-item > .img-wrapper:hover > img { + transform: scale(1.1); cursor: pointer; } -.container-item > .img-wrapper:hover + h3 { - text-decoration: underline; -} + .container-item > h3 { - transition: all; - transition-duration: 200ms; - cursor: pointer; - margin: 0rem; - margin-top: 0.5rem; - display: -webkit-box; - -webkit-box-orient: vertical; - -webkit-line-clamp: 1; + margin: 0.75rem 0; + font-size: 1.2rem; + color: #333; + transition: color 0.3s ease; + white-space: nowrap; overflow: hidden; - - /* text-decoration: solid; */ + text-overflow: ellipsis; } + .container-item > h3:hover { + color: #3498db; text-decoration: underline; } + .container-item > p { - font-size: 10px; - color: gray; - line-clamp: 2; + font-size: 0.9rem; + color: #777; + margin-bottom: 1rem; + line-height: 1.5; display: -webkit-box; - -webkit-box-orient: vertical; -webkit-line-clamp: 2; + -webkit-box-orient: vertical; overflow: hidden; - padding: 0; -} -.container-item > div > button > h3 { - margin: 0; - padding: 0; - font-family: rubik; - font-weight: 100; } + .container-item > div > button { - border: 1px solid gainsboro; - border-radius: 3px; - padding-left: 10px; - padding-right: 10px; - padding-top: 5px; - padding-bottom: 5px; - margin-top: 0.9rem; - background: none; + border: 1px solid #3498db; + border-radius: 5px; + padding: 0.6rem 1rem; + margin-top: 0.5rem; + background: transparent; + color: #3498db; + font-size: 0.9rem; cursor: pointer; display: flex; align-items: center; gap: 0.5rem; - font-size: 10px; - transition: all; - transition-duration: 300ms; - background: transparent; + transition: all 0.3s ease; } + .container-item > div > button:hover { - border: 1px solid rgb(187, 187, 187); - background: rgba(0, 0, 0, 0.01); + background-color: #3498db; + color: #fff; + box-shadow: 0 4px 10px rgba(52, 152, 219, 0.3); } -@media only screen and (max-width: 600px) { +.container-item > div > button > h3 { + margin: 0; + padding: 0; + font-family: 'Rubik', sans-serif; + font-weight: 500; +} + +@media only screen and (max-width: 900px) { .container { - display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); + gap: 1.5rem; } - .container-item > h3 { - font-size: 13px; - display: -webkit-box; - -webkit-box-orient: vertical; - -webkit-line-clamp: 2; - } - .container-item { - background-color: white; - border-radius: 5px; - margin: 0.3rem; - padding: 0.8rem; +} + +@media only screen and (max-width: 600px) { + .container { + grid-template-columns: repeat(1, minmax(0, 1fr)); + padding: 1rem; } + .container-item > .img-wrapper { - display: flex; - align-items: center; - justify-content: center; - width: 100%; - height: 8rem; + height: 10rem; + } + + .container-item > h3 { + font-size: 1rem; + } + + .container-item > p { + font-size: 0.8rem; } } From 62eeed4c80771d018a1a586099cf789a0308634f Mon Sep 17 00:00:00 2001 From: mitul-bhatia Date: Mon, 28 Oct 2024 20:16:03 +0530 Subject: [PATCH 2/8] Added a binary search algorithm it will help in efficiently locate an element in a sorted list by repeatedly halving the search interval. --- .DS_Store | Bin 0 -> 6148 bytes blogs/blog_id_7.md | 38 +++++++++++ blogsList.json | 6 ++ css/index-style.css | 157 ++++++++++++++++++++++++-------------------- 4 files changed, 131 insertions(+), 70 deletions(-) create mode 100644 .DS_Store create mode 100644 blogs/blog_id_7.md diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..22f2aa336c7d45a248ca4b494517f9d238b50c74 GIT binary patch literal 6148 zcmeHKO^Xvj5UozKo5?O}6otJA171UnyRs0x#C!+=U11aTpb|5gusb@L4w-}qA&|5F z5HEsPe~JIalfLS1b@Js+ait5oUv+m?_0*f5?r9fkw3R z(<5$%OO~IuTYA%YXkvc$hG7toOQkO&mCo$!W}U3F@4RfC%V}%e9Z%wFcl4ZFZ7D7DT?BR^=q}W98e@15VD#b@B(Z*wZ17HyZ4O*D@P_LAj<)iY^uS~nRLm-O z_Alu3+sC#HSO)$a1H3=DD2x?@3yo^)K&7q#zzn*TK<6I@_HhkX3@$Wc1R}I6P`e6q z#Sq#Z{jRaA7+h%7?j+3RLztO`xuFO(JL0>_oJ2*Vtt|tVfn^5Lx|!$mzp?%PzwBgN zmI2Gaf5m{v)LZo`QZi@jT5^2Wx+t$uSlDi%QMsTp$FWlQC_X?@f-#pBV8!4 .img-wrapper { display: flex; align-items: center; justify-content: center; width: 100%; - height: 13rem; + height: 14rem; + overflow: hidden; + transition: all 0.3s ease; } + .container-item > .img-wrapper > img { - object-fit: contain; + object-fit: cover; width: 100%; - border-radius: 5px; + height: 100%; + transition: transform 0.4s ease; + border-radius: 10px 10px 0 0; } -.container-item > .img-wrapper > img:hover { + +.container-item > .img-wrapper:hover > img { + transform: scale(1.1); cursor: pointer; } -.container-item > .img-wrapper:hover + h3 { - text-decoration: underline; -} + .container-item > h3 { - transition: all; - transition-duration: 200ms; - cursor: pointer; - margin: 0rem; - margin-top: 0.5rem; - display: -webkit-box; - -webkit-box-orient: vertical; - -webkit-line-clamp: 1; + margin: 0.75rem 0; + font-size: 1.2rem; + color: #333; + transition: color 0.3s ease; + white-space: nowrap; overflow: hidden; - - /* text-decoration: solid; */ + text-overflow: ellipsis; } + .container-item > h3:hover { + color: #3498db; text-decoration: underline; } + .container-item > p { - font-size: 10px; - color: gray; - line-clamp: 2; + font-size: 0.9rem; + color: #777; + margin-bottom: 1rem; + line-height: 1.5; display: -webkit-box; - -webkit-box-orient: vertical; -webkit-line-clamp: 2; + -webkit-box-orient: vertical; overflow: hidden; - padding: 0; -} -.container-item > div > button > h3 { - margin: 0; - padding: 0; - font-family: rubik; - font-weight: 100; } + .container-item > div > button { - border: 1px solid gainsboro; - border-radius: 3px; - padding-left: 10px; - padding-right: 10px; - padding-top: 5px; - padding-bottom: 5px; - margin-top: 0.9rem; - background: none; + border: 1px solid #3498db; + border-radius: 5px; + padding: 0.6rem 1rem; + margin-top: 0.5rem; + background: transparent; + color: #3498db; + font-size: 0.9rem; cursor: pointer; display: flex; align-items: center; gap: 0.5rem; - font-size: 10px; - transition: all; - transition-duration: 300ms; - background: transparent; + transition: all 0.3s ease; } + .container-item > div > button:hover { - border: 1px solid rgb(187, 187, 187); - background: rgba(0, 0, 0, 0.01); + background-color: #3498db; + color: #fff; + box-shadow: 0 4px 10px rgba(52, 152, 219, 0.3); } -@media only screen and (max-width: 600px) { +.container-item > div > button > h3 { + margin: 0; + padding: 0; + font-family: 'Rubik', sans-serif; + font-weight: 500; +} + +@media only screen and (max-width: 900px) { .container { - display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); + gap: 1.5rem; } - .container-item > h3 { - font-size: 13px; - display: -webkit-box; - -webkit-box-orient: vertical; - -webkit-line-clamp: 2; - } - .container-item { - background-color: white; - border-radius: 5px; - margin: 0.3rem; - padding: 0.8rem; +} + +@media only screen and (max-width: 600px) { + .container { + grid-template-columns: repeat(1, minmax(0, 1fr)); + padding: 1rem; } + .container-item > .img-wrapper { - display: flex; - align-items: center; - justify-content: center; - width: 100%; - height: 8rem; + height: 10rem; } -} + + .container-item > h3 { + font-size: 1rem; + } + + .container-item > p { + font-size: 0.8rem; + } +} \ No newline at end of file From c362e750bc7664110ebff0bbd7a4ba946a53c346 Mon Sep 17 00:00:00 2001 From: mitul-bhatia Date: Mon, 28 Oct 2024 21:40:09 +0530 Subject: [PATCH 3/8] Heap Sort efficiently organizes data using a binary heap for optimal sorting. --- blogs/blog_id_7.md | 3 +- blogs/blog_id_8.md | 120 +++++++++++++++++++++++++++++++++++++++++++++ blogsList.json | 6 +++ 3 files changed, 128 insertions(+), 1 deletion(-) create mode 100644 blogs/blog_id_8.md diff --git a/blogs/blog_id_7.md b/blogs/blog_id_7.md index e32cde9..4baad9f 100644 --- a/blogs/blog_id_7.md +++ b/blogs/blog_id_7.md @@ -35,4 +35,5 @@ def binary_search(arr, target): array = [1, 3, 5, 7, 9, 11] target = 7 result = binary_search(array, target) -print("Target found at index:", result) # Output: Target found at index: 3 \ No newline at end of file +print("Target found at index:", result) # Output: Target found at index: 3 +``` \ No newline at end of file diff --git a/blogs/blog_id_8.md b/blogs/blog_id_8.md new file mode 100644 index 0000000..314094b --- /dev/null +++ b/blogs/blog_id_8.md @@ -0,0 +1,120 @@ +--- + +# Heap Sort Algorithm + +### Difficulty: Medium +**Topic**: Sorting Algorithms +**Time Complexity**: O(n log n) +**Space Complexity**: O(1) + +--- + +Heap Sort is a comparison-based sorting technique that uses a binary heap data structure. It builds a max heap (or min heap) and repeatedly extracts the maximum (or minimum) element to create a sorted array. The algorithm is efficient and performs well for large datasets. + +--- + +### Algorithm + +1. **Build the Heap**: + - Create a max heap from the input data. This step ensures that the largest element is at the root of the heap. +2. **Extract Elements**: + - Swap the root of the heap (maximum element) with the last element of the heap. + - Reduce the size of the heap by one. + - Heapify the root of the heap to maintain the max heap property. +3. **Repeat**: + - Continue the process until all elements are sorted. + +--- + +### Input and Output + +- **Input**: + - An array of integers to be sorted. +- **Output**: + - A sorted array in ascending order. + +--- + +### Example + +#### Input +```python +Array: [12, 11, 13, 5, 6, 7] +``` +#### Output +```python +Sorted Array: [5, 6, 7, 11, 12, 13] +``` +--- + +## Solution + +Below is a Python solution for the Heap Sort algorithm. + +```python +def heapify(arr, n, i): + largest = i # Initialize largest as root + left = 2 * i + 1 # left = 2*i + 1 + right = 2 * i + 2 # right = 2*i + 2 + + # Check if left child exists and is greater than root + if left < n and arr[left] > arr[largest]: + largest = left + + # Check if right child exists and is greater than largest so far + if right < n and arr[right] > arr[largest]: + largest = right + + # Change root if needed + if largest != i: + arr[i], arr[largest] = arr[largest], arr[i] # Swap + + # Heapify the root + heapify(arr, n, largest) + +def heap_sort(arr): + n = len(arr) + + # Build a max heap + for i in range(n // 2 - 1, -1, -1): + heapify(arr, n, i) + + # One by one extract elements from heap + for i in range(n - 1, 0, -1): + arr[i], arr[0] = arr[0], arr[i] # Swap + heapify(arr, i, 0) + +# Example usage +arr = [12, 11, 13, 5, 6, 7] +heap_sort(arr) +print("Sorted array is", arr) +``` + +--- + +### Pros and Cons + +- **Pros**: + - Efficient for large datasets. + - Performs well in worst-case scenarios compared to other sorting algorithms. + +- **Cons**: + - More complex to implement compared to simpler algorithms like bubble sort. + - Not stable (does not preserve the relative order of equal elements). + +--- + +### Use Cases + +- Suitable for applications where performance is critical. +- Used in implementing priority queues. +- Applicable in scenarios where the data is too large to fit into memory (external sorting). + +--- + +### Additional Challenges + +1. **Implement Min Heap**: Modify the algorithm to sort in descending order by implementing a min heap. +2. **Heap Sort with Duplicates**: Extend the algorithm to handle arrays with duplicate values while maintaining stability. + +--- \ No newline at end of file diff --git a/blogsList.json b/blogsList.json index 1da78fd..299d9e7 100644 --- a/blogsList.json +++ b/blogsList.json @@ -46,5 +46,11 @@ "image": "data:image/png;base64,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", "title": "Understanding Binary search Algorithm in Python", "description": "Efficiently locate an element in a sorted list by repeatedly halving the search interval." + }, + { + "id": "blog_id_8", + "image": "data:image/png;base64,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", + "title": "Understanding Heap Sort Algorithm in Python", + "description": "comparison-based sorting algorithm that utilizes a binary heap data structure to repeatedly extract the maximum (or minimum) element, resulting in a sorted array with a time complexity of O(n log n)." } ] From 388d123f1837e02c8e547c4bea98f395d9c7d6f2 Mon Sep 17 00:00:00 2001 From: mitul-bhatia Date: Mon, 28 Oct 2024 21:49:59 +0530 Subject: [PATCH 4/8] Efficiently locate an element in a sorted list by repeatedly halving the search interval. --- blogs/blog_id_8.md | 120 --------------------------------------------- blogsList.json | 7 +-- 2 files changed, 1 insertion(+), 126 deletions(-) delete mode 100644 blogs/blog_id_8.md diff --git a/blogs/blog_id_8.md b/blogs/blog_id_8.md deleted file mode 100644 index 314094b..0000000 --- a/blogs/blog_id_8.md +++ /dev/null @@ -1,120 +0,0 @@ ---- - -# Heap Sort Algorithm - -### Difficulty: Medium -**Topic**: Sorting Algorithms -**Time Complexity**: O(n log n) -**Space Complexity**: O(1) - ---- - -Heap Sort is a comparison-based sorting technique that uses a binary heap data structure. It builds a max heap (or min heap) and repeatedly extracts the maximum (or minimum) element to create a sorted array. The algorithm is efficient and performs well for large datasets. - ---- - -### Algorithm - -1. **Build the Heap**: - - Create a max heap from the input data. This step ensures that the largest element is at the root of the heap. -2. **Extract Elements**: - - Swap the root of the heap (maximum element) with the last element of the heap. - - Reduce the size of the heap by one. - - Heapify the root of the heap to maintain the max heap property. -3. **Repeat**: - - Continue the process until all elements are sorted. - ---- - -### Input and Output - -- **Input**: - - An array of integers to be sorted. -- **Output**: - - A sorted array in ascending order. - ---- - -### Example - -#### Input -```python -Array: [12, 11, 13, 5, 6, 7] -``` -#### Output -```python -Sorted Array: [5, 6, 7, 11, 12, 13] -``` ---- - -## Solution - -Below is a Python solution for the Heap Sort algorithm. - -```python -def heapify(arr, n, i): - largest = i # Initialize largest as root - left = 2 * i + 1 # left = 2*i + 1 - right = 2 * i + 2 # right = 2*i + 2 - - # Check if left child exists and is greater than root - if left < n and arr[left] > arr[largest]: - largest = left - - # Check if right child exists and is greater than largest so far - if right < n and arr[right] > arr[largest]: - largest = right - - # Change root if needed - if largest != i: - arr[i], arr[largest] = arr[largest], arr[i] # Swap - - # Heapify the root - heapify(arr, n, largest) - -def heap_sort(arr): - n = len(arr) - - # Build a max heap - for i in range(n // 2 - 1, -1, -1): - heapify(arr, n, i) - - # One by one extract elements from heap - for i in range(n - 1, 0, -1): - arr[i], arr[0] = arr[0], arr[i] # Swap - heapify(arr, i, 0) - -# Example usage -arr = [12, 11, 13, 5, 6, 7] -heap_sort(arr) -print("Sorted array is", arr) -``` - ---- - -### Pros and Cons - -- **Pros**: - - Efficient for large datasets. - - Performs well in worst-case scenarios compared to other sorting algorithms. - -- **Cons**: - - More complex to implement compared to simpler algorithms like bubble sort. - - Not stable (does not preserve the relative order of equal elements). - ---- - -### Use Cases - -- Suitable for applications where performance is critical. -- Used in implementing priority queues. -- Applicable in scenarios where the data is too large to fit into memory (external sorting). - ---- - -### Additional Challenges - -1. **Implement Min Heap**: Modify the algorithm to sort in descending order by implementing a min heap. -2. **Heap Sort with Duplicates**: Extend the algorithm to handle arrays with duplicate values while maintaining stability. - ---- \ No newline at end of file diff --git a/blogsList.json b/blogsList.json index 299d9e7..42965ef 100644 --- a/blogsList.json +++ b/blogsList.json @@ -46,11 +46,6 @@ "image": "data:image/png;base64,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", "title": "Understanding Binary search Algorithm in Python", "description": "Efficiently locate an element in a sorted list by repeatedly halving the search interval." - }, - { - "id": "blog_id_8", - "image": "data:image/png;base64,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", - "title": "Understanding Heap Sort Algorithm in Python", - "description": "comparison-based sorting algorithm that utilizes a binary heap data structure to repeatedly extract the maximum (or minimum) element, resulting in a sorted array with a time complexity of O(n log n)." } + ] From c971628da6b1e024c185ea6e39f94b90e9f8f7e3 Mon Sep 17 00:00:00 2001 From: mitul-bhatia Date: Mon, 28 Oct 2024 22:11:18 +0530 Subject: [PATCH 5/8] comparison-based sorting algorithm that utilizes a binary heap data structure to repeatedly extract the maximum (or minimum) element, resulting in a sorted array with a time complexity of O(n log n). --- blogs/blog_id_8.md | 120 +++++++++++++++++++++++++++++++++++++++++++++ blogsList.json | 8 +++ 2 files changed, 128 insertions(+) create mode 100644 blogs/blog_id_8.md diff --git a/blogs/blog_id_8.md b/blogs/blog_id_8.md new file mode 100644 index 0000000..314094b --- /dev/null +++ b/blogs/blog_id_8.md @@ -0,0 +1,120 @@ +--- + +# Heap Sort Algorithm + +### Difficulty: Medium +**Topic**: Sorting Algorithms +**Time Complexity**: O(n log n) +**Space Complexity**: O(1) + +--- + +Heap Sort is a comparison-based sorting technique that uses a binary heap data structure. It builds a max heap (or min heap) and repeatedly extracts the maximum (or minimum) element to create a sorted array. The algorithm is efficient and performs well for large datasets. + +--- + +### Algorithm + +1. **Build the Heap**: + - Create a max heap from the input data. This step ensures that the largest element is at the root of the heap. +2. **Extract Elements**: + - Swap the root of the heap (maximum element) with the last element of the heap. + - Reduce the size of the heap by one. + - Heapify the root of the heap to maintain the max heap property. +3. **Repeat**: + - Continue the process until all elements are sorted. + +--- + +### Input and Output + +- **Input**: + - An array of integers to be sorted. +- **Output**: + - A sorted array in ascending order. + +--- + +### Example + +#### Input +```python +Array: [12, 11, 13, 5, 6, 7] +``` +#### Output +```python +Sorted Array: [5, 6, 7, 11, 12, 13] +``` +--- + +## Solution + +Below is a Python solution for the Heap Sort algorithm. + +```python +def heapify(arr, n, i): + largest = i # Initialize largest as root + left = 2 * i + 1 # left = 2*i + 1 + right = 2 * i + 2 # right = 2*i + 2 + + # Check if left child exists and is greater than root + if left < n and arr[left] > arr[largest]: + largest = left + + # Check if right child exists and is greater than largest so far + if right < n and arr[right] > arr[largest]: + largest = right + + # Change root if needed + if largest != i: + arr[i], arr[largest] = arr[largest], arr[i] # Swap + + # Heapify the root + heapify(arr, n, largest) + +def heap_sort(arr): + n = len(arr) + + # Build a max heap + for i in range(n // 2 - 1, -1, -1): + heapify(arr, n, i) + + # One by one extract elements from heap + for i in range(n - 1, 0, -1): + arr[i], arr[0] = arr[0], arr[i] # Swap + heapify(arr, i, 0) + +# Example usage +arr = [12, 11, 13, 5, 6, 7] +heap_sort(arr) +print("Sorted array is", arr) +``` + +--- + +### Pros and Cons + +- **Pros**: + - Efficient for large datasets. + - Performs well in worst-case scenarios compared to other sorting algorithms. + +- **Cons**: + - More complex to implement compared to simpler algorithms like bubble sort. + - Not stable (does not preserve the relative order of equal elements). + +--- + +### Use Cases + +- Suitable for applications where performance is critical. +- Used in implementing priority queues. +- Applicable in scenarios where the data is too large to fit into memory (external sorting). + +--- + +### Additional Challenges + +1. **Implement Min Heap**: Modify the algorithm to sort in descending order by implementing a min heap. +2. **Heap Sort with Duplicates**: Extend the algorithm to handle arrays with duplicate values while maintaining stability. + +--- \ No newline at end of file diff --git a/blogsList.json b/blogsList.json index 42965ef..bd37f85 100644 --- a/blogsList.json +++ b/blogsList.json @@ -46,6 +46,14 @@ "image": "data:image/png;base64,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", "title": "Understanding Binary search Algorithm in Python", "description": "Efficiently locate an element in a sorted list by repeatedly halving the search interval." + }, + { + + "id": "blog_id_8", + "image": "data:image/png;base64,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", + "title": "Understanding Heap Sort Algorithm in Python", + "description": "comparison-based sorting algorithm that utilizes a binary heap data structure to repeatedly extract the maximum (or minimum) element, resulting in a sorted array with a time complexity of O(n log n)." } + ] From a170bfb12e057a57f7b6a4665bb202c6994b9df4 Mon Sep 17 00:00:00 2001 From: mitul-bhatia Date: Mon, 28 Oct 2024 22:43:30 +0530 Subject: [PATCH 6/8] updated UI --- css/index-style.css | 194 ++++++++++++++++++++++++++++++++++++-------- 1 file changed, 160 insertions(+), 34 deletions(-) diff --git a/css/index-style.css b/css/index-style.css index 5b066e2..b5851d6 100644 --- a/css/index-style.css +++ b/css/index-style.css @@ -1,32 +1,65 @@ -/* * { +* { padding: 0; margin: 0; -} */ + box-sizing: border-box; +} + body { - background: linear-gradient(135deg, #ece9e6, #ffffff); + background: linear-gradient(135deg, #e3f2fd, #ffffff); font-family: 'Outfit', 'Rubik', sans-serif; color: #333; + line-height: 1.6; + overflow-x: hidden; } .container { display: grid; - grid-template-columns: repeat(4, minmax(0, 1fr)); + grid-template-columns: repeat(4, 1fr); min-height: 80vh; - gap: 1rem; + gap: 2rem; padding: 2rem; + max-width: 1200px; + margin: 0 auto; } .container-item { - background: white; - border-radius: 10px; + background: #ffffff; + border-radius: 15px; overflow: hidden; - box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1); + box-shadow: 0 10px 30px rgba(0, 0, 0, 0.1); transition: transform 0.3s ease, box-shadow 0.3s ease; + position: relative; + overflow: hidden; + animation: fadeIn 0.5s ease-in-out; +} + +@keyframes fadeIn { + from { + opacity: 0; + transform: translateY(20px); + } + to { + opacity: 1; + transform: translateY(0); + } } .container-item:hover { - transform: scale(1.05); - box-shadow: 0 8px 16px rgba(0, 0, 0, 0.2); + transform: translateY(-15px); + box-shadow: 0 20px 50px rgba(0, 0, 0, 0.3); + animation: pulse 0.3s ease forwards; +} + +@keyframes pulse { + 0% { + transform: scale(1); + } + 50% { + transform: scale(1.05); + } + 100% { + transform: scale(1); + } } .container-item > .img-wrapper { @@ -34,7 +67,7 @@ body { align-items: center; justify-content: center; width: 100%; - height: 14rem; + height: 18rem; overflow: hidden; transition: all 0.3s ease; } @@ -43,60 +76,135 @@ body { object-fit: cover; width: 100%; height: 100%; - transition: transform 0.4s ease; - border-radius: 10px 10px 0 0; + transition: transform 0.5s ease, filter 0.5s ease; + border-radius: 15px 15px 0 0; + filter: brightness(85%); } .container-item > .img-wrapper:hover > img { - transform: scale(1.1); + transform: scale(1.2) rotate(5deg); cursor: pointer; + filter: brightness(100%); } .container-item > h3 { - margin: 0.75rem 0; - font-size: 1.2rem; - color: #333; - transition: color 0.3s ease; + margin: 1rem 0; + font-size: 2.5rem; /* Increased font size */ + color: #34495e; + transition: color 0.3s ease, transform 0.3s ease; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; + position: relative; + display: inline-block; + animation: popIn 0.5s ease forwards; +} + +@keyframes popIn { + 0% { + transform: scale(0.5); + opacity: 0; + } + 100% { + transform: scale(1); + opacity: 1; + } } -.container-item > h3:hover { - color: #3498db; +.container-item:hover > h3 { + color: #2980b9; text-decoration: underline; + transform: scale(1.1) rotate(-2deg); + animation: swing 0.5s ease forwards; +} + +@keyframes swing { + 0% { + transform: rotate(0deg); + } + 25% { + transform: rotate(5deg); + } + 50% { + transform: rotate(-5deg); + } + 100% { + transform: rotate(0deg); + } } .container-item > p { - font-size: 0.9rem; - color: #777; + font-size: 1rem; + color: #7f8c8d; margin-bottom: 1rem; - line-height: 1.5; + line-height: 1.6; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden; + transition: color 0.3s ease, transform 0.3s ease; +} + +.container-item:hover > p { + color: #2980b9; + transform: translateY(-5px); + animation: fadeIn 0.4s ease-in; } .container-item > div > button { - border: 1px solid #3498db; + border: 2px solid #2980b9; border-radius: 5px; - padding: 0.6rem 1rem; + padding: 0.7rem 1.2rem; margin-top: 0.5rem; background: transparent; - color: #3498db; + color: #2980b9; font-size: 0.9rem; cursor: pointer; display: flex; align-items: center; gap: 0.5rem; - transition: all 0.3s ease; + position: relative; + overflow: hidden; + transition: background-color 0.4s ease, color 0.4s ease, box-shadow 0.4s ease, transform 0.4s ease; + animation: pop 1s infinite alternate; +} + +@keyframes pop { + 0% { + transform: scale(1); + } + 50% { + transform: scale(1.05); + } + 100% { + transform: scale(1); + } } .container-item > div > button:hover { - background-color: #3498db; + background-color: #2980b9; color: #fff; - box-shadow: 0 4px 10px rgba(52, 152, 219, 0.3); + box-shadow: 0 4px 10px rgba(41, 128, 185, 0.3); + transform: translateY(-3px) rotate(1deg); + animation: shake 0.3s ease forwards; +} + +@keyframes shake { + 0% { + transform: translate(0); + } + 25% { + transform: translate(-3px); + } + 50% { + transform: translate(3px); + } + 75% { + transform: translate(-3px); + } + 100% { + transform: translate(0); + } } .container-item > div > button > h3 { @@ -106,28 +214,46 @@ body { font-weight: 500; } +.container-item > div > button::before { + content: ""; + position: absolute; + width: 100%; + height: 100%; + border-radius: 5px; + background: rgba(41, 128, 185, 0.3); + top: 0; + left: 0; + transform: scale(0); + transition: transform 0.4s ease; + z-index: 0; +} + +.container-item > div > button:hover::before { + transform: scale(1); +} + @media only screen and (max-width: 900px) { .container { - grid-template-columns: repeat(2, minmax(0, 1fr)); + grid-template-columns: repeat(2, 1fr); gap: 1.5rem; } } @media only screen and (max-width: 600px) { .container { - grid-template-columns: repeat(1, minmax(0, 1fr)); + grid-template-columns: repeat(1, 1fr); padding: 1rem; } .container-item > .img-wrapper { - height: 10rem; + height: 12rem; } .container-item > h3 { - font-size: 1rem; + font-size: 2rem; /* Adjusted font size for smaller screens */ } .container-item > p { - font-size: 0.8rem; + font-size: 0.85rem; } } \ No newline at end of file From 39e237deaa647c7d1d55c9d889d5bc2285dfe0df Mon Sep 17 00:00:00 2001 From: mitul-bhatia Date: Mon, 28 Oct 2024 23:24:14 +0530 Subject: [PATCH 7/8] bookmark file update --- bookmarked.html | 48 ++++++++ css/index-style.css | 294 ++++++++++++++------------------------------ index.html | 164 ++++++++++++------------ 3 files changed, 224 insertions(+), 282 deletions(-) create mode 100644 bookmarked.html diff --git a/bookmarked.html b/bookmarked.html new file mode 100644 index 0000000..2286a26 --- /dev/null +++ b/bookmarked.html @@ -0,0 +1,48 @@ + + + + + + Bookmarked Blogs + + + + +

Bookmarked Blogs

+
+ + + + \ No newline at end of file diff --git a/css/index-style.css b/css/index-style.css index b5851d6..85d8ad7 100644 --- a/css/index-style.css +++ b/css/index-style.css @@ -1,259 +1,149 @@ -* { +/* * { padding: 0; margin: 0; - box-sizing: border-box; -} - +} */ body { - background: linear-gradient(135deg, #e3f2fd, #ffffff); - font-family: 'Outfit', 'Rubik', sans-serif; - color: #333; - line-height: 1.6; - overflow-x: hidden; + background-color: whitesmoke; + font-family: outfit, rubik; } - .container { display: grid; - grid-template-columns: repeat(4, 1fr); + grid-template-columns: repeat(4, minmax(0, 1fr)); min-height: 80vh; - gap: 2rem; - padding: 2rem; - max-width: 1200px; - margin: 0 auto; } - .container-item { - background: #ffffff; - border-radius: 15px; - overflow: hidden; - box-shadow: 0 10px 30px rgba(0, 0, 0, 0.1); - transition: transform 0.3s ease, box-shadow 0.3s ease; - position: relative; - overflow: hidden; - animation: fadeIn 0.5s ease-in-out; -} - -@keyframes fadeIn { - from { - opacity: 0; - transform: translateY(20px); - } - to { - opacity: 1; - transform: translateY(0); - } -} - -.container-item:hover { - transform: translateY(-15px); - box-shadow: 0 20px 50px rgba(0, 0, 0, 0.3); - animation: pulse 0.3s ease forwards; -} - -@keyframes pulse { - 0% { - transform: scale(1); - } - 50% { - transform: scale(1.05); - } - 100% { - transform: scale(1); - } + background-color: white; + border-radius: 5px; + margin: 1rem; + padding: 1rem; + height: min-content; } - .container-item > .img-wrapper { display: flex; align-items: center; justify-content: center; width: 100%; - height: 18rem; - overflow: hidden; - transition: all 0.3s ease; + height: 13rem; } - .container-item > .img-wrapper > img { - object-fit: cover; + object-fit: contain; width: 100%; - height: 100%; - transition: transform 0.5s ease, filter 0.5s ease; - border-radius: 15px 15px 0 0; - filter: brightness(85%); + border-radius: 5px; } - -.container-item > .img-wrapper:hover > img { - transform: scale(1.2) rotate(5deg); +.container-item > .img-wrapper > img:hover { cursor: pointer; - filter: brightness(100%); } - +.container-item > .img-wrapper:hover + h3 { + text-decoration: underline; +} .container-item > h3 { - margin: 1rem 0; - font-size: 2.5rem; /* Increased font size */ - color: #34495e; - transition: color 0.3s ease, transform 0.3s ease; - white-space: nowrap; + transition: all; + transition-duration: 200ms; + cursor: pointer; + margin: 0rem; + margin-top: 0.5rem; + display: -webkit-box; + -webkit-box-orient: vertical; + -webkit-line-clamp: 1; overflow: hidden; - text-overflow: ellipsis; - position: relative; - display: inline-block; - animation: popIn 0.5s ease forwards; -} -@keyframes popIn { - 0% { - transform: scale(0.5); - opacity: 0; - } - 100% { - transform: scale(1); - opacity: 1; - } + /* text-decoration: solid; */ } - -.container-item:hover > h3 { - color: #2980b9; +.container-item > h3:hover { text-decoration: underline; - transform: scale(1.1) rotate(-2deg); - animation: swing 0.5s ease forwards; } - -@keyframes swing { - 0% { - transform: rotate(0deg); - } - 25% { - transform: rotate(5deg); - } - 50% { - transform: rotate(-5deg); - } - 100% { - transform: rotate(0deg); - } -} - .container-item > p { - font-size: 1rem; - color: #7f8c8d; - margin-bottom: 1rem; - line-height: 1.6; + font-size: 10px; + color: gray; + line-clamp: 2; display: -webkit-box; - -webkit-line-clamp: 2; -webkit-box-orient: vertical; + -webkit-line-clamp: 2; overflow: hidden; - transition: color 0.3s ease, transform 0.3s ease; + padding: 0; } - -.container-item:hover > p { - color: #2980b9; - transform: translateY(-5px); - animation: fadeIn 0.4s ease-in; +.container-item > div > button > h3 { + margin: 0; + padding: 0; + font-family: rubik; + font-weight: 100; } - .container-item > div > button { - border: 2px solid #2980b9; - border-radius: 5px; - padding: 0.7rem 1.2rem; - margin-top: 0.5rem; - background: transparent; - color: #2980b9; - font-size: 0.9rem; + border: 1px solid gainsboro; + border-radius: 3px; + padding-left: 10px; + padding-right: 10px; + padding-top: 5px; + padding-bottom: 5px; + margin-top: 0.9rem; + background: none; cursor: pointer; display: flex; align-items: center; gap: 0.5rem; - position: relative; - overflow: hidden; - transition: background-color 0.4s ease, color 0.4s ease, box-shadow 0.4s ease, transform 0.4s ease; - animation: pop 1s infinite alternate; -} - -@keyframes pop { - 0% { - transform: scale(1); - } - 50% { - transform: scale(1.05); - } - 100% { - transform: scale(1); - } + font-size: 10px; + transition: all; + transition-duration: 300ms; + background: transparent; } - .container-item > div > button:hover { - background-color: #2980b9; - color: #fff; - box-shadow: 0 4px 10px rgba(41, 128, 185, 0.3); - transform: translateY(-3px) rotate(1deg); - animation: shake 0.3s ease forwards; + border: 1px solid rgb(187, 187, 187); + background: rgba(0, 0, 0, 0.01); } -@keyframes shake { - 0% { - transform: translate(0); - } - 25% { - transform: translate(-3px); +@media only screen and (max-width: 600px) { + .container { + display: grid; + grid-template-columns: repeat(2, minmax(0, 1fr)); } - 50% { - transform: translate(3px); + .container-item > h3 { + font-size: 13px; + display: -webkit-box; + -webkit-box-orient: vertical; + -webkit-line-clamp: 2; } - 75% { - transform: translate(-3px); + .container-item { + background-color: white; + border-radius: 5px; + margin: 0.3rem; + padding: 0.8rem; } - 100% { - transform: translate(0); + .container-item > .img-wrapper { + display: flex; + align-items: center; + justify-content: center; + width: 100%; + height: 8rem; } } - -.container-item > div > button > h3 { - margin: 0; - padding: 0; - font-family: 'Rubik', sans-serif; - font-weight: 500; +.container-item { + margin: 1rem; + padding: 1rem; + border: 1px solid #ddd; + border-radius: 8px; + transition: box-shadow 0.3s; } -.container-item > div > button::before { - content: ""; - position: absolute; - width: 100%; - height: 100%; - border-radius: 5px; - background: rgba(41, 128, 185, 0.3); - top: 0; - left: 0; - transform: scale(0); - transition: transform 0.4s ease; - z-index: 0; +.container-item:hover { + box-shadow: 0px 4px 12px rgba(0, 0, 0, 0.1); } -.container-item > div > button:hover::before { - transform: scale(1); +.bookmark-btn { + background: none; + border: none; + cursor: pointer; + font-size: 1.2rem; + transition: color 0.3s; } -@media only screen and (max-width: 900px) { - .container { - grid-template-columns: repeat(2, 1fr); - gap: 1.5rem; - } +.bookmark-btn .fa-bookmark { + color: #aaa; } -@media only screen and (max-width: 600px) { - .container { - grid-template-columns: repeat(1, 1fr); - padding: 1rem; - } - - .container-item > .img-wrapper { - height: 12rem; - } - - .container-item > h3 { - font-size: 2rem; /* Adjusted font size for smaller screens */ - } +.bookmark-btn .fa-solid { + color: #ff5733; +} - .container-item > p { - font-size: 0.85rem; - } +.bookmark-btn:hover .fa-bookmark { + color: #ff5733; } \ No newline at end of file diff --git a/index.html b/index.html index 420386f..6fc59d4 100644 --- a/index.html +++ b/index.html @@ -1,86 +1,90 @@ - - - - - - - - Python problem solving blogs - - - - -