is m right

https://github.com/klee/klee/blob/master/runtime/Intrinsic/klee_range.c Isn't it a mistake in line 23, giving the address of a local variable (x) to another function call (klee_make_symbolic)?

unless the functions runs in another thread, no. the lifetime of x does not end before klee_make_symbolic() uses it.

Given end points of n lines, design an algorithm and write a C++ code to find all the possible combination of lines which trick each other. A pt on a line is said to be an T_T point if that pt divides the lines in the ratio 2:1starting from the "start point" of the line.

Given end points of n lines, design an algorithm and write a C++ code to find all the possible combination of lines which trick each other. A pt on a line is said to be an T_T point if that pt divides the lines in the ratio 2:1starting from the "start point" of the line.

> which trick each other ??? > T_T point ??? why is the point crying

> which trick each other ??? > T_T point ??? why is the point crying

https://github.com/klee/klee/blob/master/runtime/Intrinsic/klee_range.c Isn't it a mistake in line 23, giving the address of a local variable (x) to another function call (klee_make_symbolic)?

I will steal that one from your teacher, it is a nice one

Depends on how the function klee_make_symbolic is defined even if it runs on the same thread. Unless we see the definition of klee_make_symbolic and any other functions that it calls with the pointer to x, we cant say anything.

Yeah, I tried finding its definition but did not find. Thank you

this is always O(n^2), right?

Not necessarily. It can be done in O(n lg n). But the OP has just shared the question without attempting it. Not sure if we can even offer suggestions.

https://github.com/klee/klee/blob/df04aeadefb4e1c34c7ef8b9123947ff045a34d9/tools/klee-replay/klee-replay.c#L459

this is always O(n^2), right?

O((n**2)/2) to be accurate

not sure how I can get it approved

no. M is right, https://www.geeksforgeeks.org/given-a-set-of-line-segments-find-if-any-two-segments-intersect/ just need to calculate the 2:1 part after determining the intersection point. also O(n^2) is the same as O(n^2 / 2)

not sure how I can get it approved

Who is admin of this group?

have the same question

have the same question

admins can change the "Admin" text on telegram. example - Dima's "Amogus enjoyer" and Rose's "UwU"

some one help me to tech c++

Hi

Could anyone here recommend a SVG generator/builder library?

I am not sure if it suits your case, but maybe you can try to use Qt: https://doc.qt.io/qt-5/qsvggenerator.html

Could anyone here recommend a SVG generator/builder library?

// CPP program to find length of the // longest prefix which is also suffix #include <bits/stdc++.h> using namespace std; // Function to find largest prefix // which is also a suffix int largest_prefix_suffix(const std::string &str) { int n = str.length(); // if n is less than 2 if(n < 2) { return 0; } int len = 0; int i = 1; // Iterate i till n while(i < n) { // If str[i] is equal to // str[len] if(str[i] == str[len]) { ++len; ++i; } else { i = i - len + 1;👈👈👈👈👈👈👈 len = 0; } } // Return len return len>n/2? len/2:len; } // Driver code int main() { string s = "blablabla"; // Function Call cout << largest_prefix_suffix(s); return 0; }

Is C language used in hacking

Guys some one tell me what is the significance of i=i-len+1 when the character s don't match

How will i-len +1 lead to that

Because when you are comparing two substring in this algorithm, at any point the invariant is that you would have compared len characters. The second substring previously started from position i which after len comparisons would now have the value <current value of i>-len. Now you want to restart the comparison again with suffix string starting position from the position next to this which is why you add 1.

After Len comparison won't I be I +len

No. I said the previous value of i I.e. the value at which i was when the comparsions restarted would be i-len Suppose say I is 3 and len is 0. Here you are assuming the suffix starts at position 3. Now suppose you compared 3 characters and all of them are equal. After this I would be 6 and len would be 3. Now suppose the next character doesnt match, then you should start with the suffix at position 4 which is current value of I I.e. 6 - 3 + 1

So shouldn't I just sent Len to 0 and let I stay there itself

No. Read my previous message. I have edited it now to explain with an example

And learn to use a debugger instead of asking questions like these. You would learn better and faster

At the third s...the characters won't match...

Here the suffix is then moved to 'a' at position 6 and the comparison is restarted. It wont match in the first character itself. Then the suffix moves to 'n' in position 7. It wont match. Then suffix is moved to character 's' at position 8. Here 4 characters in the prefix and suffix will match and this will be the value returned

Got a question. Why is indentation important? And how carefully does that complier pay attention to it?

Got a question. Why is indentation important? And how carefully does that complier pay attention to it?

Because when you are comparing two substring in this algorithm, at any point the invariant is that you would have compared len characters. The second substring previously started from position i which after len comparisons would now have the value <current value of i>-len. Now you want to restart the comparison again with suffix string starting position from the position next to this which is why you add 1.

Why should the second substring not start at the character that didn't match( after matching for some len...you said you'd get some mismatch then second substring should take position next to the previous starting point of second substring)

Ideally this is not the best way to do largest prefix suffix comparison. I was just explaining the algorithm that you provided. There are other much better algorithms which advance the suffix string to a much better position rather than to the next position as shown in the algorithm you provided. These algorithms are used for a large string like the entire text of a book for example or say a genome sequence.

Ideally this is not the best way to do largest prefix suffix comparison. I was just explaining the algorithm that you provided. There are other much better algorithms which advance the suffix string to a much better position rather than to the next position as shown in the algorithm you provided. These algorithms are used for a large string like the entire text of a book for example or say a genome sequence.

Yeah but why go back..I don't get the intuition..how could someone think of that

If i have an array and i want to fill this array by default value = 5 I made it like that.. ____________ array < int , 6 > arr ; arr.fill(5); —————————— Can i made it by another way !?

Do you know a good vector implementation that uses configurable "small buffer optimization"? E.g. if I know that in 99.5% cases my vector won't be larger than some value so I want to allocate a buffer of this size on the stack and only do heap allocations if it grows larger than this value.

afaik there is no std::vector that uses SBO because this would be against the C++ standard.