new files

Task/Ordered-words/C/ordered-words-1.c

@@ -0,0 +1,83 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+
+
+#define MAXLEN 100
+typedef char TWord[MAXLEN];
+
+
+typedef struct Node {
+    TWord word;
+    struct Node *next;
+} Node;
+
+
+int is_ordered_word(const TWord word) {
+    assert(word != NULL);
+    int i;
+
+    for (i = 0; word[i] != '\0'; i++)
+        if (word[i] > word[i + 1] && word[i + 1] != '\0')
+            return 0;
+
+    return 1;
+}
+
+
+Node* list_prepend(Node* words_list, const TWord new_word) {
+    assert(new_word != NULL);
+    Node *new_node = malloc(sizeof(Node));
+    if (new_node == NULL)
+        exit(EXIT_FAILURE);
+
+    strcpy(new_node->word, new_word);
+    new_node->next = words_list;
+    return new_node;
+}
+
+
+Node* list_destroy(Node *words_list) {
+    while (words_list != NULL) {
+        Node *temp = words_list;
+        words_list = words_list->next;
+        free(temp);
+    }
+
+    return words_list;
+}
+
+
+void list_print(Node *words_list) {
+    while (words_list != NULL) {
+        printf("\n%s", words_list->word);
+        words_list = words_list->next;
+    }
+}
+
+
+int main() {
+    FILE *fp = fopen("unixdict.txt", "r");
+    if (fp == NULL)
+        return EXIT_FAILURE;
+
+    Node *words = NULL;
+    TWord line;
+    unsigned int max_len = 0;
+
+    while (fscanf(fp, "%99s\n", line) != EOF) {
+        if (strlen(line) > max_len && is_ordered_word(line)) {
+            max_len = strlen(line);
+            words = list_destroy(words);
+            words = list_prepend(words, line);
+        } else if (strlen(line) == max_len && is_ordered_word(line)) {
+            words = list_prepend(words, line);
+        }
+    }
+
+    fclose(fp);
+    list_print(words);
+
+    return EXIT_SUCCESS;
+}

Task/Ordered-words/C/ordered-words-2.c

@@ -0,0 +1,87 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+
+
+#define MAXLEN 100
+typedef char TWord[MAXLEN];
+
+
+typedef struct WordsArray {
+    TWord *words;
+    size_t len;
+} WordsArray;
+
+
+int is_ordered_word(const TWord word) {
+    assert(word != NULL);
+    int i;
+
+    for (i = 0; word[i] != '\0'; i++)
+        if (word[i] > word[i + 1] && word[i + 1] != '\0')
+            return 0;
+
+    return 1;
+}
+
+
+void array_append(WordsArray *words_array, const TWord new_word) {
+    assert(words_array != NULL);
+    assert(new_word != NULL);
+    assert((words_array->len == 0) == (words_array->words == NULL));
+
+    words_array->len++;
+    words_array->words = realloc(words_array->words,
+                                 words_array->len * sizeof(words_array->words[0]));
+    if (words_array->words == NULL)
+        exit(EXIT_FAILURE);
+    strcpy(words_array->words[words_array->len-1], new_word);
+}
+
+
+void array_free(WordsArray *words_array) {
+    assert(words_array != NULL);
+    free(words_array->words);
+    words_array->words = NULL;
+    words_array->len = 0;
+}
+
+
+void list_print(WordsArray *words_array) {
+    assert(words_array != NULL);
+    size_t i;
+    for (i = 0; i < words_array->len; i++)
+        printf("\n%s", words_array->words[i]);
+}
+
+
+int main() {
+    FILE *fp = fopen("unixdict.txt", "r");
+    if (fp == NULL)
+        return EXIT_FAILURE;
+
+    WordsArray words;
+    words.len = 0;
+    words.words = NULL;
+
+    TWord line;
+    line[0] = '\0';
+    unsigned int max_len = 0;
+
+    while (fscanf(fp, "%99s\n", line) != EOF) { // 99 = MAXLEN - 1
+        if (strlen(line) > max_len && is_ordered_word(line)) {
+            max_len = strlen(line);
+            array_free(&words);
+            array_append(&words, line);
+        } else if (strlen(line) == max_len && is_ordered_word(line)) {
+            array_append(&words, line);
+        }
+    }
+
+    fclose(fp);
+    list_print(&words);
+    array_free(&words);
+
+    return EXIT_SUCCESS;
+}

Task/Ordered-words/C/ordered-words-3.c

@@ -0,0 +1,54 @@
+#include <stdio.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <err.h>
+#include <string.h>
+
+int ordered(char *s, char **end)
+{
+	int r = 1;
+	while (*++s != '\n' && *s != '\r' && *s != '\0')
+		if (s[0] < s[-1]) r = 0;
+
+	*end = s;
+	return r;
+}
+
+int main()
+{
+	char *buf, *word, *end, *tail;
+	struct stat st;
+	int longest = 0, len, fd;
+
+	if ((fd = open("unixdict.txt", O_RDONLY)) == -1) err(1, "read error");
+
+	fstat(fd, &st);
+	if (!(buf = mmap(0, st.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0)))
+		err(1, "mmap");
+
+	for (word = end = buf; end < buf + st.st_size; word = end) {
+		while (*word == '\r' || *word == '\n') word++;
+		if (!ordered(word, &end)) continue;
+		if ((len = end - word + 1) < longest) continue;
+		if (len > longest) {
+			tail = buf;  /* longer words found; reset out buffer */
+			longest = len;
+		}
+		/* use the same mmap'd region to store output.  because of MAP_PRIVATE,
+		 * change will not go back to file.  mmap is copy on write, and we are using
+		 * only the head space to store output, so kernel doesn't need to copy more
+		 * than the words we saved--in this case, one page tops.
+		 */
+		memcpy(tail, word, len);
+		tail += len;
+		*tail = '\0';
+	}
+	printf(buf);
+
+	munmap(buf, st.st_size);
+	close(fd);
+	return 0;
+}