# Remove all the duplicates from a sorted linked list

Given a sorted linked list, remove all the duplicates from the list. For example, given 1->2->3->3->6, return 1->2->6. Another example, given 1->1->1->2->4, return 2->4.

```typedef struct node Node;

/* The function removes duplicates from a sorted list */
{
/* do nothing if the list is empty */
if(current == NULL)
return;

/* Pointer to traverse the linked list */

/* Pointer to store the next pointer of a node to be deleted*/
Node* next_next;
bool deleted = false;

/* Traverse the list till last node */
while(current->next != NULL)
{
/* Compare current node with next node */
if(current->data == current->next->data) {
/*The sequence of steps is important*/
next_next = current->next->next;
free(current->next);
current->next = next_next;
deleted = true;
}
else if (deleted)  {
pre->next = current->next;
free(current);
current = pre->next;
deleted = false;
}
else {
pre = current;
current = current->next;
}
}

/* remove the last duplicated node*/
if (deleted) {
pre->next = NULL;
free(current);
}

}

```

# Compute the kurtosis of standard Gaussian distribution

In this post, we will derive the kurtosis of stand Gaussian distribution is 3. We use the following equation to calculate the fourth central moment The fourth central moment is Therefore, the kurtosis is For an application of Kurtosis analysis in saliency detection/in-focus segmentation, please refer to our paper and source code.

# Dutch national flag problem – matlab

Dutch national flag problem is a classic programming problem. It groups the input array into three sub-groups in just one pass. For detailed information, please refer to http://en.wikipedia.org/wiki/Dutch_national_flag_problem

```function x = category_sort(x, low, high)

len = length(x);
p = 1; q = len;
i = 1;

while i <= q
if x(i) < low     % move the current element to the front
tmp = x(p);
x(p) = x(i);
x(i) = tmp;

p = p + 1;
i = i + 1;
elseif x(i) >= high     % move the current element to the back
tmp = x(q);
x(q) = x(i);
x(i) = tmp;

q = q - 1;
else    % move to the next element in the array
i = i + 1;
end
end

```

We can test the code by simply running the following script:

```x = 3 * rand(20, 1);
x = category_sort(x, 1, 2)
```

# Implement strtok in C

To implement the C function ‘strtok’, one doesn’t need to allocate extra memory for the input string before modifying it, since the caller function is supposed to make copy of the input string and deallocate the original input string. The function only needs to define static variables to store the starting of the string.

The caller function provides a string as the input during the first call, and ‘null’ for the following function calls. For details about how this function works, please refer to http://www.cplusplus.com/reference/cstring/strtok/.

```char* sp = NULL; /* the start position of the string */

char* strtok1(char* str, const char* delimiters) {

int i = 0;
int len = strlen(delimiters);

/* check in the delimiters */
if(len == 0)
printf("delimiters are empty\n");

/* if the original string has nothing left */
if(!str && !sp)
return NULL;

/* initialize the sp during the first call */
if(str && !sp)
sp = str;

/* find the start of the substring, skip delimiters */
char* p_start = sp;
while(true) {
for(i = 0; i < len; i ++) {
if(*p_start == delimiters[i]) {
p_start ++;
break;
}
}

if(i == len) {
sp = p_start;
break;
}
}

/* return NULL if nothing left */
if(*sp == '\0') {
sp = NULL;
return sp;
}

/* find the end of the substring, and
replace the delimiter with null */
while(*sp != '\0') {
for(i = 0; i < len; i ++) {
if(*sp == delimiters[i]) {
*sp = '\0';
break;
}
}

sp ++;
if (i < len)
break;
}

return p_start;
}
```

This following is the test code from `cplusplus.com`.

```#include <stdio.h>
#include <string.h>

int main ()
{
char str[] ="- This, a sample string.";
char * pch;
printf ("Splitting string \"%s\" into tokens:\n",str);
pch = strtok1(str," ,.-");
while (pch != NULL)
{
printf ("%s\n",pch);
pch = strtok1(NULL, " ,.-");
}
return 0;
}
```

————————-
As pointed out by Ian in the following comments [9.25.2014], there is a much simpler solution to this problem. Feel free to test it and let us know if it has any bugs.

```char* strtok1(char *str, const char* delim) {
static char* _buffer;
if(str != NULL) _buffer = str;
if(_buffer == '\0') return NULL;

char *ret = _buffer, *b;
const char *d;

for(b = _buffer; *b !='\0'; b++) {
for(d = delim; *d != '\0'; d++) {
if(*b == *d) {
*b = '\0';
_buffer = b+1;

// skip the beginning delimiters
if(b == ret) {
ret++;
continue;
}
return ret;
}
}
}

return ret;
}

```