Merge pull request #8048 from pauloscustodio/master

Add solution

4 files changed, 377 insertions, 18 deletions

diff --git a/challenge-025/paulo-custodio/c/ch-1.c b/challenge-025/paulo-custodio/c/ch-1.c
new file mode 100644
index 0000000000..709c9adc19
--- /dev/null
+++ b/challenge-025/paulo-custodio/c/ch-1.c
@@ -0,0 +1,108 @@
+/*
+Challenge 025
+
+Generate a longest sequence of the following "English Pokemon" names where
+each name starts with the last letter of previous name.
+*/
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "utarray.h"
+
+static const char* names[] = {
+    "audino", "bagon", "baltoy", "banette", "bidoof", "braviary", "bronzor",
+    "carracosta", "charmeleon", "cresselia", "croagunk", "darmanitan",
+    "deino", "emboar", "emolga", "exeggcute", "gabite", "girafarig",
+    "gulpin", "haxorus", "heatmor", "heatran", "ivysaur", "jellicent",
+    "jumpluff", "kangaskhan", "kricketune", "landorus", "ledyba", "loudred",
+    "lumineon", "lunatone", "machamp", "magnezone", "mamoswine", "nosepass",
+    "petilil", "pidgeotto", "pikachu", "pinsir", "poliwrath", "poochyena",
+    "porygon2", "porygonz", "registeel", "relicanth", "remoraid", "rufflet",
+    "sableye", "scolipede", "scrafty", "seaking", "sealeo", "silcoon",
+    "simisear", "snivy", "snorlax", "spoink", "starly", "tirtouga",
+    "trapinch", "treecko", "tyrogue", "vigoroth", "vulpix", "wailord",
+    "wartortle", "whismur", "wingull", "yamask"
+};
+int names_size = sizeof(names) / sizeof(char*);
+
+UT_array* longest_seq;
+
+void print_seq(UT_array* seq) {
+    for (int* p = (int*)utarray_front(seq); p != NULL;
+        p = (int*)utarray_next(seq, p)) {
+        printf("%s ", names[*p]);
+    }
+    printf("\n");
+}
+
+void copy_seq(UT_array* dst, UT_array* src) {
+    utarray_clear(dst);
+    for (int* p = (int*)utarray_front(src); p != NULL;
+        p = (int*)utarray_next(src, p)) {
+        utarray_push_back(dst, p);
+    }
+}
+
+char last_letter_seq(UT_array* seq) {
+    char last_letter = '\0';
+    if (utarray_len(seq) > 0) {
+        const char* last_name = names[*(int*)utarray_back(seq)];
+        last_letter = last_name[strlen(last_name) - 1];
+    }
+    return last_letter;
+}
+
+void find_longest_sequence(UT_array* seq, UT_array* pending) {
+    char last_letter = last_letter_seq(seq);
+
+    bool found_next = false;
+    for (int* p = (int*)utarray_front(pending); p != NULL;
+        p = (int*)utarray_next(pending, p)) {
+        char first_letter = names[*p][0];
+
+        if (last_letter == '\0' || last_letter == first_letter) {
+            found_next = true;
+
+            UT_array* new_seq;
+            utarray_new(new_seq, &ut_int_icd);
+            copy_seq(new_seq, seq);
+            utarray_push_back(new_seq, p);
+
+            UT_array* new_pending;
+            utarray_new(new_pending, &ut_int_icd);
+            copy_seq(new_pending, pending);
+            utarray_erase(new_pending, p-(int*)utarray_front(pending), 1);
+
+            find_longest_sequence(new_seq, new_pending);
+
+            utarray_free(new_seq);
+            utarray_free(new_pending);
+        }
+    }
+
+    if (!found_next) {
+        if (utarray_len(seq) > utarray_len(longest_seq)) {
+            copy_seq(longest_seq, seq);
+        }
+    }
+}
+
+int main() {
+    utarray_new(longest_seq, &ut_int_icd);
+
+    UT_array* seq;
+    utarray_new(seq, &ut_int_icd);
+
+    UT_array* pending;
+    utarray_new(pending, &ut_int_icd);
+    for (int i = 0; i < names_size; i++)
+        utarray_push_back(pending, &i);
+
+    find_longest_sequence(seq, pending);
+    print_seq(longest_seq);
+
+    utarray_free(longest_seq);
+    utarray_free(seq);
+    utarray_free(pending);
+}
diff --git a/challenge-025/paulo-custodio/c/utarray.h b/challenge-025/paulo-custodio/c/utarray.h
new file mode 100644
index 0000000000..1fe8bc1c74
--- /dev/null
+++ b/challenge-025/paulo-custodio/c/utarray.h
@@ -0,0 +1,252 @@
+/*
+Copyright (c) 2008-2022, Troy D. Hanson  https://troydhanson.github.io/uthash/
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/* a dynamic array implementation using macros
+ */
+#ifndef UTARRAY_H
+#define UTARRAY_H
+
+#define UTARRAY_VERSION 2.3.0
+
+#include <stddef.h>  /* size_t */
+#include <string.h>  /* memset, etc */
+#include <stdlib.h>  /* exit */
+
+#ifdef __GNUC__
+#define UTARRAY_UNUSED __attribute__((__unused__))
+#else
+#define UTARRAY_UNUSED
+#endif
+
+#ifndef utarray_oom
+#define utarray_oom() exit(-1)
+#endif
+
+typedef void (ctor_f)(void *dst, const void *src);
+typedef void (dtor_f)(void *elt);
+typedef void (init_f)(void *elt);
+typedef struct {
+    size_t sz;
+    init_f *init;
+    ctor_f *copy;
+    dtor_f *dtor;
+} UT_icd;
+
+typedef struct {
+    unsigned i,n;/* i: index of next available slot, n: num slots */
+    UT_icd icd;  /* initializer, copy and destructor functions */
+    char *d;     /* n slots of size icd->sz*/
+} UT_array;
+
+#define utarray_init(a,_icd) do {                                             \
+  memset(a,0,sizeof(UT_array));                                               \
+  (a)->icd = *(_icd);                                                         \
+} while(0)
+
+#define utarray_done(a) do {                                                  \
+  if ((a)->n) {                                                               \
+    if ((a)->icd.dtor) {                                                      \
+      unsigned _ut_i;                                                         \
+      for(_ut_i=0; _ut_i < (a)->i; _ut_i++) {                                 \
+        (a)->icd.dtor(utarray_eltptr(a,_ut_i));                               \
+      }                                                                       \
+    }                                                                         \
+    free((a)->d);                                                             \
+  }                                                                           \
+  (a)->n=0;                                                                   \
+} while(0)
+
+#define utarray_new(a,_icd) do {                                              \
+  (a) = (UT_array*)malloc(sizeof(UT_array));                                  \
+  if ((a) == NULL) {                                                          \
+    utarray_oom();                                                            \
+  }                                                                           \
+  utarray_init(a,_icd);                                                       \
+} while(0)
+
+#define utarray_free(a) do {                                                  \
+  utarray_done(a);                                                            \
+  free(a);                                                                    \
+} while(0)
+
+#define utarray_reserve(a,by) do {                                            \
+  if (((a)->i+(by)) > (a)->n) {                                               \
+    char *utarray_tmp;                                                        \
+    while (((a)->i+(by)) > (a)->n) { (a)->n = ((a)->n ? (2*(a)->n) : 8); }    \
+    utarray_tmp=(char*)realloc((a)->d, (a)->n*(a)->icd.sz);                   \
+    if (utarray_tmp == NULL) {                                                \
+      utarray_oom();                                                          \
+    }                                                                         \
+    (a)->d=utarray_tmp;                                                       \
+  }                                                                           \
+} while(0)
+
+#define utarray_push_back(a,p) do {                                           \
+  utarray_reserve(a,1);                                                       \
+  if ((a)->icd.copy) { (a)->icd.copy( _utarray_eltptr(a,(a)->i++), p); }      \
+  else { memcpy(_utarray_eltptr(a,(a)->i++), p, (a)->icd.sz); };              \
+} while(0)
+
+#define utarray_pop_back(a) do {                                              \
+  if ((a)->icd.dtor) { (a)->icd.dtor( _utarray_eltptr(a,--((a)->i))); }       \
+  else { (a)->i--; }                                                          \
+} while(0)
+
+#define utarray_extend_back(a) do {                                           \
+  utarray_reserve(a,1);                                                       \
+  if ((a)->icd.init) { (a)->icd.init(_utarray_eltptr(a,(a)->i)); }            \
+  else { memset(_utarray_eltptr(a,(a)->i),0,(a)->icd.sz); }                   \
+  (a)->i++;                                                                   \
+} while(0)
+
+#define utarray_len(a) ((a)->i)
+
+#define utarray_eltptr(a,j) (((j) < (a)->i) ? _utarray_eltptr(a,j) : NULL)
+#define _utarray_eltptr(a,j) ((void*)((a)->d + ((a)->icd.sz * (j))))
+
+#define utarray_insert(a,p,j) do {                                            \
+  if ((j) > (a)->i) utarray_resize(a,j);                                      \
+  utarray_reserve(a,1);                                                       \
+  if ((j) < (a)->i) {                                                         \
+    memmove( _utarray_eltptr(a,(j)+1), _utarray_eltptr(a,j),                  \
+             ((a)->i - (j))*((a)->icd.sz));                                   \
+  }                                                                           \
+  if ((a)->icd.copy) { (a)->icd.copy( _utarray_eltptr(a,j), p); }             \
+  else { memcpy(_utarray_eltptr(a,j), p, (a)->icd.sz); };                     \
+  (a)->i++;                                                                   \
+} while(0)
+
+#define utarray_inserta(a,w,j) do {                                           \
+  if (utarray_len(w) == 0) break;                                             \
+  if ((j) > (a)->i) utarray_resize(a,j);                                      \
+  utarray_reserve(a,utarray_len(w));                                          \
+  if ((j) < (a)->i) {                                                         \
+    memmove(_utarray_eltptr(a,(j)+utarray_len(w)),                            \
+            _utarray_eltptr(a,j),                                             \
+            ((a)->i - (j))*((a)->icd.sz));                                    \
+  }                                                                           \
+  if ((a)->icd.copy) {                                                        \
+    unsigned _ut_i;                                                           \
+    for(_ut_i=0;_ut_i<(w)->i;_ut_i++) {                                       \
+      (a)->icd.copy(_utarray_eltptr(a, (j) + _ut_i), _utarray_eltptr(w, _ut_i)); \
+    }                                                                         \
+  } else {                                                                    \
+    memcpy(_utarray_eltptr(a,j), _utarray_eltptr(w,0),                        \
+           utarray_len(w)*((a)->icd.sz));                                     \
+  }                                                                           \
+  (a)->i += utarray_len(w);                                                   \
+} while(0)
+
+#define utarray_resize(dst,num) do {                                          \
+  unsigned _ut_i;                                                             \
+  if ((dst)->i > (unsigned)(num)) {                                           \
+    if ((dst)->icd.dtor) {                                                    \
+      for (_ut_i = (num); _ut_i < (dst)->i; ++_ut_i) {                        \
+        (dst)->icd.dtor(_utarray_eltptr(dst, _ut_i));                         \
+      }                                                                       \
+    }                                                                         \
+  } else if ((dst)->i < (unsigned)(num)) {                                    \
+    utarray_reserve(dst, (num) - (dst)->i);                                   \
+    if ((dst)->icd.init) {                                                    \
+      for (_ut_i = (dst)->i; _ut_i < (unsigned)(num); ++_ut_i) {              \
+        (dst)->icd.init(_utarray_eltptr(dst, _ut_i));                         \
+      }                                                                       \
+    } else {                                                                  \
+      memset(_utarray_eltptr(dst, (dst)->i), 0, (dst)->icd.sz*((num) - (dst)->i)); \
+    }                                                                         \
+  }                                                                           \
+  (dst)->i = (num);                                                           \
+} while(0)
+
+#define utarray_concat(dst,src) do {                                          \
+  utarray_inserta(dst, src, utarray_len(dst));                                \
+} while(0)
+
+#define utarray_erase(a,pos,len) do {                                         \
+  if ((a)->icd.dtor) {                                                        \
+    unsigned _ut_i;                                                           \
+    for (_ut_i = 0; _ut_i < (len); _ut_i++) {                                 \
+      (a)->icd.dtor(utarray_eltptr(a, (pos) + _ut_i));                        \
+    }                                                                         \
+  }                                                                           \
+  if ((a)->i > ((pos) + (len))) {                                             \
+    memmove(_utarray_eltptr(a, pos), _utarray_eltptr(a, (pos) + (len)),       \
+            ((a)->i - ((pos) + (len))) * (a)->icd.sz);                        \
+  }                                                                           \
+  (a)->i -= (len);                                                            \
+} while(0)
+
+#define utarray_renew(a,u) do {                                               \
+  if (a) utarray_clear(a);                                                    \
+  else utarray_new(a, u);                                                     \
+} while(0)
+
+#define utarray_clear(a) do {                                                 \
+  if ((a)->i > 0) {                                                           \
+    if ((a)->icd.dtor) {                                                      \
+      unsigned _ut_i;                                                         \
+      for(_ut_i=0; _ut_i < (a)->i; _ut_i++) {                                 \
+        (a)->icd.dtor(_utarray_eltptr(a, _ut_i));                             \
+      }                                                                       \
+    }                                                                         \
+    (a)->i = 0;                                                               \
+  }                                                                           \
+} while(0)
+
+#define utarray_sort(a,cmp) do {                                              \
+  qsort((a)->d, (a)->i, (a)->icd.sz, cmp);                                    \
+} while(0)
+
+#define utarray_find(a,v,cmp) bsearch((v),(a)->d,(a)->i,(a)->icd.sz,cmp)
+
+#define utarray_front(a) (((a)->i) ? (_utarray_eltptr(a,0)) : NULL)
+#define utarray_next(a,e) (((e)==NULL) ? utarray_front(a) : (((a)->i != utarray_eltidx(a,e)+1) ? _utarray_eltptr(a,utarray_eltidx(a,e)+1) : NULL))
+#define utarray_prev(a,e) (((e)==NULL) ? utarray_back(a) : ((utarray_eltidx(a,e) != 0) ? _utarray_eltptr(a,utarray_eltidx(a,e)-1) : NULL))
+#define utarray_back(a) (((a)->i) ? (_utarray_eltptr(a,(a)->i-1)) : NULL)
+#define utarray_eltidx(a,e) (((char*)(e) - (a)->d) / (a)->icd.sz)
+
+/* last we pre-define a few icd for common utarrays of ints and strings */
+static void utarray_str_cpy(void *dst, const void *src) {
+  char *const *srcc = (char *const *)src;
+  char **dstc = (char**)dst;
+  if (*srcc == NULL) {
+    *dstc = NULL;
+  } else {
+    *dstc = (char*)malloc(strlen(*srcc) + 1);
+    if (*dstc == NULL) {
+      utarray_oom();
+    } else {
+      strcpy(*dstc, *srcc);
+    }
+  }
+}
+static void utarray_str_dtor(void *elt) {
+  char **eltc = (char**)elt;
+  if (*eltc != NULL) free(*eltc);
+}
+static const UT_icd ut_str_icd UTARRAY_UNUSED = {sizeof(char*),NULL,utarray_str_cpy,utarray_str_dtor};
+static const UT_icd ut_int_icd UTARRAY_UNUSED = {sizeof(int),NULL,NULL,NULL};
+static const UT_icd ut_ptr_icd UTARRAY_UNUSED = {sizeof(void*),NULL,NULL,NULL};
+
+
+#endif /* UTARRAY_H */
diff --git a/challenge-025/paulo-custodio/perl/ch-1.pl b/challenge-025/paulo-custodio/perl/ch-1.pl
index 765a8c77f0..01eb44415e 100644
--- a/challenge-025/paulo-custodio/perl/ch-1.pl
+++ b/challenge-025/paulo-custodio/perl/ch-1.pl
@@ -22,23 +22,24 @@ my @names = qw( audino bagon baltoy banette bidoof braviary bronzor carracosta
 say join(" ", find_longest_sequence(@names));
 
 sub find_longest_sequence1 {
-    my($longest_path, $current_path, $seen) = @_;
-
-    # words that can still be used
-    my @pending = grep {!$seen->{$_} &&
-                        (@$current_path == 0 ||
-                         substr($current_path->[-1], -1, 1) eq substr($_, 0, 1))
-                       } @names;
-    if (@pending == 0) {                    # end of search
-        if (@$current_path > @$longest_path) {
-            @$longest_path = @$current_path;
+    my($longest_path, $current_path, @pending) = @_;
+#say "(@$current_path) (@pending)";
+
+    my $found_name = 0;
+    for my $i (0 .. $#pending) {
+        if (@$current_path == 0 ||
+            substr($current_path->[-1], -1, 1) eq substr($pending[$i], 0, 1)) {
+            $found_name = 1;
+
+            find_longest_sequence1($longest_path,
+               [ @$current_path, $pending[$i] ],
+               ( @pending[0..$i-1], @pending[$i+1..$#pending] ) );
         }
     }
-    else {                                  # find each possible path
-        for my $word (@pending) {
-            find_longest_sequence1($longest_path,
-                                   [ @$current_path, $word ],
-                                   { %$seen, $word => 1 } );
+
+    if (!$found_name) {
+        if (@$current_path > @$longest_path) {
+            @$longest_path = @$current_path;
         }
     }
 }
@@ -46,6 +47,6 @@ sub find_longest_sequence1 {
 sub find_longest_sequence {
     my(@words) = @_;
     my @longest_path;
-    find_longest_sequence1(\@longest_path, [], {});
+    find_longest_sequence1(\@longest_path, [], @names);
     return @longest_path;
 }
diff --git a/challenge-215/paulo-custodio/perl/ch-2.pl b/challenge-215/paulo-custodio/perl/ch-2.pl
index 9a55f27be1..2255a49608 100644
--- a/challenge-215/paulo-custodio/perl/ch-2.pl
+++ b/challenge-215/paulo-custodio/perl/ch-2.pl
@@ -49,5 +49,3 @@ sub can_place {
 my @nums = split /,/, shift;
 my $count = shift;
 say can_place(\@nums, $count);
-
-