#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int are_cyclical(int number_of_arguments,...);
int chk(int value, int *array, int index);             // Considering only the numbers
int foo(char *s1,char *s2);                            // with 4 digits,  the smallest
int main()                                             // (triangle) has to be greater
{                                                      // than 1010
      int n3,n4,n5,n6,n7,n8,P_x,sum=0;                 //        P_x(n)>=1010
      char triangle[5],square[5],pentagonal[5],hexagonal[5],heptagonal[5],octagonal[5];

      for(n3=141;n3>=45;n3--)                                     // n(n+1)/2<10000
      {
            P_x=n3*(n3+1)/2;
            sprintf(triangle,"%i",P_x);
            for(n4=99;n4>=32;n4--)                                // n*n<10000
            {
                  P_x=n4*n4;
                  sprintf(square,"%i",P_x);
                  for(n5=27;n5<82;n5++)                           // n*(3*n-1)/2<10000
                  {
                        P_x=n5*(3*n5-1)/2;
                        sprintf(pentagonal,"%i",P_x);
                        for(n6=71;n6>=23;n6--)                    // n*(2*n-1)<10000
                        {
                              P_x=n6*(2*n6-1);
                              sprintf(hexagonal,"%i",P_x);
                              for(n7=21;n7<64;n7++)               // n*(5*n-3)/2<10000
                              {
                                    P_x=n7*(5*n7-3)/2;
                                    sprintf(heptagonal,"%i",P_x);
                                    for(n8=19;n8<59;n8++)         // n*(3*n−2)<10000
                                    {
                                          P_x=n8*(3*n8-2);
                                          sprintf(octagonal,"%i",P_x);
                                          if(are_cyclical(  6,
                                                            triangle,
                                                            square,
                                                            pentagonal,
                                                            hexagonal,
                                                            heptagonal,
                                                            octagonal))
                                          {
                                                sum+=atoi(triangle);
                                                sum+=atoi(square);
                                                sum+=atoi(pentagonal);
                                                sum+=atoi(hexagonal);
                                                sum+=atoi(heptagonal);
                                                sum+=atoi(octagonal);
                                                printf("\n\t%i\n\n",sum);
                                                return 0;
                                          }
                                    }
                              }
                        }
                  }
            }
      }
      return 1;
}
int are_cyclical(int number_of_arguments,...)
{
      int index1=0,index2,order[number_of_arguments];
      char **strings;
      va_list argptr;
      strings=malloc(number_of_arguments*sizeof(char *));

      for(;index1<number_of_arguments;index1++)
            order[index1]=0;

      va_start(argptr,number_of_arguments);
      for(index1=0;index1<number_of_arguments;index1++)
      {
            index2=index1;
            strings[index1]=malloc(strlen(va_arg(argptr,char *))*sizeof(char));            
            va_end(argptr);
            va_start(argptr,number_of_arguments);
            while(index2-->0)
                  va_arg(argptr,char *);
            strcpy(strings[index1],(char *)va_arg(argptr,char *));
      }
      for(index1=0;index1<number_of_arguments;index1++)
      {
            for(index2=0;index2<number_of_arguments;index2++)
                  if(   index1!=index2 && order[index2]!=index1+1 &&
                        foo(strings[index1],strings[index2])==2 &&
                        chk(index2+1,order,number_of_arguments))
                        order[index1]=index2+1;
            if(order[index1]==0)
            {
                  for(index1=0;index1<number_of_arguments;index1++)
                        free(strings[index1]);
                  free(strings);
                  return 0;
            }
      }
      for(index1=0;index1<number_of_arguments;index1++)
            free(strings[index1]);
      free(strings);
      return 1;
}
int chk(int value, int *array, int index)
{
      while(index-->0)
      {
            if(value==array[index])
                  return 0;
      }
      return 1;
}
int foo(char *s1,char *s2)
{
      char *last_match,*restart=s2;
      int identical_characters=0;
      
      while(*s1!='\0')
      {
            if(*s1==*s2)
            {
                  if(identical_characters==0)
                        last_match=s1;
                  identical_characters++;
                  s2++;
            }
            else
            {
                  if(identical_characters!=0)
                        s1=last_match;
                  identical_characters=0;
                  s2=restart;
            }
            s1++;
      }
      return identical_characters;
}