#include <iostream> int main() { int sum = 0, val = 1; while (val <= 10) { sum += val; val++; } std::cout << "Sum of 1 to 10 inclusively is " << sum << std::endl; return 0; }

Krishna loves Radha and wants to propose her in a different way. He wants to tell her the message, but he wanted the message to be a surprise. So, he plans to encrypt the message and send the encrypted message to Radha and he also gives the key to decrypt. He thinks that this might be a surprise to Radha. Help Radha to decrypt the message. Rules of encryption : 0<=key<=51 The original message only consists of a-z, A-Z, and space. Spaces are encrypted as '.' If key lies between 0 and 25, then the character is added with the key and modulo is taken and the case is maintained. For eg, if key is 3, then a is decrypted to d and e is decrypted to h. If key lies between 26 and 51, then the character is added with the key and modulo is taken and the case is inverted. For eg, if key is 29, then a is decrypted to D and E is decrypted to h. Input First line consists of t, the number of test cases. (1<=t<=20) For each test case, first line consists of key. 0<=key<=51 Second line consists of the encrypted message S. |S| <= 100000 Output For each test case, display the decrypted message in a separate line.

But if I write like this

#include <iostream> int main() { int sum = 0, val = 1; while (val <= 10) { Difference val++; Difference sum += val; } std::cout << "Sum of 1 to 10 inclusively is " << sum << std::endl; return 0; }

In first code you sum 1 + 2 + 3 .... And in second you sum 2 + 3 + 4 ....

Language: c Source: #include <stdio.h> int main() { char arr[3] = "hell"; puts(arr); } Warnings: 1015575703/source.c: In function ‘main’: 1015575703/source.c:4:19: warning: initializer-string for array of chars is too long char arr[3] = "hell"; ^~~~~~ Result: hel Note: gcc assumed, other valid options are clang, visual_c, you can be more specific next time.

why this warning? arr[3] means there's 4 index right? 0,1,2,3

no, only 3: 0,1,2 also "hell" probably needs zero char at the end ('\0') so it probably (not completely sure) needs 5 chars

whats that '\0' for?

It says that the string ends here

if , suppose char arr[] = "hell"; outputs hell I haven't given '\0' in it, how did it know it ends there ?

Does it output that though?

yes

Send source

if , suppose char arr[] = "hell"; outputs hell I haven't given '\0' in it, how did it know it ends there ?

as far as I know string literals (the thing you put into code inside two doublequotes) already have it https://ideone.com/BvfWuw

so it automatically puts '\0' at the end of the string?

As far as I know

where does it get the space to put that character in the string?

movl $1819043176, -12(%rbp) leaq -12(%rbp), %rax movq %rax, %rdi call puts@PLT

it allocates one more char when you ask it for char[], basically "hell" can use 5 chars to be stored (not sure if it always should) I've updated the code above to show how this '\0' affects the logic, note that sizeof(arr) is five

i don't see anywhere allocating 5 chars hm

#include <stdio.h> int main() { char arr[4] = "helloWorld"; puts(arr); printf("%d",sizeof(arr)); } OUTPUT : hell 4 when I put arr[4] is it allocating 5 spaces?

you've specified size of [4], if will use the size that you have specified and copy first 4 characters there

so if I put arr[4] = "hello"; is the index, 0 - h 1 - e 2 - l 3 - l or 0 - h 1 - e 2 - l 3 - l 4 - \0 ?

First variant

but sizeoff(arr) is 4, that fills the "hell" in "hello" so you did they put a "/0" in an already filled arr ?

but sizeoff(arr) is 4, that fills the "hell" in "hello" so you did they put a "/0" in an already filled arr ?

Here's how it looks, note that first time it prints two strings, it's because the strings are going one after another in memory (because they are in the same struct) and the first one lacking '\0' at the end https://ideone.com/InKWga

char arr[4] = {'h', 'e', 'l', 'l'}; char next[4] = {'A','A','A','A'}; puts(arr); klimi@14are05~/testing$ ./a.out hellAAAA

But I guess it's also not guaranteed that they will be in memory like this one after another, the example by the link above is more reliable :)

But I guess it's also not guaranteed that they will be in memory like this one after another, the example by the link above is more reliable :)

they should be next to each other

My task, I want to store floating points as a key in a map, but they can be slightly off and I want nearly equal values to be stored in the same node of the map like I want these two to give me the same value from the map: myMap[shorten(3.1415926)] and myMap[shorten(3.141592)] and I want to implement this shorten function for that

There is std::hash methods for floats and doubles. Why do you want to shorten them?

Maybe shorten isn't the best name of the function. I can have some values that are nearly equal, close enough that for my algorithms they are basically the same. But if I store them as key in the map, then they are checked for exact equality. I don't know how std::hash implemented, but I expected it to return the same hash (if no collisions) only for exactly equal floats, if it returns the same hash for nearly equal floats, then it is probably what I need.

Maybe something like this std::floorf(val * 1000) / 1000?

C++ question Do we have some way of rounding/flooring float with some amount of digits after zero (not necessary decimal digits)? Something better than two multiplications and round/floor (static_cast<float>(static_cast<int>(floatVal * 100))*0.01f), I'm thinking maybe we can directly zero some bits in mantissa depending on value of exponent, or maybe there's already some function for that?

What’s the point?

I descried it in the next messages

It’s just an extra overhead that you can rid of

what do you mean by overhead?

I mean things will not go faster because you rounded up

I don't want them to go faster, I need to use float as keys in maps (already written it twice with example above)

Here's how it looks, note that first time it prints two strings, it's because the strings are going one after another in memory (because they are in the same struct) and the first one lacking '\0' at the end https://ideone.com/InKWga

wait, so idk if my understanding is correct or not, but from observing that example code, so, suppose, char myCharArr[4] = "hello world"; when it is printed it shows "hell". now myCharArr[4] doesn't have a \0 and by default assuming that the char someGarbage[] = "\0"; then, memcpy(data.shortArr, myCharArr, sizeof(myCharArr)); memcpy(data.someGarbage, someGarbage, sizeof(someGarbage)); Now, this will make data.shortArr "hell\0" (memory is next to each other since they are in same struct) and finally when printing it was able to print "hell" Is my understanding correct? Anything wrong here? All of this based on your https://ideone.com/InKWga