you basically have to iterate over the array again and print count all the numbers where arr[i] != arr[N - 1]

"the number of elements different from the last element"I am not writing correctly

I just need help getting started

and if for a certain period I do not show the result, I will not go to the second round

OK #include <stdio.h> int main() { printf("yes"); } You are now basically overqualified to work at any tech startup

Which IDE are you using?

Is it bad practice to declare a static variable in the header file?

I don't like that idea as most people might not be aware of the implications.

What's wrong with it?

i think share data

Yeah data are shared all time + I think inline solved that definition and declare problems

The data gets duplicated for every CU. Potentially wasting memory. e.g. foo.hpp #pragma once #ifndef FOO_HPP_ #define FOO_HPP_ #include <cstdint> static uint64_t foo = 1337; void bar(); #endif foo.cpp #include <cstdio> #include "foo.hpp" void bar() { foo = 1338; std::printf("%llu\n", foo); } app.cpp #include <cstdio> #include "foo.hpp" int main (int argc, char **argv) { bar(); std::printf("%llu\n", foo); return 0; } the unsigned integer in foo.cpp and app.cpp are not the same. So this will print 1338 1337

You mean bar function?

are there best practice?

I should sleep -.- yeah, bar function or foo.cpp in general

I don't see the point Bar () just adjusted the value because you called it That's all

yes, but defining the variable in the header might give the impression that you can access the same variable from different source files - but you can't because it gets duplicated. Changing foo defined in the header in the bar function has no impact on the value of foo in the other source file

who knows algorithm and data structure`/?

If you want to have two distinct foo (one in each source file) I would suggest defining them there and not in a shared header.

It's related to execution process What's get called first changes it first

+ Why there is a duplication I thought header guards prevent that

the thing is tho, if you can't "share" the variable why even define it in a header? I would argue that is an implementation detail and should not be exposed. You include the header and not you have this variable defined, what if it is a huge lookup table? Do you really want to duplicate the table over and over again? the static defines the variable to be internally linked which basically prevents it from being exposed to the linker and hence it will never be accessible from any different CU

it prevents. so in one compilation unit you have one variable. but if you have two source files, in each the same header file is included, you have two copy of the same variable

Won't that cause any error?!🤔

So that's what differs it from global variable What's the lookup table

And @ollirz said something about internal link What is that?

https://stackoverflow.com/questions/1358400/what-is-external-linkage-and-internal-linkage

So static variables do not have any external linkage, right?

correct - they are internal

It can be shared across multiple files (e.g the source file and header you include) but not multiple compilation units

How does the compiler accommodate that

with internal linkage the header basically defines the variable. For every compilation unit the header is included in, memory for this variable will be allocated and since it's internal the location will not be looked up by the linker (it's already known)

Thanks olli You should go to sleep now xD

gcc can show you the output after the preprocessor step by passing -E , e.g. https://godbolt.org/z/an5xKM Seeing how fast this can grow it makes sense to prefer forward declarations over includes.

What is it used for?

To store pointers

How?

So i want they are declared and initialized

Btw do ppl usually read the C standard? Those who aren't building a compiler?