#include

#include

#include "pattern$\_$finder.h$"$

#define MAX$\_$LENGTH $1000$

int is$\_$singleton$($const char $*$str$)\{$

$//$ Implementation for is$\_$singleton

char first$\_$char $=$ str$[0]$;

for $($int i $=1$; str$[$i$]!=\text{'}\backslash 0\text{'}$; i$++)\{$

if $($str$[$i$]!=$ first$\_$char$)\{$

return $0$; $//$ Not a singleton

$\}$

$\}$

return $1$; $//$ Singleton

$\}$

int is$\_$arithmetic$($const char $*$str$)\{$

$//$ Implementation for is$\_$arithmetic

for $($int i $=1$; str$[$i$]!=\text{'}\backslash 0\text{'}$; i$++)\{$

if $($str$[$i$]!=$ str$[$i $-1]+1)\{$

return $0$; $//$ Not arithmetic

$\}$

$\}$

return $1$; $//$ Arithmetic

$\}$

int is$\_$reverse$\_$arithmetic$($const char $*$str$)\{$

$//$ Implementation for is$\_$reverse$\_$arithmetic

for $($int i $=1$; str$[$i$]!=\text{'}\backslash 0\text{'}$; i$++)\{$

if $($str$[$i$]!=$ str$[$i $-1]-1)\{$

return $0$; $//$ Not reverse arithmetic

$\}$

$\}$

return $1$; $//$ Reverse arithmetic

$\}$

int is$\_$balanced$\_$tripartite$($const char $*$str$)\{$

$//$ Implementation for is$\_$balanced$\_$tripartite

int length $=$ strlen$($str$)$;

if $($length $\%3!=0)\{$

return $0$; $//$ Not divisible by $3$

$\}$

int part$\_$length $=$ length $/3$;

for $($int i $=$ part$\_$length; i $$ length; i$++)\{$

if $($str$[$i$]!=$ str$[$i $-$ part$\_$length$])\{$

return $0$; $//$ Not balanced tripartite

$\}$

$\}$

return $1$; $//$ Balanced tripartite

$\}$

int is$\_$balanced$\_$bipartite$($const char $*$str$)\{$

$//$ Implementation for is$\_$balanced$\_$bipartite

int length $=$ strlen$($str$)$;

if $($length $\%2!=0)\{$

return $0$; $//$ Not divisible by $2$

$\}$

int half$\_$length $=$ length $/2$;

for $($int i $=$ half$\_$length; i $$ length; i$++)\{$

if $($str$[$i$]!=$ str$[$i $-$ half$\_$length$])\{$

return $0$; $//$ Not balanced bipartite

$\}$

$\}$

return $1$; $//$ Balanced bipartite

$\}$

int is$\_$palindrome$($const char $*$str$)\{$

$//$ Implementation for is$\_$palindrome

int length $=$ strlen$($str$)$;

for $($int i $=0$; i $$ length $/2$; i$++)\{$

if $($str$[$i$]!=$ str$[$length $-1-$ i$])\{$

return $0$; $//$ Not a palindrome

$\}$

$\}$

return $1$; $//$ Palindrome

$\}$

int main$()\{$

char line$[$MAX$\_$LENGTH$]$;

while $(1)\{$

if $($fgets$($line$,$ MAX$\_$LENGTH, stdin$)==$ NULL$)\{$

break; $//$ End of input

$\}$

$//$ Remove the newline character

line$[$strcspn$($line$,"$

$")]=\text{'}\backslash 0\text{'}$;

int found $=0$;

if $($is$\_$singleton$($line$))\{$

printf$("$singleton

$")$;

found $=1$;

$\}$

if $($is$\_$arithmetic$($line$))\{$

printf$("$arithmetic

$")$;

found $=1$;

$\}$

if $($is$\_$reverse$\_$arithmetic$($line$))\{$

printf$("$reverse arithmetic

$")$;

found $=1$;

$\}$

if $($is$\_$balanced$\_$tripartite$($line$))\{$

printf$("$balanced tripartite

$")$;

found $=1$;

$\}$

if $($is$\_$balanced$\_$bipartite$($line$))\{$

printf$("$balanced bipartite

$")$;

found $=1$;

$\}$

if $($is$\_$palindrome$($line$))\{$

printf$("$palindrome

$")$;

found $=1$;

$\}$

if $(!$found$)\{$

printf$("$

$")$;

$\}$

$\}$

return $0$;

$\}$

#ifndef PATTERN$\_$FINDER$\_$H

#define PATTERN$\_$FINDER$\_$H

int is$\_$singleton$($const char $*$str$)$;

int is$\_$arithmetic$($const char $*$str$)$;

int is$\_$reverse$\_$arithmetic$($const char $*$str$)$;

int is$\_$balanced$\_$tripartite$($const char $*$str$)$;

int is$\_$balanced$\_$bipartite$($const char $*$str$)$;

int is$\_$palindrome$($const char $*$str$)$;

#endif $//$ PATTERN$\_$FINDER$\_$H

i need the make file of the code. and any erros fixed.Programming Assignment $1$

Knight Foundation School of Computing and Information Sciences

In this assignment, you are asked to implement a program that recognizes interesting

patterns for any given string. In an infinite loop, the program receives a single line from

standard input $($you may use fgets$($line$,1000,$ stdin$)$ to receive such line where line is a char

array of length $1000).$ The program must be interested in finding one or more of the following

special patterns in the input string:

I. Singleton: A singleton string is made of only one letter. Examples: mmmmm$,$ qqqqqqq$,$

rr$,$ s$,$ yyy

II$.$ Arithmetic: A string made of subsequent alphabetical letters that appear in the alpha$-$

betical order. Examples: bcdef, pqrstuvwx, jk$,$ y

III. Reverse Arithmetic: A string made of subsequent alphabetical letters that appear

in the reverse alphabetical order. Example: fedcb, xwvutsrqp, kj$,$ y

IV$.$ Balanced Tripartite: A string made of three identical parts. Example: busbusbus,

laptoplaptoplaptop, zzz

V$.$ Balanced Bipartite: A string made of two identical halves. Examples: ticktick,

hophop, tantan$,$ nocknock, nn

VI$.$ Palindrome: A palindrome reads the same backward as forward. Examples: abcba,

bob, $g$

Please note that the above list is ranked in the decreasing order of their rarity. You

program prints out the list of all patterns $($that can be found for each input string$)$ followed

by a new line. Then, it asks for another line from input stream in a repetitive fashion. If no

pattern is found for an input string, the program prints a new line only.