DEV Community: eluconsmidar

DSA at one place

eluconsmidar — Sat, 11 May 2024 19:34:46 +0000

Striver: takeuforward

Two pointers
Sliding window
Bit manipulation
Linked list
Binary search
Arrays
Dynamic programming
Graph
Recursion
Trie
Binary tree / Binary search tree
Stack and Queue
Greedy
Advanced data structure
DP interveiw questions

How to ask better questions?

eluconsmidar — Sat, 11 May 2024 19:27:04 +0000

You learn more from asking questions.
Questions frame the answers.

What's on your mind?
And what else?
What is the real challenge here?
What do you want?
How can I help you?
If you are saying 'yes' to this, what are you saying 'no' to?
What was the most useful for you?

Book : The coaching habit.

Anatomy of a good question?

Types of questions:

open ended question
close ended question / binary question
leading question / neutral or unbiased question
clear / direct question
ambiguous question
complex / loaded question
consice question

Good question?

situation:

low engagement
low growth

reason:

lack of focus
consistency

Framework for asking good questions:
PROACT

listening / decision framework
The visual mba - Jason barron

What is the real problem?

what objective are you trying to accomplish?
how will you measure the success?
what are tradeoffs?
build meaningful connections and be more empathetic.
be aware

Books recommended:

What's your problem
Socratic selling
The coaching habit
The visual mba
Non violent communication

credit: Chris Do

Constants in Solidity

eluconsmidar — Wed, 08 May 2024 17:08:56 +0000

Constants are variables that cannot be modified.

Their value is hard coded and using constants can save gas cost.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Constants {
     // coding convention to uppercase constant variables
     address public constant MY_ADDRESS = 0x777788889999AaAAbBbbCcccddDdeeeEfFFfCcCc;
     uint256 public constant MY_UINT= 123;
}

Variables in Solidity

eluconsmidar — Wed, 08 May 2024 17:04:08 +0000

There are 3 types of variables in Solidity

local
- declare inside a function
- not stored on the blockchain
state
- declared outside a function
- stored on the blockchain
global (provides information about the blockchain)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Variables {
     // State variables are stored on the blockchain.
     string public text = "Hello";
     uint256 public num = 123;

     function doSomething() public { 
          // Local variables are not saved to the blockchain.
          uint256 i = 456;

          // Here are some global variables
          uint256 timestamp = block.timestamp; // current block timestamp
          address sender = msg.sender; // address of the caller
     }
}

Primitive Data Types in Solidity

eluconsmidar — Wed, 08 May 2024 16:57:43 +0000

Here we introduce you to some primitive data types available in Solidity.

boolean
uint256
int256
address

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Primitives {
     bool public boo = true;

     /*
     uint stands for unsigned integer, meaning non negative integers 
     different sizes are availabe

     uint8 ranges from 0 to 2 ** 8 -1
     uint16 ranges from 0 to 2 ** 16 -1
     ...
     uint256 ranges from 0 to 2 ** 256 -1
     */

     uint8 public u8 = 1;
     uint256 public u256 = 456;
     uint256 public u = 123; // uint is an alias for uint256

     /*
     Negative numbers are allowed for int types.
     Like uint, different ranges are available from int8 to int256

     int256 ranges from -2 ** 255 to 2 ** 255 - 1
     int128 ranges from -2 ** 127 to 2 ** 127 - 1 
     */

     int8 public i8 = -1;
     int256 public i256 = 456;
     int256 public i = -123; // int is same as int256

     // minimum and maximum of int
     int256 public minInt = type(int256).min;
     int256 public maxInt = type(int256).max;

     address public addr = 0xCA35b7d915458EF540aDe6068dFe2F44E8fa733c;

     /*
     In Solidity, the data type byte represent a sequence of bytes.
     Solidity presents two type of bytes types:

     - fixed-sized byte arrays
     - dynamically-sized byte arrays

     The term bytes in Solidity represents a dynamic array of bytes.
     It's a shorthand for byte[].
     */

     bytes1 a = 0xb5;
     bytes1 b = 0x56;

     // Default values
     // Unassigned variables have a default value
     bool public defautlBoo; // false
     uint256 public defualtUint; // 0
     int256 public defaultInt; // 0
     address public defautlAddr; // 0x0000000000000000000000000000000000000000
}

Increment/Decrement in solidity smart contract

eluconsmidar — Wed, 08 May 2024 16:11:27 +0000

Here is a simple contract that you can get, increment and decrement the count store in this contract.

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Counter {
     uint256 public count;

     // Function to get the current count
     function get() public view returns (uint256) {
          return count;
     }

     // Function to increment count by 1
     function inc() public {
          count += 1;
     }

     // Function to decrement count by 1
     function dec() public {
          // This function will fail if count = 0
          count -= 1;
     }
}

Solidity "Hello World"

eluconsmidar — Wed, 08 May 2024 16:05:52 +0000

pragma specifies the compiler version of Solidity.

// SPDX-License-Identifier: MIT
// compiler version must be greater than or equal to 0.8.24 and less than 0.9.0
pragma solidity ^0.8.24;

contract HelloWorld {
     string public greet = "Hello World!";
}