From bff180cd1b3410ae3851ed6638524029092f51ab Mon Sep 17 00:00:00 2001 From: Paulo Custodio Date: Tue, 9 May 2023 16:55:18 +0100 Subject: Add C solution --- challenge-025/paulo-custodio/c/ch-1.c | 108 +++++++++++++ challenge-025/paulo-custodio/c/utarray.h | 252 ++++++++++++++++++++++++++++++ challenge-025/paulo-custodio/perl/ch-1.pl | 33 ++-- 3 files changed, 377 insertions(+), 16 deletions(-) create mode 100644 challenge-025/paulo-custodio/c/ch-1.c create mode 100644 challenge-025/paulo-custodio/c/utarray.h 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..feb2b11dae --- /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 +#include +#include +#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 /* size_t */ +#include /* memset, etc */ +#include /* 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..7812bb0b8d 100644 --- a/challenge-025/paulo-custodio/perl/ch-1.pl +++ b/challenge-025/paulo-custodio/perl/ch-1.pl @@ -22,30 +22,31 @@ 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) = @_; + my($longest_path, $current_path, @pending) = @_; +#say "(@$current_path) (@pending)"; - # 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 + 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] ) ); + } + } + + if (!$found_name) { if (@$current_path > @$longest_path) { @$longest_path = @$current_path; } - } - else { # find each possible path - for my $word (@pending) { - find_longest_sequence1($longest_path, - [ @$current_path, $word ], - { %$seen, $word => 1 } ); - } - } + } } sub find_longest_sequence { my(@words) = @_; my @longest_path; - find_longest_sequence1(\@longest_path, [], {}); + find_longest_sequence1(\@longest_path, [], @names); return @longest_path; } -- cgit From e09d0c629d99aa5f6db10e7eac8569cea72aae3b Mon Sep 17 00:00:00 2001 From: Paulo Custodio Date: Tue, 9 May 2023 16:59:29 +0100 Subject: whitespace --- challenge-025/paulo-custodio/c/ch-1.c | 144 +++++++++++++++--------------- challenge-025/paulo-custodio/perl/ch-1.pl | 26 +++--- challenge-215/paulo-custodio/perl/ch-2.pl | 2 - 3 files changed, 85 insertions(+), 87 deletions(-) diff --git a/challenge-025/paulo-custodio/c/ch-1.c b/challenge-025/paulo-custodio/c/ch-1.c index feb2b11dae..709c9adc19 100644 --- a/challenge-025/paulo-custodio/c/ch-1.c +++ b/challenge-025/paulo-custodio/c/ch-1.c @@ -11,98 +11,98 @@ each name starts with the last letter of previous name. #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" + "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"); + 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); - } + 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; + 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); - } - } + 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); + utarray_new(longest_seq, &ut_int_icd); - UT_array* seq; - utarray_new(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); + 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); + find_longest_sequence(seq, pending); + print_seq(longest_seq); - utarray_free(longest_seq); - utarray_free(seq); - utarray_free(pending); + utarray_free(longest_seq); + utarray_free(seq); + utarray_free(pending); } diff --git a/challenge-025/paulo-custodio/perl/ch-1.pl b/challenge-025/paulo-custodio/perl/ch-1.pl index 7812bb0b8d..01eb44415e 100644 --- a/challenge-025/paulo-custodio/perl/ch-1.pl +++ b/challenge-025/paulo-custodio/perl/ch-1.pl @@ -25,23 +25,23 @@ sub find_longest_sequence1 { my($longest_path, $current_path, @pending) = @_; #say "(@$current_path) (@pending)"; - my $found_name = 0; - for my $i (0 .. $#pending) { - if (@$current_path == 0 || + 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] ) ); - } - } - - if (!$found_name) { + $found_name = 1; + + find_longest_sequence1($longest_path, + [ @$current_path, $pending[$i] ], + ( @pending[0..$i-1], @pending[$i+1..$#pending] ) ); + } + } + + if (!$found_name) { if (@$current_path > @$longest_path) { @$longest_path = @$current_path; } - } + } } sub find_longest_sequence { 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); - - -- cgit