We can use any as per our convenience. ??

Is there any inbuilt Library function to Remove space in the string

You have in <cctype> the function std::isspace() Just iterate over the string and copy it, omitting all characters which return a non-zero value

Thanks for your response is there any other idealogy

Not in the standard library, I'm afraid. If you don't want to implement it, copy one off of Google.

Is there any inbuilt Library function to Remove space in the string

What's happening here? template<typename T, typename U> Is there some way the priority_queue class is implemented that it manages to pass the value type and container type data to comp? Otherwise how? If it's not too much, can you show an example by manually writing a class instead of priority_queue?

can one declare a string data type in c as: typedef char* string; ? Is there another way besides declaring an array of characters?

char* gives you the right impression that you are using a pointer to an array of chars.

how does one create a custom data type such as a string?

in C, since it's not object oriented, you would need to implement a struct which has a pointer to the char*, size and possibly more. functions to manipulate it like add/remove/modify characters, etc.

can you please give me an example 🙂🙂

I think it was clear enough

i mean in code

Yeah, why? I think it was clear enough.

If you really want abstraction, I am not sure why you don't hop over to c++

Just make something like what I said.

No. There is nothing in the priority_queue implementation that allows deducing of template arguments for comp. CTAD doesn't apply here. If you look at my code, I had specified that comp is a template class with the default template parameter being void. Then I specialise this class for void and make operator() inside it a template function instead of a regular function. This method has two template parameters T and U which are inferred by the compiler automatically when this method is called. In instantiating the priority_queue, I specify comp<> as the type which means that it uses comp<void> as the type because void is the default type. So it uses my specialization of comp for void as the concrete instance and uses its operator() for comparisons within the priority queue. The compiler will then infer T and U as int automatically.

I tried with only T for both a and b, and it seemed to work, so ig that's fine. But how are T and Q inferred by the compiler? The compiler automatically determines the type of data with which we call comp<>()? Also, why do we default the template parameter to void, as in <typename T=void>? Shouldn't <typename T> be enough, because when we specialize with, say char, we don't need to default T to char.

#include<stdio.h> void number(int n){ static int num=7; printf("num+n=%d",(num+n)); printf("\n"); num=num+2; } int main(){ number(5); number(5); return 0; } /*o/p: num+n=12 num+n=14*/

I specified T and U because that is what std::greater template does. Using two different template types allows more flexibility because that would allow you to compare an int with a float say. We default the template parameter to void because if we don't then the compiler would complain about us not having supplied a template argument when we specify comp<>. That is a non deduucing context and the compiler can't figure out which specific template argument to instantiate comp with. By specifying void as default, the compiler will use comp<void> specialization when we don't specify the template argument The compiler is able to deduce T and U because it is a function call and that is a deducible context. Looking at the priority_queue implementation, the compiler knows that operator() method inside comp will be called with 2 integers in your specific case and hence will be able to deduce T and U as both ints. This deduction can't happen for comp itself (when the default void parameter is not there) because that is what is called a non deducible context in the standard. So in that case we will have to specifically help the compiler and specify comp<int> instead. In the case where void is the default template parameter argument, the compiler always infers comp<> as comp<void>.

#include<stdio.h> void number(int n){ static int num=7; printf("num+n=%d",(num+n)); printf("\n"); num=num+2; } int main(){ number(5); number(5); return 0; } /*o/p: num+n=12 num+n=14*/

Help me to solve my problem

pls who can give me a guide to c++

suppose you have two sequences for positive integers A[1...n] and B[1...n]. You wish to find the heaviest common subsequence. The heaviest common subsequence between A and B is the subsequence that has the maximum sum of entries. For ex, if A = 2 2 4 8 5 and B = 2 8 4 5 6, then 2 8 5 is the heaviest weight subsequece of A and B. can someone help me solving this problem. I am unable to build the logic...?

What is the difference between %p and %u control strings for denoting address of a variable?

%p will print the address in hexadecimal format, and %u will print the address in decimal format...

problem in area function . the function is not returning the value of length * width , if i do cout« length * width it is working but if im doing return length * width it is not working , why ?? }

It seems area returns an int, but you don't save it anywhere

so what should I do next and how to save it , i cannot understood the meaning of save ?

int res = area(a,p);

did you mean create a variable and store the area and print the variable

There is not much advanced template magic here. Infact it is pretty simple. Since C++14, std::greater is defined like this: template< class T = void > struct greater; You can do something similar by providing a default template parameter argument for your comp struct. std::greater uses void as its default type and then specializes greater for void by defining operator() as a template function. You could do something similar as well like I have shown below: template <typename T=void> struct comp { bool operator()(const T& a, const T& b) { return a > b; } }; template<> struct comp<void> { template<typename T, typename U> bool operator()(T&& a, U&& b) { return a>b; } }; Now you can do something like: priority_queue<int, vector<int>, comp<>> q;

can someone help me in my code it's not taking my inputs

Is there a reason you used constant lvalue reference in the first operator function, but rvalue in the second?

#include <iostream> using namespace std; struct Employee{ string name; struct Employee *next; }; void insert (struct Employee** head, string employee_data){ struct Employee* newEmployee = new Employee; newEmployee-> name = employee_data; newEmployee-> next = (*head); (*head) = newEmployee; } void displaylist(struct Employee *employee){ while(employee != NULL){ cout << employee->name << endl; employee = employee ->next; } } int main() { struct Employee* head = NULL; int x; string name; cout << "How many Employee you want to add to the list: "; cin >> x; for(int i = 0; i<x; i++){ cin >> name; insert(&head,name); } cout << "Name of the Employee: " << endl; displaylist (head); return 0; }

..Why is the very hard to understand friend function ..🥲🥲