hash_table | Ce repo contient une simple implementation d'une table

This should be handled by documented pre-conditions. If you write a function, it should document what the required pre-conditions are to call the function and then it's the responsibility of the calling code to ensure the pre-conditions are met. This should be a pre-condition.

For example, it is a pre-condition of calling free that the pointer passed in either point to memory allocated by malloc (or a related function) and not freed yet. The free function does not attempt to check if this pre-condition is met because it's the responsibility of the calling code to do that.

Do not rely on a pointer value being NULL. That's not a good habit to get into and it will serve you badly as you continue learning more complex programming skills. While it can certainly make sense to use a pointer value of NULL to indicate that an object hasn't been allocated or has been freed, it should never be used without thought and only used where it specifically makes sense to do that.

The main reason is simple -- there will be times when there will be two pointers to the same object. You often can't set both to NULL when you call free. If you get in the habit of assuming that a pointer will always be NULL if it's not pointing to something allocated, you will struggle with code like that.

You generally do not need to use types in the malloc size, and you should avoid it. You can use a “sample object” instead:

Two headers that rely to each other are not a show stopper if well-formed. What I observe is that your include guards don't enclose the full header but only part of it, this I think is wrong. The right way to use include guards is shown in this

example header some_component.h:

You shoudld

• Specify the types of function arguments.
• Allocate for the array index_table.
• Remove extra malloc() whose result is overwritten to NULL right away to eliminate memory leak.
• Use correct syntax for for: use ; instead of ,.
• Return the created object.

The number 7 is in your list nums, but it isn't automatically in the dictionary.

The line hash_table[i] += 1 looks up the value of i in hash_table, adds one to it, and then changes the value in the hash_table. But it can't look up the value of 7 in hash_table if hash_table is an ordinary dictionary, because 7 was never added to the dictionary.

With a defaultdict, the code works because when it tries to look up the value 7 in hash_table, it discovers that 7 is not in the hash_table yet, and so it returns the default value, which in this case is 0. It then adds 1 to that, and then changes the value in the dictionary.

I think your understanding of the defaultdict is correct: If the key is not present, then the key will be added with a default value. In the case of a defaultdict(int), that default value will be 0. But what are you passing as nums? If nums is not empty then hash_table will not be empty after the first for loop. However, method singleNumber just returns a single value, which will be the first key of hash_table that appeared in the nums list only once. As Tomericlo pointed out, your hash_table is acting more like a set of counters counting the number of times that each distinct integer in nums appears. I have modified your code to insert a print statement (and missing import statements) and added a test case.

Note that if no integer in nums appears only once, then your code never finds a match and never issues a return statement, which is equivalent to returning the value None.

The issue is that the feature empty_duplicate (mentioned in the error message) creates a new instance of a hash table using the original creation procedure make. However, this feature is no longer a creation procedure in HASH_TABLE2. The solution is to redefine empty_duplicate accordingly:

Replace this code

You can use itertools.groupby to group the 0s and 1s: