Mayank Pushpjeet’s Post

Day 68: 365 Days of DSA Challenge 🔍 Problem: Count Primes 📜 Description: Given an integer n, find and return the number of prime numbers that are strictly less than n. Approach 💡 Key Idea: The problem can be solved using the Sieve of Eratosthenes algorithm. This efficient algorithm helps us find all prime numbers up to a given limit in O(nloglogn) time complexity. 🛠 Steps to Solve: 1. Initialize an array prime[] of size n where each index represents whether that number is prime. Set prime[0] and prime[1] to 0 as 0 and 1 are not primes. 2. Start from 2 and mark all its multiples as non-prime. Continue for all numbers up to the square root of n. 3. After the sieve is complete, count the number of 1s in the prime[] array, which represents the prime numbers less than n. Efficiency ⏱️ Time Complexity: O(nlog⁡log⁡n), where n is the given integer. The sieve involves iterating over numbers and marking multiples, which is much faster than checking each number individually. 📦 Space Complexity: O(n). The space used is for the prime[] array to store prime information for all numbers less than n. Takeaway This problem leverages the Sieve of Eratosthenes, one of the most optimized algorithms for finding primes. It’s a great tool for efficiently solving problems related to prime numbers and number theory! 🌟 #365DaysOfDSA #Day68 #CountPrimes #SieveOfEratosthenes #PrimeNumbers

Here is an example of call by value and call by reference Call by Value * Concept: When a function is called, a copy of the actual argument's value is passed to the formal parameter. * Changes within the function: Any modifications made to the formal parameter within the function do not affect the original argument. * Example: #include <stdio.h> void swap(int x, int y) { int temp = x; x = y; y = temp; } int main() { int a = 10, b = 20; swap(a, b); printf("a = %d, b = %d\n", a, b); // Output: a = 10, b = 20 return 0; } Call by Reference * Concept: When a function is called, the memory address of the actual argument is passed to the formal parameter. * Changes within the function: Any modifications made to the formal parameter within the function directly affect the original argument. * Example: #include <stdio.h> void swap(int *x, int *y) { int temp = *x; *x = *y; *y = temp; } int main() { int a = 10, b = 20; swap(&a, &b); printf("a = %d, b = %d\n", a, b); // Output: a = 20, b = 10 return 0; }

Hey People! Today, let's chat about Linked Lists and how they're not quite the same as good old arrays. Think of it as a friendly conversation where we break down some tech stuff into easy-to-understand bits. Sound like a plan? Let's explore together! Memory Storage:- Arrays: Arrays are a way of storing data where each element is directly connected to the next one in line. Linked Lists: Linked lists store each element in separate memory locations and connect them using pointers. Adding and Removing Things:- Arrays: When you add or remove an element from an array, you might have to shift all the other elements, which can be time-consuming. Linked Lists: Adding or removing elements in a linked list is easier because you just need to adjust the pointers of neighboring elements. Finding Things Quickly:- Arrays: It's easy to find an element in an array because you just need to know its index. Linked Lists: Finding an element in a linked list can be challenging because you have to check each element one by one. Access Time:- Arrays: Accessing elements by index is efficient (O(1)) because elements are stored contiguously. Linked Lists: Accessing elements by index requires traversing the list from the head, which is less efficient (O(n)). Memory Overhead:- Arrays: Generally have less memory overhead because they only store the elements. Linked Lists: Have more memory overhead due to the additional memory required for storing pointers/references. Dynamic Size:- Arrays: In many languages, the size of an array is fixed at initialization and cannot be changed dynamically without reallocating memory. Linked Lists: Can easily grow or shrink in size dynamically by adding or removing nodes. Random Access:- Arrays: Support random access, meaning you can access any element directly by its index. Linked Lists: Do not support direct random access; you have to traverse the list from the beginning to reach a specific element. Cache Performance:- Arrays: Tend to have better cache performance because elements are stored contiguously, leading to better spatial locality. Linked Lists: Poorer cache performance due to non-contiguous memory allocation, leading to more cache misses.

A TC39 Proposal for Signals. A v0 draft of the signals proposal… | by EisenbergEffect | Apr, 2024 | Medium https://buff.ly/3U3iyl2 What are signals?A signal is a data type that enables one-way data flow by modeling cells of state and computations derived from other state/computations. The state and computations form an acyclic graph, where each node has other nodes that derive state from its value (sinks) and/or that contribute state to its value (sources). A node may also be tracked as “clean” or “dirty”.Source: A TC39 Proposal for Signals. A v0 draft of the signals proposal… | by EisenbergEffect | Apr, 2024 | Medium ()

📊 Efficiently extract valuable insights and pinpoint crucial relationships and influential elements in complex networks with the new Augmented Centrality analysis algorithm available now in Perspectives 13.0. This algorithm interprets Designer user input and returns the set of especially important nodes and edges in your graph, enhancing your analysis capabilities. Learn more at https://bit.ly/3V5suLA. #DataAnalysis #NetworkAnalysis #InnovationInTech

A TC39 Proposal for Signals. A v0 draft of the signals proposal… | by EisenbergEffect | Apr, 2024 | Medium https://buff.ly/3U3iyl2 What are signals?A signal is a data type that enables one-way data flow by modeling cells of state and computations derived from other state/computations. The state and computations form an acyclic graph, where each node has other nodes that derive state from its value (sinks) and/or that contribute state to its value (sources). A node may also be tracked as “clean” or “dirty”.Source: A TC39 Proposal for Signals. A v0 draft of the signals proposal… | by EisenbergEffect | Apr, 2024 | Medium ()

Calculated Columns vs Measures: Deciding Between the Two 📊 A commonn dilemma encountered by many when working with dashboards is not knowing what to use when. Lets break it down 💃💃💃💃💃 Just kidding Calculated columns perform the operation row by row across columns while Measures are calculations performed on the fly - calculations involiving aggregations/summarizations on the dataset However, there's a complexity to consider; it's not as straightforward as it might initially seem. Calculated columns remain static and unaffected by user interactions. But since they calculate values row by row and store them within the data model, they can consume significant memory resources. Measures, on the other hand, are ideal for dynamic calculations that adjust based on filters or selections. As they often involve aggregations across the dataset, measures tend to be CPU intensive and may impact report performance, especially with larger datasets The choice between them depends on the specific requirements of your analysis and the performance considerations of your dataset.

Pointer stability and data layout are tough to get right. Standard layout affects transportability and cache fetch. Union layout helps solve the problem but is harder to maintain.

Human memory storage methods include procedural memory and declarative memory. - LLMs seem to be closer to procedural memory. - Augmented data in techniques like RAG (Retrieval-Augmented Generation) and TAG (Table-Augmented Generation) seem to be closer to declarative memory.

Thermal Analysis is a process that simulates how heat flows through a component, allowing us to predict temperature distributions and how heat affects its performance. This can be achieved by solving variations of the heat equation, typically using finite element methods for large, complex components. Achieving accurate results often demands considerable computing power, which is where a HPC can help. Our on-site, secure HPC provides flexibilty and computing power to make simulations and analysis such as this possible. Contact us to find out how this can support your organisation. https://lnkd.in/ew8awVVG #DigitalEngineering #ThermalAnalysis #HPC