^_^
int main(void) {
char last_initial;
printf("What is your name? : ");
string name = GetString();
printf("%c", name[0]);
for(int i= 0; i < strlen(name); i++){
if(name[i] == ' ') {
last_initial = name[i+1];
printf("%c", last_initial);
}
}
printf("\n");
}I'd use a flag for this: initial position set (for the first character), raise it on space, drop it on non-space (and print the non-space). This way, you cope with leading and trailing spaces, double spaces, and spare a printf. Adding support for - is straightforward (just the test to change)
bool isInitial = true;
for(int i=0; i<name.length(); ++i) {
if (name[i]==' ') {
isInitial = true;
} else if (isInitial) {
isInitial = false;
printf("%c", name[i]);
}
}
printf("\n"); bool isInitial = true;
for(auto ich=name.begin(); ich!=name.end(); ++ich) {
if (*ich==' ') {
isInitial = true;
} else if (isInitial) {
isInitial = false;
printf("%c", *ich);
}
}
printf("\n"); bool isInitial = true;
for(char& ch : name) {
if (ch==' ') {
isInitial = true;
} else if (isInitial) {
isInitial = false;
printf("%c", ch);
}
}
printf("\n"); bool f=true;
for(char& c:name)f=(c==' '?true:f?printf("%c",c),false:false);
printf("\n");
int main(void) {
char first[256] = {0};
char last[256] = {0};
printf("What is your name? : ");
string name = GetString();
sscanf(name, "%s %s", first, last);
printf("%c%c\n", first[0], last[0]);
}int main(void) {
char first[256] = {0};
char last[256] = {0};
printf("What is your name? : ");
scanf("%s %s", first, last);
printf("%c%c\n", first[0], last[0]);
}scanf("%255s %255s", first, last);return ((union { float v; uint32_t r; }){(int)x}.r+0x1fffff>>21) - 496;union u {
float v;
uint32_t r;
};
u foo {(int)x};
return (foo.r + 0x1fffff>>21) - 496;This sentnece doesn't make sense to me, because how can an environment variable be in HKLM? They're totally unrelated things.
C:\Users\Me>set TESTVAR
Environment variable TESTVAR not defined
C:\Users\Me>foo
C:\Users\Me>SET TESTVAR=FOO
C:\Users\Me>set TESTVAR
TESTVAR=FOOC:\> SET TESTVAR=FOO
C:\> SET TESTVAR
FOOOh goodness, I'm sorry; I responded too quickly. Yep meant "my output does match that." I got the same result as you.
I'm only half awake and on a phone waiting for a late train, but is't it just a way to ceil the value before taking the log?
I'm pretty sure it's not just that.
I'm not convinced. We would need to know why these specific values are chosen first. It's obviously a hash of some sort (computing a bucket index) so there must be a reason why these values are desirable and some logical derivation.
Mostly i was posting it to illustrate the concept of casting an int to a float and then extracting the fields of the IEEE floating point representation, because I imagine many people never thought of that.
This is also a good illustration of why you should comment code
I'm not convinced. We would need to know why these specific values are chosen first. It's obviously a hash of some sort (computing a bucket index) so there must be a reason why these values are desirable and some logical derivation.
Mostly i was posting it to illustrate the concept of casting an int to a float and then extracting the fields of the IEEE floating point representation, because I imagine many people never thought of that.
This is also a good illustration of why you should comment code
It's part of the code from some implementation of malloc. x is size_t type.
foo.r>>23 is foo.v >> 23, which is IEEE 754 single-precision binary floating-point, https://en.wikipedia.org/wiki/Singl...cision_binary_floating-point_format:_binary32
The question is why >>21, +01ffff, -496 at the end, but I think that's implementation specific, i.e., I have no idea.
A hash or a way t choose which chunk of memory you'll use depending on the data size? Usually, there's plently of small chunks, a bit less larger ones, and so on, the size of the chunks being usually something like 2^(3k) and the number of each size inverse proportionnal to the size.
I must have spend far too much time doing low-level awfully crude things ^_^
I suspect many of memory management pieces of code are directly linked to a paper on the matter. I wouldn't be surprised that the expression is explained somewhere, although it would have been easier if they had provided a link inside the code. Link can be broken, but I'm sometimes reluctant to detail all subtilities inside the code source. I just ship the code with documentation alongside it.This is also a good illustration of why you should comment code
I've thrown a glance at the source, and I'd say I can live with a strange formula if I at least know what the function is doing...
That convinced me even more than it's a ceil (while bin_index truncates the value)
union u {
float v;
uint32_t r;
};u foo {(int)x};return (foo.r + 0x1fffff>>21) - 496;foo.rclass Foo
{
public int bar;
public int upham;
}
Foo testobj = new Foo();
testobj.bar = 1;
testobj.upham = 2;class Foo
{
private int bar;
private int upham;
public int getBar()
{
return bar;
}
public void setBar(int newbar)
{
bar = newbar;
}
public int getUpham()
{
return upham;
}
public void setUpham(int newupham)
{
upham= newupham;
}
}
Foo testobj = new Foo();
testobj.setBar(1);
testobj.setUpham(2);
System.out.println(testobj.getBar());
System.out.println(testobj.getUpham());Easiest and best won't go well together...
Easiest and best won't go well together...
Result = rand() % 6;
Should fit most needs if you want an easy solution, but not all values have exactly the same probability, although in the worst case it's less than 0.0031% difference, and usually it's far far less than that.
Don't forget to seed with a
srand(time(NULL))
at the beginning of the code.
There's better random functions in recent C versions, like C++X11 but you may not need them.
And I won't relaunch the interesting debate on randomness