On 11 Jun 2024 18:23:28 GMT, rbowman wrote:

> ... I've hit instances using functions
> in legacy code where one const in a function resulted in having to
> spread const around to keep the compiler from whining.

Dennis Ritchie himself pointed out some pitfalls with the “const” concept
early on. For example, take this standard library routine:

char *strstr(const char *haystack, const char *needle);

Note that the result is a (non-const) pointer into one of the arguments.
But the arguments are const! So the function is not typesafe. It was done
this way so that, if the user passed a pointer into a modifiable string,
they could get back a pointer they could use to make further
modifications.

The right solution would have been to create two versions of this routine,
one with a non-const haystack pointer returning non-const, and another
with a const haystack pointer, returning const.

On 11 Jun 2024 18:33:13 GMT, rbowman wrote:

> On Tue, 11 Jun 2024 12:20:05 -0400, DFS wrote:
>
>> Usually qsort().
>
> Enter Big O...

The “Timsort” algorithm is generally seen to be a significant advance on
Quicksort. It was invented by one of the Python developers.

On Tue, 11 Jun 2024 12:05:38 -0400, Joel wrote:

> Nice, I bet you will excel in it.

My word, but you make a powerful point.

Lawrence D'Oliveiro <ldo@nz.invalid> wrote:

>> Nice, I bet you will excel in it.
>
>My word, but you make a powerful point.

I'm a fan of candycanearter07, he's a wonderful contributor, I dare
say the most valued one we have, being younger than most of us. He's
our future, the future of Linux.

--
Joel W. Crump

Amendment XIV
Section 1.

[...] No state shall make or enforce any law which shall
abridge the privileges or immunities of citizens of the
United States; nor shall any state deprive any person of
life, liberty, or property, without due process of law;
nor deny to any person within its jurisdiction the equal
protection of the laws.

Dobbs rewrites this, it is invalid precedent. States are
liable for denying needed abortions, e.g. TX.

On Tue, 11 Jun 2024 23:15:11 -0400, Joel wrote:

> Lawrence D'Oliveiro <ldo@nz.invalid> wrote:
>
>>> Nice, I bet you will excel in it.
>>
>> My word, but you make a powerful point.
>
> I'm a fan of candycanearter07 ...

Maybe my humour was not quite as ... Access-ible ... as it could have
been ...

Lawrence D'Oliveiro <ldo@nz.invalid> wrote:

>>>> Nice, I bet you will excel in it.
>>>
>>> My word, but you make a powerful point.
>>
>> I'm a fan of candycanearter07 ...
>
>Maybe my humour was not quite as ... Access-ible ... as it could have
>been ...

Ah, yeah. M$ Office.

--
Joel W. Crump

Amendment XIV
Section 1.

[...] No state shall make or enforce any law which shall
abridge the privileges or immunities of citizens of the
United States; nor shall any state deprive any person of
life, liberty, or property, without due process of law;
nor deny to any person within its jurisdiction the equal
protection of the laws.

Dobbs rewrites this, it is invalid precedent. States are
liable for denying needed abortions, e.g. TX.

Lawrence D'Oliveiro <ldo@nz.invalid> wrote at 02:43 this Wednesday (GMT):
> On 11 Jun 2024 18:23:28 GMT, rbowman wrote:
>
>> ... I've hit instances using functions
>> in legacy code where one const in a function resulted in having to
>> spread const around to keep the compiler from whining.
>
> Dennis Ritchie himself pointed out some pitfalls with the “const” concept
> early on. For example, take this standard library routine:
>
> char *strstr(const char *haystack, const char *needle);
>
> Note that the result is a (non-const) pointer into one of the arguments.
> But the arguments are const! So the function is not typesafe. It was done
> this way so that, if the user passed a pointer into a modifiable string,
> they could get back a pointer they could use to make further
> modifications.
>
> The right solution would have been to create two versions of this routine,
> one with a non-const haystack pointer returning non-const, and another
> with a const haystack pointer, returning const.

I guess that's why function overloading was introduced in C++. Of
course, that's a whole other can o worms.
--
user <candycane> is generated from /dev/urandom

DFS <nospam@dfs.com> wrote at 16:20 this Tuesday (GMT):
> On 6/10/2024 10:40 PM, candycanearter07 wrote:
>> DFS <nospam@dfs.com> wrote at 23:30 this Saturday (GMT):
>>> On 6/8/2024 5:32 PM, Joel wrote:
>>>
>>>> I can't imagine I'd need anything beyond C.
>>>
>>>
>>> I hope you're not gonna pull a Feeb and claim you're a C guru that can
>>> 'move the Earth', but refuse to show ANY decent code, then make lame
>>> excuses like "I have other fish to fry".
>>
>> Seems like a fun challenge.. especially since im kinda rusty with c
>>
>>> 1) write your own C to sort these 3 names (by last then first):
>>>
>>> William Thomas
>>> Zachary Jones
>>> Jim Thomas
>>
>> I'll be honest, I might be bad but I completely forgot how to sort
>> strings.. sorry
>
>
> Usually qsort().
>
I knew there was an official implementation!
>
>>> 2) write your own C to count the words in:
>>>
>>> "Now is the time for all good men to come to the aid of their country."
>>
>> #include <stdio.h>
>> #include <ctype.h>
>>
>> const char phrase[] = "Now is the time for all good men to come to the
>> aid of their country.";
>>
>> int main()
>> {
>> const char *phr = phrase;
>> int words = 0;
>> int space = 0; // does c have bool?
>
> Yes.
>
>> while(*phr)
>> {
>> if(space && isalpha(*phr))
>> {
>> space = 0;
>> words++;
>> }
>> if(isblank(*phr)) space = 1;
>>
>> phr++;
>> }
>>
>> printf("Words: %d, words);
>> }
>
>
> My wordcounter code used:
>
> if(isspace(myStr[i]) && !isspace(myStr[i+1])) {countWords++;}
>
> to also count words that might begin with numbers.
>
> "For the right money cola Linux 'advocates' would work 4MS in 2ms."
>
Right, I forgot isalnum was a thing.
>
>
>>> 3) write your own C to calc the mean, median and mode of:
>>>
>>> 1,2,3,4,5,5,6,7,8,9
>>
>> #include <stdio.h>
>> #define COUNT_CNT 10
>>
>> int nums[] = {1, 2, 3, 4, 5, 5, 6, 7, 8, 9, -1};
>>
>> int main()
>> {
>> double mean;
>> int median, mode, md_count[COUNT_CNT], len;
>>
>> for( len = 0; nums[len] != -1; len++ )
>> {
>> mean += nums[len];
>> md_count[nums[len]]++;
>> }
>> mean /= len;
>>
>> if(len % 2 == 0)
>> {
>> int mid = len / 2;
>> median = nums[mid] + nums[mid + 1]];
>> median /= 2;
>> }
>> else
>> median = nums[len / 2];
>>
>> for( int i = 0; i < COUNT_CNT; i++ )
>> {
>> if(md_count[mode] < md_count[i]) mode = i;
>> }
>>
>> printf("mean %g, median %d, mode %d", mean, median, mode);
>> }
>>
>> These compiled fine on my machine (gcc 12.2.0)
>
>
> Did you actually run the code?

Yes, but I also typed it into slrn by hand bc I was worried that pasting
it would mess up word wrapping

> I got a segfault (WSL Ubuntu, gcc 11.4). Had to make a few tweaks to
> get it to run and provide correct answers.
>
> Do you want me to tell you what I did, or do you want to figure it out?
>
> Hint: after the line "mean /= len;" print out the contents of
> md_count[]. You should get:
>
> 1. 1
> 2. 1
> 3. 1
> 4. 1
> 5. 2
> 6. 1
> 7. 1
> 8. 1
> 9. 1

I don't see it sorry ^^:

> I like the technique you use for the mode count, but something to
> remember is there can be multiple modes, and your code as is will
> identify only one.
>
> And the numbers were already sorted, but if they weren't you would have
> to sort them - forward or reverse - before getting the median.

Thanks, I'll keep it in mind next time

>
>>> Why is it I have a VERY strong feeling you and Feeb and C are about to
>>> be pwned by python?
>>
>>
>> IMO, both are pretty good languages, with their own strengths..like, C
>> is good for dealing with the raw data and it can be really satisfying to
>> get everything working, and python is great for throwing something
>> together.
>
>
> I like them both, too. But C is too time-consuming for me. I just
> don't spend enough time using it exclusively to be productive vs python.

Yeah, it can be frustrating sometimes (like how arrays don't really
exist and you have to be /very careful/ around them)

> Another language I've had my eye on is Julia.

Oh, never heard of it.
--
user <candycane> is generated from /dev/urandom

Joel <joelcrump@gmail.com> wrote at 16:05 this Tuesday (GMT):
> candycanearter07 <candycanearter07@candycanearter07.nomail.afraid>
> wrote:
>
>>> I majored in comp sci, I have used a number of languages, even
>>> multiple platforms of assembly, just not in a long time. I've done
>>> amazing things with mIRC script's language. It's not a hard thing for
>>> me to pick up the process of coding, it *is* hard to think of an
>>> original idea for something to code, though.
>>
>>Oh, awesome. I'm about to start comp sci myself ^^
>
>
> Nice, I bet you will excel in it.

Thanks.
--
user <candycane> is generated from /dev/urandom

Joel <joelcrump@gmail.com> wrote at 03:15 this Wednesday (GMT):
> Lawrence D'Oliveiro <ldo@nz.invalid> wrote:
>
>>> Nice, I bet you will excel in it.
>>
>>My word, but you make a powerful point.
>
>
> I'm a fan of candycanearter07, he's a wonderful contributor, I dare
> say the most valued one we have, being younger than most of us. He's
> our future, the future of Linux.

:D thx!
--
user <candycane> is generated from /dev/urandom

Chris Ahlstrom <OFeem1987@teleworm.us> wrote at 12:17 this Tuesday (GMT):
> candycanearter07 wrote this copyrighted missive and expects royalties:
>
>> Tyrone <none@none.none> wrote at 02:32 this Sunday (GMT):
>>
>> <brevsnip>
>>
>> A lot of times, programming involves connecting "trivial problems in an
>> advanced way". Sorting a list of names would be needed for a dropdown,
>> letter or word counts are usually used to limit how much text a user can
>> input, and averages are useful for any kind of data summary. While
>> they're not /everything/ in programming, knowing the basics (or being
>> able to figure it out easily) can definitely help you out. They're also
>> fun to figure out in my opinion.
>>
>> [snip]
>>> In the real world, very few problems have "already been coded". Which is why
>>> people who proclaim that "AI" is going to make programmers "obsolete" have no
>>> GD clue what they are talking about.
>>
>> Yeah, AI is very very annoying and not a good replacement for coders.
>
> But here is another take:
>
> https://www.newyorker.com/magazine/2023/11/20/a-coder-considers-the-waning-days-of-the-craft
>
> There will also be a need for coders, though. Cannot completely trust what AI
> mines from the internet.

Well, yeah. Google tried that and everyone is rightfully laughing at
them for it.
--
user <candycane> is generated from /dev/urandom

On Wed, 12 Jun 2024 06:35:02 -0000 (UTC), candycanearter07 wrote:

> DFS <nospam@dfs.com> wrote at 16:20 this Tuesday (GMT):
>>
>> Usually qsort().
>>
> I knew there was an official implementation!

Just a note that Quicksort is quite bad on nearly-sorted lists.

A very simple, easy-to-implement sorting algorithm, that works
surprisingly well in a wide range of situations, is Shellsort.

candycanearter07 wrote:

> Joel wrote:
>>
>> I majored in comp sci, I have used a number of languages, even
>> multiple platforms of assembly, just not in a long time. I've done
>> amazing things with mIRC script's language. It's not a hard thing for
>> me to pick up the process of coding, it *is* hard to think of an
>> original idea for something to code, though.
>
> Oh, awesome. I'm about to start comp sci myself ^^

Way back when, I thought that I would major in CSci. I switched to EE
as I thought it a more versatile degree.

--
'Too bad Mr "BSEE" has tried to BS us about his alleged credentials in
the past.' -highhorse, lying shamelessly

Lawrence D'Oliveiro wrote this copyrighted missive and expects royalties:

> On Tue, 11 Jun 2024 23:15:11 -0400, Joel wrote:
>
>> Lawrence D'Oliveiro <ldo@nz.invalid> wrote:
>>
>>>> Nice, I bet you will excel in it.
>>>
>>> My word, but you make a powerful point.
>>
>> I'm a fan of candycanearter07 ...
>
> Maybe my humour was not quite as ... Access-ible ... as it could have
> been ...

It's a problem with your visio-n.

--
A tall, dark stranger will have more fun than you.

On 6/12/2024 1:59 AM, Lawrence D'Oliveiro wrote:
> On Tue, 11 Jun 2024 23:15:11 -0400, Joel wrote:
>
>> Lawrence D'Oliveiro <ldo@nz.invalid> wrote:
>>
>>>> Nice, I bet you will excel in it.
>>>
>>> My word, but you make a powerful point.
>>
>> I'm a fan of candycanearter07 ...
>
> Maybe my humour was not quite as ... Access-ible ... as it could have
> been ...

Word.

On 6/12/2024 2:35 AM, candycanearter07 wrote:
> DFS <nospam@dfs.com> wrote at 16:20 this Tuesday (GMT):

>>>> 3) write your own C to calc the mean, median and mode of:
>>>>
>>>> 1,2,3,4,5,5,6,7,8,9
>>>
>>> #include <stdio.h>
>>> #define COUNT_CNT 10
>>>
>>> int nums[] = {1, 2, 3, 4, 5, 5, 6, 7, 8, 9, -1};
>>>
>>> int main()
>>> {
>>> double mean;
>>> int median, mode, md_count[COUNT_CNT], len;
>>>
>>> for( len = 0; nums[len] != -1; len++ )
>>> {
>>> mean += nums[len];
>>> md_count[nums[len]]++;
>>> }
>>> mean /= len;
>>>
>>> if(len % 2 == 0)
>>> {
>>> int mid = len / 2;
>>> median = nums[mid] + nums[mid + 1]];
>>> median /= 2;
>>> }
>>> else
>>> median = nums[len / 2];
>>>
>>> for( int i = 0; i < COUNT_CNT; i++ )
>>> {
>>> if(md_count[mode] < md_count[i]) mode = i;
>>> }
>>>
>>> printf("mean %g, median %d, mode %d", mean, median, mode);
>>> }
>>>
>>> These compiled fine on my machine (gcc 12.2.0)
>>
>>
>> Did you actually run the code?
>
> Yes, but I also typed it into slrn by hand bc I was worried that pasting
> it would mess up word wrapping
>
>> I got a segfault (WSL Ubuntu, gcc 11.4). Had to make a few tweaks to
>> get it to run and provide correct answers.
>>
>> Do you want me to tell you what I did, or do you want to figure it out?
>>
>> Hint: after the line "mean /= len;" print out the contents of
>> md_count[]. You should get:
>>
>> 1. 1
>> 2. 1
>> 3. 1
>> 4. 1
>> 5. 2
>> 6. 1
>> 7. 1
>> 8. 1
>> 9. 1
>
> I don't see it sorry ^^:

You don't see what?

DFS <nospam@dfs.com> wrote at 13:15 this Wednesday (GMT):
> On 6/12/2024 2:35 AM, candycanearter07 wrote:
>> DFS <nospam@dfs.com> wrote at 16:20 this Tuesday (GMT):
>
>
>>>>> 3) write your own C to calc the mean, median and mode of:
>>>>>
>>>>> 1,2,3,4,5,5,6,7,8,9
>>>>
>>>> #include <stdio.h>
>>>> #define COUNT_CNT 10
>>>>
>>>> int nums[] = {1, 2, 3, 4, 5, 5, 6, 7, 8, 9, -1};
>>>>
>>>> int main()
>>>> {
>>>> double mean;
>>>> int median, mode, md_count[COUNT_CNT], len;
>>>>
>>>> for( len = 0; nums[len] != -1; len++ )
>>>> {
>>>> mean += nums[len];
>>>> md_count[nums[len]]++;
>>>> }
>>>> mean /= len;
>>>>
>>>> if(len % 2 == 0)
>>>> {
>>>> int mid = len / 2;
>>>> median = nums[mid] + nums[mid + 1]];
>>>> median /= 2;
>>>> }
>>>> else
>>>> median = nums[len / 2];
>>>>
>>>> for( int i = 0; i < COUNT_CNT; i++ )
>>>> {
>>>> if(md_count[mode] < md_count[i]) mode = i;
>>>> }
>>>>
>>>> printf("mean %g, median %d, mode %d", mean, median, mode);
>>>> }
>>>>
>>>> These compiled fine on my machine (gcc 12.2.0)
>>>
>>>
>>> Did you actually run the code?
>>
>> Yes, but I also typed it into slrn by hand bc I was worried that pasting
>> it would mess up word wrapping
>>
>>> I got a segfault (WSL Ubuntu, gcc 11.4). Had to make a few tweaks to
>>> get it to run and provide correct answers.
>>>
>>> Do you want me to tell you what I did, or do you want to figure it out?
>>>
>>> Hint: after the line "mean /= len;" print out the contents of
>>> md_count[]. You should get:
>>>
>>> 1. 1
>>> 2. 1
>>> 3. 1
>>> 4. 1
>>> 5. 2
>>> 6. 1
>>> 7. 1
>>> 8. 1
>>> 9. 1
>>
>> I don't see it sorry ^^:
>
>
> You don't see what?

The mistake I made.
--
user <candycane> is generated from /dev/urandom

Lawrence D'Oliveiro <ldo@nz.invalid> wrote at 07:22 this Wednesday (GMT):
> On Wed, 12 Jun 2024 06:35:02 -0000 (UTC), candycanearter07 wrote:
>
>> DFS <nospam@dfs.com> wrote at 16:20 this Tuesday (GMT):
>>>
>>> Usually qsort().
>>>
>> I knew there was an official implementation!
>
> Just a note that Quicksort is quite bad on nearly-sorted lists.
>
> A very simple, easy-to-implement sorting algorithm, that works
> surprisingly well in a wide range of situations, is Shellsort.

I'll note it down.
--
user <candycane> is generated from /dev/urandom

On 6/13/2024 2:05 AM, candycanearter07 wrote:
> DFS <nospam@dfs.com> wrote at 13:15 this Wednesday (GMT):
>> On 6/12/2024 2:35 AM, candycanearter07 wrote:
>>> DFS <nospam@dfs.com> wrote at 16:20 this Tuesday (GMT):
>>
>>
>>>>>> 3) write your own C to calc the mean, median and mode of:
>>>>>>
>>>>>> 1,2,3,4,5,5,6,7,8,9
>>>>>
>>>>> #include <stdio.h>
>>>>> #define COUNT_CNT 10
>>>>>
>>>>> int nums[] = {1, 2, 3, 4, 5, 5, 6, 7, 8, 9, -1};
>>>>>
>>>>> int main()
>>>>> {
>>>>> double mean;
>>>>> int median, mode, md_count[COUNT_CNT], len;
>>>>>
>>>>> for( len = 0; nums[len] != -1; len++ )
>>>>> {
>>>>> mean += nums[len];
>>>>> md_count[nums[len]]++;
>>>>> }
>>>>> mean /= len;
>>>>>
>>>>> if(len % 2 == 0)
>>>>> {
>>>>> int mid = len / 2;
>>>>> median = nums[mid] + nums[mid + 1]];
>>>>> median /= 2;
>>>>> }
>>>>> else
>>>>> median = nums[len / 2];
>>>>>
>>>>> for( int i = 0; i < COUNT_CNT; i++ )
>>>>> {
>>>>> if(md_count[mode] < md_count[i]) mode = i;
>>>>> }
>>>>>
>>>>> printf("mean %g, median %d, mode %d", mean, median, mode);
>>>>> }
>>>>>
>>>>> These compiled fine on my machine (gcc 12.2.0)
>>>>
>>>>
>>>> Did you actually run the code?
>>>
>>> Yes, but I also typed it into slrn by hand bc I was worried that pasting
>>> it would mess up word wrapping
>>>
>>>> I got a segfault (WSL Ubuntu, gcc 11.4). Had to make a few tweaks to
>>>> get it to run and provide correct answers.
>>>>
>>>> Do you want me to tell you what I did, or do you want to figure it out?
>>>>
>>>> Hint: after the line "mean /= len;" print out the contents of
>>>> md_count[]. You should get:
>>>>
>>>> 1. 1
>>>> 2. 1
>>>> 3. 1
>>>> 4. 1
>>>> 5. 2
>>>> 6. 1
>>>> 7. 1
>>>> 8. 1
>>>> 9. 1
>>>
>>> I don't see it sorry ^^:
>>
>>
>> You don't see what?
>
>
> The mistake I made.

Did you print the contents of md_count[] ? That should give you a clue.

The code you posted shouldn't have run. What answers did it give you?

On Thu, 13 Jun 2024 10:59:51 -0400, DFS wrote:

> Did you print the contents of md_count[] ? That should give you a clue.

Or print mode. Maybe you got lucky.

$ gcc -Wall -o mean mean.c
$

$ clang -Wall -o mean mean.c
mean.c:13:4: warning: variable 'mean' is uninitialized when used here [-
Wuninitialized]
mean += nums[len];
^~~~
mean.c:8:14: note: initialize the variable 'mean' to silence this warning
double mean;
^
= 0.0
1 warning generated.

Where this gets interesting is adding

printf("mode %d\n", mode);
for( int i = 0; i < COUNT_CNT; i++ )
.....

$ gcc -Wall -o mean mean.c
mean.c: In function ‘main’:
mean.c:27:9: warning: ‘mode’ is used uninitialized [-Wuninitialized]
27 | printf("mode %d\n", mode);
| ^~~~~~~~~~~~~~~~~~~~~~~~~

$ ./mean
mode -678188295
Segmentation fault (core dumped)

$ clang -Wall -o mean mean.c
mean.c:27:29: warning: variable 'mode' is uninitialized when used here [-
Wuninitialized]
printf("mode %d\n", mode);
^~~~
mean.c:9:19: note: initialize the variable 'mode' to silence this warning
int median, mode, md_count[COUNT_CNT], len;
^
= 0
1 warning generated.

$ ./mean
mode 100
mean 5, median 5, mode 6

Not quite out of the woods... Adding

int median, md_count[COUNT_CNT], len;
int mode = 0;
.....

$ clang -Wall -o mean mean.c
$ ./mean
mean 5, median 5, mode 0

$ gcc -Wall -o mean mean.c
mean 5, median 5, mode 2

So what else might be uninitialized?

I'm a little disappointed in both compilers.

On 6/13/2024 1:30 PM, rbowman wrote:
> On Thu, 13 Jun 2024 10:59:51 -0400, DFS wrote:
>
>> Did you print the contents of md_count[] ? That should give you a clue.
>
> Or print mode. Maybe you got lucky.

You mean I got lucky with:

1. 1
2. 1
3. 1
4. 1
5. 2
6. 1
7. 1
8. 1
9. 1

?

Not luck. It didn't look like that at first. I got there only after
making various fixes.

With his 3-word responses and 2-day delay, candycane doesn't seem too
interested in his program. The fixes I made are below.

> $ gcc -Wall -o mean mean.c
> $

It compiled for me too (after fixing the typo). But it segfaulted at
runtime.

> $ clang -Wall -o mean mean.c
> mean.c:13:4: warning: variable 'mean' is uninitialized when used here [-
> Wuninitialized]
> mean += nums[len];
> ^~~~
> mean.c:8:14: note: initialize the variable 'mean' to silence this warning
> double mean;
> ^
> = 0.0
> 1 warning generated.

C did something REALLY strange recently because I didn't initialize a
char[] variable. It was a stats program (see at bottom), and it worked
well until I tested a dataset of consecutive numbers. Up to 40 it was
fine, but it flagged as outliers every number above 40, but only if the
dataset was consecutive numbers. None of them were actually outliers,
as defined by the formula I used.

No matter the code changes, file saves, compiles, etc it kept flagging
40+ as outliers. Until I initialized the variable with ="". Then it
worked right.

> Where this gets interesting is adding
>
> printf("mode %d\n", mode);
> for( int i = 0; i < COUNT_CNT; i++ )
> .....
>
>
> $ gcc -Wall -o mean mean.c
> mean.c: In function ‘main’:
> mean.c:27:9: warning: ‘mode’ is used uninitialized [-Wuninitialized]
> 27 | printf("mode %d\n", mode);
> | ^~~~~~~~~~~~~~~~~~~~~~~~~

That's a good thing.

> $ ./mean
> mode -678188295
> Segmentation fault (core dumped)

There it is.

> $ clang -Wall -o mean mean.c
> mean.c:27:29: warning: variable 'mode' is uninitialized when used here [-
> Wuninitialized]
> printf("mode %d\n", mode);
> ^~~~
> mean.c:9:19: note: initialize the variable 'mode' to silence this warning
> int median, mode, md_count[COUNT_CNT], len;
> ^
> = 0
> 1 warning generated.
> $ ./mean
> mode 100
> mean 5, median 5, mode 6
>
> Not quite out of the woods... Adding
>
> int median, md_count[COUNT_CNT], len;
> int mode = 0;
> .....
>
> $ clang -Wall -o mean mean.c
> $ ./mean
> mean 5, median 5, mode 0

The mode is incorrect.

> $ gcc -Wall -o mean mean.c
> mean 5, median 5, mode 2

That mode is also incorrect. There does happen to be 2 instances of the
mode, but the mode isn't 2.

> So what else might be uninitialized?
>
>
> I'm a little disappointed in both compilers.
I learned yesterday about a gcc option:
-fsanitize=undefined
that might help you.

I made a few fixes to candy cane's code:

- fix typo with two closing brackets ]]
- add stdlib.h include
- set mean, median, mode and len to 0 beforehand
- malloc the md_count[] array to size 9 (because there
are only 9 unique values in the size 10 dataset)
- add return 0

============================================================
#include <stdio.h>
#include <stdlib.h>

#define COUNT_CNT 10

int nums[] = {1,2,3,4,5,5,6,7,8,9,-1};

int main()
{ double mean = 0.0;
int median = 0, mode = 0, len = 0;
int *md_count = malloc((COUNT_CNT-1) * sizeof(int));
//calc mean and count mode
for( len = 0; nums[len] != -1; len++ )
{
mean += nums[len];
md_count[nums[len]]++;
}
mean /= len;
//temp to see contents of md_count[]
// for( int i = 1; i < COUNT_CNT; i++ )
// {
// printf("%d. %d\n",i,md_count[i]);
// }

//median
if(len % 2 == 0)
{
int mid = len / 2;
median = nums[mid] + nums[mid + 1];
median /= 2;
}
else
{
median = nums[len / 2];
}
//mode
for( int i = 0; i < COUNT_CNT; i++ )
{
if(md_count[mode] < md_count[i])
{
mode = i;
}
}
printf("mean %g, median %d, mode %d\n", mean, median, mode);
free(md_count);
return 0;
}

============================================================

$ gcc -Wall mmm_fixed.c -o mmm_fixed
$ ./mmm_fixed
mean 5, median 5, mode 5

And 5 IS the correct mode.

Here's something you might enjoy playing with:

============================================================

//this code is hereby released to the public domain

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <time.h>

/*
this program computes the descriptive statistics of sets of integers

1.0 release Dec 2020
2.0 release Jun 2024

used the population skewness and Kurtosis formulas from:

https://www.calculatorsoup.com/calculators/statistics/descriptivestatistics.php
also test the results of this code against that site

compile:
$ gcc -Wall -Wextra -O2 prog.c -o prog -lm
or
$ gcc -Wall -Wextra -O2 -fsanitize=undefined prog.c -o prog
-lm
usage : ./prog N -option (where N is 2 or higher, and option is -r or
-c or -o)
-r generates N random numbers
-c generates consecutive numbers 1 to N
-o generates random numbers with outliers
*/

//random ints
int randNbr(int low, int high) {
return (low + rand() / (RAND_MAX / (high - low + 1) + 1));
}

//comparator function used with qsort
int compareint (const void * a, const void * b)
{ if (*(int*)a > *(int*)b) return 1;
else if (*(int*)a < *(int*)b) return -1;
else return 0;
}

int main(int argc, char *argv[])
{ if(argc < 3) {
printf("Missing argument:\n");
printf(" * enter a number greater than 2\n");
printf(" * enter an option -r -c or -o\n");
exit(0);
}

//vars
int i=0;
int N = atoi(argv[1]);
int *nums = malloc(N * sizeof(int));
double sumN=0.0, median=0.0, Q1=0.0, Q2=0.0, Q3=0.0, IQR=0.0;
double stddev = 0.0, kurtosis = 0.0;
double sqrdiffmean = 0.0, cubediffmean = 0.0, quaddiffmean = 0.0;
double meanabsdev = 0.0, rootmeansqr = 0.0;

//generate random dataset
if(strcmp(argv[2],"-r") == 0) {
srand(time(NULL));
for(i=0;i<N;i++) { nums[i] = randNbr(1,N*3); }

printf("%d Randoms:\n", N);
printf("No commas : "); for(i=0;i<N;i++) { printf("%d ", nums[i]); }
printf("\nWith commas: "); for(i=0;i<N;i++) { printf("%d,", nums[i]); }
qsort(nums,N,sizeof(int),compareint);
printf("\nSorted : "); for(i=0;i<N;i++) { printf("%d ", nums[i]); }
printf("\nSorted : "); for(i=0;i<N;i++) { printf("%d,", nums[i]); }
}
//generate random dataset with outliers
if(strcmp(argv[2],"-o") == 0) {
srand(time(NULL));
nums[0] = 1; nums[1] = 3;
for(i=2;i<N-2;i++) { nums[i] = randNbr(100,N*30); }
nums[N-2] = 1000; nums[N-1] = 2000;

printf("%d Randoms with outliers:\n", N);
printf("No commas : "); for(i=0;i<N;i++) { printf("%d ", nums[i]); }
printf("\nWith commas: "); for(i=0;i<N;i++) { printf("%d,", nums[i]); }
qsort(nums,N,sizeof(int),compareint);
printf("\nSorted : "); for(i=0;i<N;i++) { printf("%d ", nums[i]); }
printf("\nSorted : "); for(i=0;i<N;i++) { printf("%d,", nums[i]); }
}

//generate consecutive numbers 1 to N
if(strcmp(argv[2],"-c") == 0) {
for(i=0;i<N;i++) { nums[i] = i + 1; }

printf("%d Consecutive:\n", N);
printf("No commas : "); for(i=0;i<N;i++) { printf("%d ", nums[i]); }
printf("\nWith commas : "); for(i=0;i<N;i++) { printf("%d,", nums[i]); }
}

//calc various descriptive stats
double min = nums[0], max = nums[N-1];
for(i=0;i<N;i++) {sumN += nums[i];}
double mean = sumN / (double)N;
for(i = 0; i < N; i++)
{
double diff = nums[i] - mean;
sqrdiffmean += diff * diff ; // for variance and sum squares
cubediffmean += diff * diff * diff ; // for skewness
quaddiffmean += diff * diff * diff * diff ; // for Kurtosis
meanabsdev += fabs(diff) ; // for mean absolute deviation
rootmeansqr += nums[i] * nums[i] ; // for root mean square
}

On Thu, 13 Jun 2024 15:08:50 -0400, DFS wrote:

> - malloc the md_count[] array to size 9 (because there
> are only 9 unique values in the size 10 dataset)

What memory location is md_count[9]++ incrementing? For that matter what
are the initial values of md_count[0] through md_count[8] ?

I used memset(&md_count, 0, sizeof md_count); with the original
declaration or you could have used calloc().

Same difference. You wind up with something that's not an array of
whatever random crap is on the stack.

> - add return 0

picky, picky... I suppose you want 'int main(void)' too. I can't remember
the guy's name but he was a prolific author of programming books in the
early '80s whose examples always started with 'void main(). If comments
in programming forums could kill he would have had an early retirement.

Not for nothing but in VS Code if you don't initialize 'mode' at the point
where it's used there is a red squiggle that pops up 'identifier "mode" is
undefinedC/C++(20)' It doesn't flag an uninitialized 'mean', although
'mean += nums[len];' assumes it was 0.0. Points to clang for that one.

DFS <nospam@dfs.com> wrote at 19:08 this Thursday (GMT):
> On 6/13/2024 1:30 PM, rbowman wrote:
>> On Thu, 13 Jun 2024 10:59:51 -0400, DFS wrote:
>>
>>> Did you print the contents of md_count[] ? That should give you a clue.
>>
>> Or print mode. Maybe you got lucky.
>
> You mean I got lucky with:
>
> 1. 1
> 2. 1
> 3. 1
> 4. 1
> 5. 2
> 6. 1
> 7. 1
> 8. 1
> 9. 1
>
> ?
>
> Not luck. It didn't look like that at first. I got there only after
> making various fixes.
>
> With his 3-word responses and 2-day delay, candycane doesn't seem too
> interested in his program. The fixes I made are below.
>

Sorry, I've been kinda busy this week..
[snip]
--
user <candycane> is generated from /dev/urandom

On 6/13/2024 6:16 PM, rbowman wrote:
> On Thu, 13 Jun 2024 15:08:50 -0400, DFS wrote:
>
>> - malloc the md_count[] array to size 9 (because there
>> are only 9 unique values in the size 10 dataset)
>
> What memory location is md_count[9]++ incrementing?

9 is the correct size for md_count[], but then you have to play games
with index addressing and looping.

So malloc() to size 10 and life's good.

> For that matter what are the initial values of md_count[0] through md_count[8] ?

0.

gcc 11.4 on Ubuntu WSL

> I used memset(&md_count, 0, sizeof md_count); with the original
> declaration or you could have used calloc().
>
> Same difference. You wind up with something that's not an array of
> whatever random crap is on the stack.
>
>> - add return 0
>
> picky, picky... I suppose you want 'int main(void)' too.

Definitely. I should've caught that.

You HAVE to be picky to write good C programs. Way too picky I think.

> I can't remember
> the guy's name but he was a prolific author of programming books in the
> early '80s whose examples always started with 'void main(). If comments
> in programming forums could kill he would have had an early retirement.

Bring up void main() in comp.lang.c and you'll get an earful, I'm sure.

> Not for nothing but in VS Code if you don't initialize 'mode' at the point
> where it's used there is a red squiggle that pops up 'identifier "mode" is
> undefinedC/C++(20)' It doesn't flag an uninitialized 'mean', although
> 'mean += nums[len];' assumes it was 0.0. Points to clang for that one.

I just tried VS Code with a light theme and it looked good. I guess I
could get used to it, but I'll stick with Notepad++.

Le 08-06-2024, Diego Garcia <dg@chaos.rocks> a écrit :
>
> I can write my name in 2 seconds,

Are you sure about it? I don't believe it.

> but with Python it would require 20 minutes

I believe in this part. I already knew you aren't a programmer. A little
girl could do it in five minutes. If a child comes to see you in your asylum,
you could ask her to teach you. It would take less than 20 minutes.

> -- not including the installation of appropriate modules.

You already have three versions of python on your gentoo distro managed
by others. You don't need to install anything more on it.

--
Si vous avez du temps à perdre :
https://scarpet42.gitlab.io

> Python is taking the computing world by storm, because the majority of the
> computing world are totally incompetent idiots.
>
> Aside: Does anyone see a Microslop connection? Ha, ha, ha, ha, ha, ha, ha!
>
> While updating my fantastic Gentoo machines I notice these funny things:
>
> hatch-fancy-pypi-readme (https://pypi.org/project/hatch-fancy-pypi-readme/)
>
> pluggy (https://pluggy.readthedocs.io/en/stable/)
>
> calver (https://github.com/di/calver/)
>
>
> Holy shish kabob! Junk Python requires a thousand auxiliary modules
> just to output a single char! (And millions more to do anything remotely
> worthwhile.)
>
> The inescapable conclusion:
>
> Python absolutely requires a humongous mountain of support functions to
> accomplish its seeming magical ease, and this mountain is conveniently
> hidden from the incompetent Python user who will drool in awe over the
> "effortless" capability.
>
> The unhidden cost, however, is extreme sluggishness and sluggishness
> violates the very concept of digital computing.
>
> Ha, ha, ha, ha, ha, ha, ha, ha, ha, ha, ha, ha!
>
> I can write my name in 2 seconds, but with Python it would require 20
> minutes -- not including the installation of appropriate modules.
>
> Ha, ha, ha, ha, ha, ha, ha, ha, ha, ha, ha, ha!
>
>

--
Si vous avez du temps à perdre :
https://scarpet42.gitlab.io