diff options
| -rw-r--r-- | challenge-196/duncan-c-white/C/Makefile | 18 | ||||
| -rw-r--r-- | challenge-196/duncan-c-white/C/README | 9 | ||||
| -rw-r--r-- | challenge-196/duncan-c-white/C/args.c | 207 | ||||
| -rw-r--r-- | challenge-196/duncan-c-white/C/args.h | 11 | ||||
| -rw-r--r-- | challenge-196/duncan-c-white/C/ch-1.c | 88 | ||||
| -rw-r--r-- | challenge-196/duncan-c-white/C/ch-2.c | 131 | ||||
| -rw-r--r-- | challenge-196/duncan-c-white/C/parseints.c | 114 | ||||
| -rw-r--r-- | challenge-196/duncan-c-white/C/parseints.h | 1 | ||||
| -rw-r--r-- | challenge-196/duncan-c-white/C/printarray.c | 39 | ||||
| -rw-r--r-- | challenge-196/duncan-c-white/C/printarray.h | 1 | ||||
| -rw-r--r-- | challenge-196/duncan-c-white/README | 59 | ||||
| -rwxr-xr-x | challenge-196/duncan-c-white/perl/ch-1.pl | 80 | ||||
| -rwxr-xr-x | challenge-196/duncan-c-white/perl/ch-2.pl | 99 |
13 files changed, 834 insertions, 23 deletions
diff --git a/challenge-196/duncan-c-white/C/Makefile b/challenge-196/duncan-c-white/C/Makefile new file mode 100644 index 0000000000..1b34ccd3b2 --- /dev/null +++ b/challenge-196/duncan-c-white/C/Makefile @@ -0,0 +1,18 @@ +# Makefile rules generated by CB +CC = gcc +CFLAGS = -Wall -g +BUILD = ch-1 ch-2 + +all: $(BUILD) + +clean: + /bin/rm -f $(BUILD) *.o core a.out + +args.o: args.c +ch-1: ch-1.o args.o parseints.o printarray.o +ch-1.o: ch-1.c args.h parseints.h printarray.h +ch-2: ch-2.o args.o parseints.o printarray.o +ch-2.o: ch-2.c args.h parseints.h printarray.h +parseints.o: parseints.c args.h parseints.h printarray.h +printarray.o: printarray.c + diff --git a/challenge-196/duncan-c-white/C/README b/challenge-196/duncan-c-white/C/README new file mode 100644 index 0000000000..5f960417f8 --- /dev/null +++ b/challenge-196/duncan-c-white/C/README @@ -0,0 +1,9 @@ +Thought I'd also have a go at translating ch-1.pl and ch-2.pl into C.. + +Both C versions produce near-identical (non-debugging and even debugging) +output to the Perl originals. + +They use several of my regular support modules: +- a command-line argument processing module args.[ch], +- a csvlist-of-int parsing module parseints.[ch], and +- an int-array printing module printarray.[ch]. diff --git a/challenge-196/duncan-c-white/C/args.c b/challenge-196/duncan-c-white/C/args.c new file mode 100644 index 0000000000..d4a2d38b9a --- /dev/null +++ b/challenge-196/duncan-c-white/C/args.c @@ -0,0 +1,207 @@ +#include <stdio.h> +#include <stdlib.h> +#include <stdbool.h> +#include <string.h> +#include <ctype.h> +#include <assert.h> + + +bool debug = false; + + +// process_flag_noarg( name, argc, argv ); +// Process the -d flag, and check that there are no +// remaining arguments. +void process_flag_noarg( char *name, int argc, char **argv ) +{ + int arg=1; + if( argc>1 && strcmp( argv[arg], "-d" ) == 0 ) + { + debug = true; + arg++; + } + + int left = argc-arg; + if( left != 0 ) + { + fprintf( stderr, "Usage: %s [-d]\n", name ); + exit(1); + } +} + + +// int argno = process_flag_n_args( name, argc, argv, n, argmsg ); +// Process the -d flag, and check that there are exactly +// n remaining arguments, return the index position of the first +// argument. If not, generate a fatal Usage error using the argmsg. +// +int process_flag_n_args( char *name, int argc, char **argv, int n, char *argmsg ) +{ + int arg=1; + if( argc>1 && strcmp( argv[arg], "-d" ) == 0 ) + { + debug = true; + arg++; + } + + int left = argc-arg; + if( left != n ) + { + fprintf( stderr, "Usage: %s [-d] %s\n Exactly %d " + "arguments needed\n", name, argmsg, n ); + exit(1); + } + return arg; +} + + +// int argno = process_flag_n_m_args( name, argc, argv, min, max, argmsg ); +// Process the -d flag, and check that there are between +// min and max remaining arguments, return the index position of the first +// argument. If not, generate a fatal Usage error using the argmsg. +// +int process_flag_n_m_args( char *name, int argc, char **argv, int min, int max, char *argmsg ) +{ + int arg=1; + if( argc>1 && strcmp( argv[arg], "-d" ) == 0 ) + { + debug = true; + arg++; + } + + int left = argc-arg; + if( left < min || left > max ) + { + fprintf( stderr, "Usage: %s [-d] %s\n Between %d and %d " + "arguments needed\n", name, argmsg, min, max ); + exit(1); + } + return arg; +} + + +// process_onenumarg_default( name, argc, argv, defvalue, &n ); +// Process the -d flag, and check that there is a single +// remaining numeric argument (or no arguments, in which case +// we use the defvalue), putting it into n +void process_onenumarg_default( char *name, int argc, char **argv, int defvalue, int *n ) +{ + char argmsg[100]; + sprintf( argmsg, "[int default %d]", defvalue ); + int arg = process_flag_n_m_args( name, argc, argv, 0, 1, argmsg ); + + *n = arg == argc ? defvalue : atoi( argv[arg] ); +} + + +// process_onenumarg( name, argc, argv, &n ); +// Process the -d flag, and check that there is a single +// remaining numeric argument, putting it into n +void process_onenumarg( char *name, int argc, char **argv, int *n ) +{ + int arg = process_flag_n_args( name, argc, argv, 1, "int" ); + + // argument is in argv[arg] + *n = atoi( argv[arg] ); +} + + +// process_twonumargs( name, argc, argv, &m, &n ); +// Process the -d flag, and check that there are 2 +// remaining numeric arguments, putting them into m and n +void process_twonumargs( char *name, int argc, char **argv, int *m, int *n ) +{ + int arg = process_flag_n_args( name, argc, argv, 2, "int" ); + + // arguments are in argv[arg] and argv[arg+1] + *m = atoi( argv[arg++] ); + *n = atoi( argv[arg] ); +} + + +// process_twostrargs() IS DEPRECATED: use process_flag_n_m_args() instead + + +// int arr[100]; +// int nel = process_listnumargs( name, argc, argv, arr, 100 ); +// Process the -d flag, and check that there are >= 2 +// remaining numeric arguments, putting them into arr[0..nel-1] +// and returning nel. +int process_listnumargs( char *name, int argc, char **argv, int *arr, int maxel ) +{ + int arg=1; + if( argc>1 && strcmp( argv[arg], "-d" ) == 0 ) + { + debug = true; + arg++; + } + + int left = argc-arg; + if( left < 2 ) + { + fprintf( stderr, "Usage: %s [-d] list_of_numeric_args\n", name ); + exit(1); + } + if( left > maxel ) + { + fprintf( stderr, "%s: more than %d args\n", name, maxel ); + exit(1); + } + + // elements are in argv[arg], argv[arg+1]... + + if( debug ) + { + printf( "debug: remaining arguments are in arg=%d, " + "firstn=%s, secondn=%s..\n", + arg, argv[arg], argv[arg+1] ); + } + + int nel = 0; + for( int i=arg; i<argc; i++ ) + { + arr[nel++] = atoi( argv[i] ); + } + arr[nel] = -1; + return nel; +} + + +// +// bool isint = check_unsigned_int( char *val, int *n ); +// Given an string val, check that there's an unsigned integer +// in it (after optional whitespace). If there is a valid +// unsigned integer value, store that integer value in *n and +// return true; otherwise return false (and don't alter *n). +bool check_unsigned_int( char *val, int *n ) +{ + // skip whitespace in val + char *p; + for( p=val; isspace(*p); p++ ) + { + /*EMPTY*/ + } + if( ! isdigit(*p) ) return false; + *n = atoi(p); + return true; +} + + +// +// bool ok = check_unsigned_real( char *val, double *n ); +// Given an string val, check that there's an unsigned real +// in it (after optional whitespace). If there is a valid +// unsigned real value, store that value in *n and +// return true; otherwise return false (and don't alter *n). +bool check_unsigned_real( char *val, double *n ) +{ + // skip whitespace in val + char *p; + for( p=val; isspace(*p); p++ ) + { + /*EMPTY*/ + } + if( ! isdigit(*p) ) return false; + *n = atof(p); + return true; +} diff --git a/challenge-196/duncan-c-white/C/args.h b/challenge-196/duncan-c-white/C/args.h new file mode 100644 index 0000000000..8844a8f9c4 --- /dev/null +++ b/challenge-196/duncan-c-white/C/args.h @@ -0,0 +1,11 @@ +extern bool debug; + +extern void process_flag_noarg( char * name, int argc, char ** argv ); +extern int process_flag_n_args( char * name, int argc, char ** argv, int n, char * argmsg ); +extern int process_flag_n_m_args( char * name, int argc, char ** argv, int min, int max, char * argmsg ); +extern void process_onenumarg_default( char * name, int argc, char ** argv, int defvalue, int * n ); +extern void process_onenumarg( char * name, int argc, char ** argv, int * n ); +extern void process_twonumargs( char * name, int argc, char ** argv, int * m, int * n ); +extern int process_listnumargs( char * name, int argc, char ** argv, int * arr, int maxel ); +extern bool check_unsigned_int( char * val, int * n ); +extern bool check_unsigned_real( char * val, double * n ); diff --git a/challenge-196/duncan-c-white/C/ch-1.c b/challenge-196/duncan-c-white/C/ch-1.c new file mode 100644 index 0000000000..3a31e6f136 --- /dev/null +++ b/challenge-196/duncan-c-white/C/ch-1.c @@ -0,0 +1,88 @@ +// +// Task 1: Pattern 132 +// +// C version. +// + +#include <stdio.h> +#include <stdlib.h> +#include <stdbool.h> +#include <string.h> +#include <ctype.h> +#include <assert.h> + +#include "args.h" +#include "parseints.h" +#include "printarray.h" + + +// +// int * found = find_pat_132( arr, n ); +// Find and return a 3-element freshly malloc()d array found[] containing +// the first subsequence of arr that matches the 132 rules above, or +// return NULL if none. +// +int * find_pat_132( int *arr, int n ) +{ + for( int i=0; i<n-2; i++ ) + { + for( int j=i+1; j<n-1; j++ ) + { + for( int k=j+1; k<n; k++ ) + { + if( arr[i] < arr[k] && arr[k] < arr[j] ) + { + int *list = malloc( 3 * sizeof(int) ); + assert( list != NULL ); + list[0] = arr[i]; + list[1] = arr[j]; + list[2] = arr[k]; + return list; + } + } + } + } + return NULL; +} + + +int main( int argc, char **argv ) +{ + int argno = process_flag_n_m_args( "pattern-132", argc, argv, + 1, 1000, "intlist" ); + + int nel; + int *list = parse_int_args( argc, argv, argno, &nel ); + + if( nel < 2 ) + { + fprintf( stderr, "pattern-132: need a list of > 1 elements\n" ); + exit(1); + } + + if( debug ) + { + printf( "debug: initial list: " ); + print_int_array( 60, nel, list, ',', stdout ); + putchar( '\n' ); + } + + if( nel < 1 ) + { + fprintf( stderr, "special-numbers: nel %d must be > 0\n", nel ); + exit(1); + } + + int *sol = find_pat_132( list, nel ); + printf( "(" ); + if( sol != NULL ) + { + printf( "%d, %d, %d", sol[0], sol[1], sol[2] ); + free( sol ); + } + printf( ")\n" ); + + free( list ); + + return 0; +} diff --git a/challenge-196/duncan-c-white/C/ch-2.c b/challenge-196/duncan-c-white/C/ch-2.c new file mode 100644 index 0000000000..4b86b1e884 --- /dev/null +++ b/challenge-196/duncan-c-white/C/ch-2.c @@ -0,0 +1,131 @@ +// +// Task 2: Range List +// +// C version. +// + +#include <stdio.h> +#include <stdlib.h> +#include <stdbool.h> +#include <string.h> +#include <ctype.h> +#include <assert.h> + +#include "args.h" +#include "parseints.h" +#include "printarray.h" + + +typedef char shortstr[10]; // long enough to store a-b string + + +// +// shortstr *ranges; // dynamic array of strings +// int nr = 0; +// find_ranges( list, nel, &ranges, &nr ); +// Find and return all ranges of consecutive numbers in @list. +// Each range is an [from,to] pair. ranges is a dynarray, which +// the caller must free. +// +void find_ranges( int *list, int nel, shortstr **ranges, int *nr ) +{ + shortstr *r = malloc( nel * sizeof(shortstr) ); + assert( r != NULL ); + *ranges = r; + *nr = 0; + + int from = -1; + int to = -1; + for( int i=0; i<nel; i++ ) + { + int item = list[i]; + if( from == -1 ) // start first range + { + from = item; + to = item; + if( debug ) + { + printf( "debug: item=%d, 1st range %d..%d\n", + item, from, to ); + } + } else if( item == to+1 ) // extend current range + { + to++; + if( debug ) + { + printf( "debug: item=%d, extend range %d..%d\n", + item, from, to ); + } + } else // finish one range, start next + { + if( to > from ) // len > 1: add range + { + shortstr s; + sprintf( s, "[%d,%d]", from, to ); + strcpy( r[(*nr)++], s ); + if( debug ) + { + printf( "debug: item=%d, add range %d..%d\n", + item, from, to ); + } + } + from = item; + to = item; + if( debug ) + { + printf( "debug: item=%d, new range %d..%d\n", + item, from, to ); + } + } + } + if( to > from ) // len > 1: add range + { + shortstr s; + sprintf( s, "[%d,%d]", from, to ); + strcpy( r[(*nr)++], s ); + if( debug ) + { + printf( "debug: add final range %d..%d\n", from, to ); + } + } +} + + +int main( int argc, char **argv ) +{ + int argno = process_flag_n_m_args( "range-list", argc, argv, + 1, 1000, "intlist" ); + + int nel; + int *list = parse_int_args( argc, argv, argno, &nel ); + + if( nel < 3 ) + { + fprintf( stderr, "range-list: need at least 3 ints in list\n" ); + exit(1); + } + + if( debug ) + { + printf( "debug: initial list: " ); + print_int_array( 60, nel, list, ',', stdout ); + putchar( '\n' ); + } + + shortstr *ranges; // dynamic array of strings + int nr = 0; + find_ranges( list, nel, &ranges, &nr ); + //printf( "nr=%d, ranges=", nr ); + for( int i=0; i<nr; i++ ) + { + if( i>0 ) printf( ", " ); + printf( "%s", ranges[i] ); + } + putchar( '\n' ); + + free( ranges ); + + free( list ); + + return 0; +} diff --git a/challenge-196/duncan-c-white/C/parseints.c b/challenge-196/duncan-c-white/C/parseints.c new file mode 100644 index 0000000000..0fb9985633 --- /dev/null +++ b/challenge-196/duncan-c-white/C/parseints.c @@ -0,0 +1,114 @@ +// Simple routine to parse one or more arguments, +// looking for individual +ints or comma-separated +// lists of +ints. +// + +#include <stdio.h> +#include <stdlib.h> +#include <stdbool.h> +#include <string.h> +#include <ctype.h> +#include <assert.h> + +#include "args.h" +#include "printarray.h" +#include "parseints.h" + +typedef struct +{ + int nel; // current number of elements + int maxel; // maximum number of elements allocated + int *list; // malloc()d list of integers +} intlist; + + +// +// intlist il.. then initialize il.. then: +// add_one( element, &il ); +// +static void add_one( int x, intlist *p ) +{ + if( p->nel > p->maxel ) + { + p->maxel += 128; + p->list = realloc( p->list, p->maxel ); + assert( p->list ); + } + #if 0 + if( debug ) + { + printf( "PIA: appending %d to result at " + "pos %d\n", x, p->nel ); + } + #endif + p->list[p->nel++] = x; +} + + +// +// intlist il.. then initialize il.. then: +// add_one_arg( argstr, &il ); +// +static void add_one_arg( char *argstr, intlist *p ) +{ + int x; + if( !check_unsigned_int(argstr,&x) ) + { + fprintf( stderr, "PIA: arg %s must be +int\n", argstr ); + exit(1); + } + add_one( x, p ); +} + + +// +// int nel; +// int *ilist = parse_int_args( argc, argv, argno, &nel ); +// process all arguments argv[argno..argc-1], extracting either +// single ints or comma-separated lists of ints from those arguments, +// accumulate all integers in a dynarray list, storing the total number +// of elements in nel. This list must be freed by the caller. +// Note that the list of elements used to be terminated by a -1 value, +// but I've commented this out from now on. +// +int *parse_int_args( int argc, char **argv, int argno, int *nel ) +{ + int *result = malloc( 128 * sizeof(int) ); + assert( result ); + intlist il = { 0, 128, result }; + + #if 0 + if( debug ) + { + printf( "PIA: parsing ints from args %d..%d\n", argno, argc-1 ); + } + #endif + for( int i=argno; i<argc; i++ ) + { + assert( strlen(argv[i]) < 1024 ); + char copy[1024]; + strcpy( copy, argv[i] ); + char *com; + char *s; + for( s=copy; (com = strchr(s,',')) != NULL; s=com+1 ) + { + *com = '\0'; + add_one_arg( s, &il ); + } + add_one_arg( s, &il ); + } + + //add_one( -1, &il ); + + #if 0 + if( debug ) + { + printf( "PIA: final list is " ); + print_int_array( 80, il.nel, il.list, ',', stdout ); + putchar( '\n' ); + } + #endif + + *nel = il.nel; + return il.list; +} diff --git a/challenge-196/duncan-c-white/C/parseints.h b/challenge-196/duncan-c-white/C/parseints.h new file mode 100644 index 0000000000..da5e145a86 --- /dev/null +++ b/challenge-196/duncan-c-white/C/parseints.h @@ -0,0 +1 @@ +extern int * parse_int_args( int argc, char ** argv, int argno, int * nel ); diff --git a/challenge-196/duncan-c-white/C/printarray.c b/challenge-196/duncan-c-white/C/printarray.c new file mode 100644 index 0000000000..ddee597df3 --- /dev/null +++ b/challenge-196/duncan-c-white/C/printarray.c @@ -0,0 +1,39 @@ +#include <stdio.h> +#include <string.h> + + +// print_int_array( maxw, nelements, results[], sep, outfile ); +// format results[0..nelements-1] as a <sep> separated +// list onto outfile with lines <= maxw chars long. +// produces a whole number of lines of output - without the trailing '\n' +void print_int_array( int maxw, int nel, int *results, char sep, FILE *out ) +{ + int linelen = 0; + for( int i=0; i<nel; i++ ) + { + char buf[100]; + sprintf( buf, "%d", results[i] ); + int len = strlen(buf); + if( linelen + len + 2 > maxw ) + { + fputc( '\n', out ); + linelen = 0; + } else if( i>0 ) + { + fputc( ' ', out ); + linelen++; + } + + linelen += len; + fprintf( out, "%s", buf ); + if( i<nel-1 ) + { + fputc( sep, out ); + linelen++; + } + } + //if( linelen>0 ) + //{ + // fputc( '\n', out ); + //} +} diff --git a/challenge-196/duncan-c-white/C/printarray.h b/challenge-196/duncan-c-white/C/printarray.h new file mode 100644 index 0000000000..40efb83277 --- /dev/null +++ b/challenge-196/duncan-c-white/C/printarray.h @@ -0,0 +1 @@ +extern void print_int_array( int maxw, int nel, int * results, char sep, FILE * out ); diff --git a/challenge-196/duncan-c-white/README b/challenge-196/duncan-c-white/README index 63318ee3fc..bce30687f2 100644 --- a/challenge-196/duncan-c-white/README +++ b/challenge-196/duncan-c-white/README @@ -1,50 +1,63 @@ -Task 1: Special Integers +Task 1: Pattern 132 -You are given a positive integer, $n > 0. +You are given a list of integers, @list. -Write a script to print the count of all special integers between 1 and $n: -An integer is special when all of its digits are unique. +Write a script to find out subsequence that respect Pattern 132. Return +empty array if none found. -Example 1: +Pattern 132 in a sequence (a[i], a[j], a[k]) such that i < j < k +and a[i] < a[k] < a[j]. -Input: $n = 15 -Output: 14 as except 11 all other integers between 1 and 15 are spcial. +Example 1 + +Input: @list = (3, 1, 4, 2) +Output: (1, 4, 2) respect the Pattern 132. + +Example 2 + +Input: @list = (1, 2, 3, 4) +Output: () since no subsequence can be found. + +Example 3 + +Input: @list = (1, 3, 2, 4, 6, 5) +Output: (1, 3, 2) if more than one subsequence found then return the first. -Example 2: +Example 4 -Input: $n = 35 -Output: 32 as except 11, 22, 33 all others are special. +Input: @list = (1, 3, 4, 2) +Output: (1, 3, 2) -MY NOTES: very easy; use a freq hash +MY NOTES: very easy; straightforward "non-clever" code. GUEST LANGUAGE: As a bonus, I also had a go at translating ch-1.pl into C (look in the C directory for the translation) -Task 2: Most Frequent Even +Task 2: Range List -You are given a list of numbers, @list. +You are given a sorted unique integer array, @array. -Write a script to find most frequent even numbers in the list. In case you -get more than one even numbers then return the smallest even integer. For -all other case, return -1. +Write a script to find all possible Number Range i.e [x, y] represent +range all integers from x and y (both inclusive). Each subsequence +must be of two or more contiguous integers. Example 1 -Input: @list = (1,1,2,6,2) -Output: 2 as there are only 2 even numbers 2 and 6 and of those 2 appears the most. +Input: @array = (1,3,4,5,7) +Output: [3,5] Example 2 -Input: @list = (1,3,5,7) -Output: -1 since no even numbers found in the list +Input: @array = (1,2,3,6,7,9) +Output: [1,3], [6,7] Example 3 -Input: @list = (6,4,4,6,1) -Output: 4 since there are only two even numbers 4 and 6. They both appears the equal number of times, so pick the smallest. +Input: @array = (0,1,2,4,5,6,8,9) +Output: [0,2], [4,6], [8,9] -MY NOTES: very easy; select even numbers; build a freq hash, sort by freqs.. +MY NOTES: simple enough state machine while we walk over the array in 1-pass. GUEST LANGUAGE: As a bonus, I also had a go at translating ch-2.pl into C (look in the C directory for the translation) diff --git a/challenge-196/duncan-c-white/perl/ch-1.pl b/challenge-196/duncan-c-white/perl/ch-1.pl new file mode 100755 index 0000000000..6d18bce65c --- /dev/null +++ b/challenge-196/duncan-c-white/perl/ch-1.pl @@ -0,0 +1,80 @@ +#!/usr/bin/perl +# +# Task 1: Pattern 132 +# +# You are given a list of integers, @list. +# +# Write a script to find out the first subsequence that respect Pattern 132. +# Return empty array if none found. +# +# Pattern 132 in a sequence (a[i], a[j], a[k]) such that i < j < k +# and a[i] < a[k] < a[j]. +# +# Example 1 +# +# Input: @list = (3, 1, 4, 2) +# Output: (1, 4, 2) respect the Pattern 132. +# +# Example 2 +# +# Input: @list = (1, 2, 3, 4) +# Output: () since no subsequence can be found. +# +# Example 3 +# +# Input: @list = (1, 3, 2, 4, 6, 5) +# Output: (1, 3, 2) if more than one subsequence found then return the first. +# +# Example 4 +# +# Input: @list = (1, 3, 4, 2) +# Output: (1, 3, 2) +# +# MY NOTES: very easy; straightforward "non-clever" code. +# +# GUEST LANGUAGE: As a bonus, I also had a go at translating ch-1.pl +# into C (look in the C directory for the translation) +# + +use strict; +use warnings; +use feature 'say'; +use Getopt::Long; +use Data::Dumper; + +my $debug=0; +die "Usage: pattern-132 [--debug] intlist\n" + unless GetOptions( "debug"=>\$debug ) && @ARGV>0; + +=pod + +=head2 my @sol = find_pat_132( @a ); + +Find and return the first subsequence of @a that matches the +132 rules above, or () if none. + +=cut +sub find_pat_132 +{ + my( @a ) = @_; + for( my $i=0; $i<@a-2; $i++ ) + { + for( my $j=$i+1; $j<@a-1; $j++ ) + { + for( my $k=$j+1; $k<@a; $k++ ) + { + return @a[$i,$j,$k] if + $a[$i] < $a[$k] < $a[$j]; + } + } + } + return (); +} + + +my @list = split( /,/, join(',',@ARGV) ); + +die "pattern-132: need at least 3 ints in list\n" unless @list>2; + +my @sol = find_pat_132( @list ); +say '( '. join( ', ', @sol ) . ' )'; diff --git a/challenge-196/duncan-c-white/perl/ch-2.pl b/challenge-196/duncan-c-white/perl/ch-2.pl new file mode 100755 index 0000000000..4616846e12 --- /dev/null +++ b/challenge-196/duncan-c-white/perl/ch-2.pl @@ -0,0 +1,99 @@ +#!/usr/bin/perl +# +# Task 2: Range List +# +# You are given a sorted unique integer array, @array. +# +# Write a script to find all possible Number Range i.e [x, y] represent +# range all integers from x and y (both inclusive). Each subsequence +# must be of two or more contiguous integers. +# +# Example 1 +# +# Input: @array = (1,3,4,5,7) +# Output: [3,5] +# +# Example 2 +# +# Input: @array = (1,2,3,6,7,9) +# Output: [1,3], [6,7] +# +# Example 3 +# +# Input: @array = (0,1,2,4,5,6,8,9) +# Output: [0,2], [4,6], [8,9] +# +# MY NOTES: simple enough state machine while we walk over the array in 1-pass. +# +# GUEST LANGUAGE: As a bonus, I also had a go at translating ch-2.pl +# into C (look in the C directory for the translation) +# + +use strict; +use warnings; +use feature 'say'; +use Getopt::Long; +use Function::Parameters; +use Data::Dumper; + + +my $debug=0; +die "Usage: range-list [--debug] list(int)\n" + unless GetOptions( "debug"=>\$debug ) && @ARGV>0; + +=pod + +=head2 my @range = find_ranges( @list ); + +Find and return all ranges of consecutive numbers in @list. +Each range is an [from,to] pair. + +=cut +fun find_ranges( @list ) +{ + my @result; + my $from = -1; + my $to = -1; + foreach my $item (@list) + { + if( $from == -1 ) # start first range + { + $from = $item; + $to = $item; + say "debug: item=$item, 1st range $from..$to" if $debug; + } elsif( $item == $to+1 ) # extend current range + { + $to++; + say "debug: item=$item, extend range $from..$to" + if $debug; + } else # finish one range, start next + { + if( $to > $from ) # len > 1: add range + { + push @result, [$from,$to]; + say "debug: item=$item, add range $from..$to" + if $debug; + } + $from = $item; + $to = $item; + say "debug: item=$item, new range $from..$to" if $debug; + } + } + if( $to > $from ) # len > 1: add range + { + push @result, [$from,$to]; + say "debug: add final range $from..$to" if $debug; + } + return @result; +} + + + + +my @list = split( /,/, join( ',', @ARGV ) ); + +die "range-list: need at least 3 ints in list\n" unless @list>2; + +my @range = find_ranges( @list ); +#die Dumper( \@range ); +say join( ', ', map { "[$_->[0],$_->[1]]" } @range ); |