We should pass the size along with array to a function because when we are trying to find the size

of the array using sizeof we will

get total size of the array whether whole array is filled or not.

C++ STL:
Pair:

If we use ref variable and change the values then p.first value
Vector  dynamic size. Size depends on number of elements we added to it.
vector<int> v; v.size() =0
v.push_back(1); v.size() =1
 Copying one vector to another takes O(n) time complexity. So it’s better to pass reference of that vector
as arguments to functions instead of copies.
We can either use make_pair function or use brackets directly {}
Array of vectors:
 In Vectors it++ and it+1 gives the same output since vector has continuous memory allocation but in
maps and sets it+1 points to next location which may not necessarily where the next element is present.
and it++ points to the next iterator where the next element is present.

we can also use

 We can use two kinds of loops for vectors. Below value is copy of the vector elements not reference to
values in the vector . If we need reference we can use & operator

 In this case values in the vector gets

incremented

auto keyword
 Maps: Implemented using Red Black trees Keys are stored in sorted order

The insertion operation in map takes O(nlogn) time

Even though we did not assign value to m[6] just by declaring it inserts null to m[6]. m.find() operation also take O(nlogn) time.
m.erase(3) removes element with key =3

m.clear();  clears map

insertion operation also depends on size of the key

if string size is too long
Unordered Map(Implemented using Hash table): Keys are not in sorted order

Because of Internal Hash table implementation Insertion and access has O(1) complexity

m.erase()O (1)

Not all data types can be used a keys in unordered map unlike map because of its internal Hash table
implementation. Like Keys cannot be pair, vector, set etc...

Multimap allows duplicate keys.

Try to use Unordered maps if possible, when sorting is not required since takes less time.

Set: (No duplicated and sorted order implemented using red, black trees)

If value is removed from map then we get the set. Both Loops produces same output.
To delete an element, we use s.erase(it);
Unordered Set: (uses hash functions in internal implementation)

Multiset:
Duplicates are allowed
 deletes all occurrences.

Strings and Character Arrays:

Last Element in character array is null ‘\0’ same as in String

Anywhere null pointer is present it won’t be processed further

Reversing a string

std::string is a class in the C++ Standard Library that represents a sequence of characters and provides numerous member
functions for string manipulation.

 Memory Management:

 Character Array: Requires manual memory management if dynamically allocated.

 std::string: Handles memory management automatically.

 Size:

 Character Array: Fixed size; cannot be resized after declaration.

 std::string: Dynamic size; can be resized as needed.

https://github.com/loveBabbar/CodeHelp-DSA-Busted-Series/blob/main/Lecture022%20Strings/validPalindrome.cpp
cin Execution stops when “ “ or “\t” or “\n” is triggered

we can use cin.getline(pointer to char array ,len)

By default, getline uses the newline character ('\n') as the delimiter, but you can specify any character as the delimiter.

 cin.getline(str, SIZE, ';'); reads input into str up to a semicolon (;).

strcmp(s1,s2)  0 if equal
strcpy(dest,src)
CORE JAVA
Generics Watch Coding with John video
Primitive datatypes are stored in STACK itself. Objects are stored in heap
Everything that starts with a capital letter is called Class. String s=”Pavani”;
String s1=”Pavani”;
s==s1 gives true.
s1=”Reddy”; works but s1 is now pointing to Reddy object not “Pavani”; we did not change Pavani to Reddy here
Strings are immutable because in string pool two or more ref variables can point to the same object and if one of them
changes the object the value would be changed. This can be against security so they made strings immutable in java.

String pool: Separate Memory Structure inside heap so that similar strings do not have to be recreated again.
 When you only want to compare values then we can use .equals method .
a.equals(b)true
charAt(index)gives character.
System.out.println(56)o/p:56
System.out.println(“pavani”)o/p:pavani

If obj ==NULL it just

prints NULL

Now if we want to print an object for e.g an array

 this is
happening because of below toString function

So we use
we are telling java to use toString method in arrays . Now o/p would be [2,3,4,5] we did
function overriding here
 O/P: 56
56 even though we did not use
num.toString just using num also it prints 56 because it calls valueOf function which futher
calls toString
 we should use printf
here not println

printf rounds off the value

Pretty Printing uses printf
 o/p:- 195
ab

o/p- :d

o/p:100

o/p:- Kunal[]

o/p:- Kunal56

erro
r because + operator only works for primitive datatypes and if at least one of them is a
string
In Java operator overloading is not supported unlike in C++ and python.
Since Strings are immutable in java if we change the value then the ref variable points to
the new object. We can use String Builder to avoid creation of new object and can make
changes to old object.
StringBuilder

No new object will be created every time we

add a new character.
Note that name.toLowerCase() does not modify the original object.

o/p:-[Kunal, Kushwaha]