int main(){
char str[]="abbbbbbbbbbcccaabbccaa";
printf("Original String %s\n",str);
remove_duplicate(str);
printf("Pruned String %s",str);
return 0;}
int nfa2dfa(int start,int end)
{
int j,t,c,i,k,count,arr[10],name,l;
for(i=start;i<=end;i++)
{
for(j=0;j<=max_inp;j++)
{
c=0;t=0;
while(Fa[i][j][t]>=0)
{
t++;
c++;
}
if(c>1)
{
if(check(i,j,c,&name)==0)
{
for(k=0;k<c;k++)
{
new_state[stat][k]=Fa[i][j][k];
for(l=0;states[1][l]!=-1;l++)
if(new_state[stat][k] == states[1][l]&& !search(stat))
states[1][no_stat++]=stat;
}
for(t=0;t<=max_inp;t++)
{
count=0;
for(k=0;k<10;k++)
arr[k]=-1;
trans(i,j,t,c,&count,arr);
checkcon(arr,&count);
sort(arr,count);
remove_duplicate(arr,&count);
for(k=0;k<count;k++)
Fa[stat][t][k]=arr[k];
}
Fa[i][j][0]=stat++;
for(t=1;t<c;t++)
Fa[i][j][t]=-1;
}
else
{
Fa[i][j][0]=name ;
for(t=1;t<c;t++)
Fa[i][j][t]=-1;
}
}//if(c>1) wala khatm hua
}
}
return 0;
}
int main(int argc,char* argv[]){
//int start = atoi(argv[1]);
//string str(argv[1]);
//string weekday(argv[2]);
//float num = atof(argv[1]);
int x[] = {1, 1, 3, 3, 3, 5, 5, 5, 9, 9, 9, 9};
int len = sizeof(x)/sizeof(x[0]);
vector<int> nums = getVector(x,len);
remove_duplicate(nums);
return 0;
}
std::vector<xts::uri> fetch_image::chapter_getter::fetch_chapter_uri_all() const
{
std::size_t image_index = 0;
std::size_t size = _image_token.values.size();
std::size_t batch_success_count = 1;
std::string partial_url = source_token::remplace_token(_db.input.sources[_source_index], _number_token, _number_index);
std::vector< xts::uri > image_uris;
while (image_index < size && batch_success_count > 0)
{
std::vector< std::future< std::vector< xts::uri > > > image_uris_fetched;
for (std::size_t i = 0; i < MAX_ERROR_ON_CHAPTER && image_index < size; ++i)
{
image_uris_fetched.emplace_back(std::async(
#ifdef _DEBUG
std::launch::deferred,
#endif
&chapter_getter::fetch_chapter_uri, this, astd::string_view(partial_url), image_index));
++image_index;
}
batch_success_count = 0;
for (auto& image_uri_fetched : image_uris_fetched)
{
auto image_uri = image_uri_fetched.get();
if (image_uri.size())
{
batch_success_count++;
image_uris.insert(image_uris.end(), image_uri.begin(), image_uri.end());
}
}
}
image_uris = remove_duplicate(image_uris);
return image_uris;
}
/*
* _bt_mergeload - Merge two streams of index tuples into new index files.
*/
static void
_bt_mergeload(Spooler *self, BTWriteState *wstate, BTSpool *btspool, BTReader *btspool2, Relation heapRel)
{
BTPageState *state = NULL;
IndexTuple itup,
itup2;
bool should_free = false;
TupleDesc tupdes = RelationGetDescr(wstate->index);
int keysz = RelationGetNumberOfAttributes(wstate->index);
ScanKey indexScanKey;
ON_DUPLICATE on_duplicate = self->on_duplicate;
Assert(btspool != NULL);
/* the preparation of merge */
itup = BTSpoolGetNextItem(btspool, NULL, &should_free);
itup2 = BTReaderGetNextItem(btspool2);
indexScanKey = _bt_mkscankey_nodata(wstate->index);
for (;;)
{
bool load1 = true; /* load BTSpool next ? */
bool hasnull;
int32 compare;
if (self->dup_old + self->dup_new > self->max_dup_errors)
ereport(ERROR,
(errcode(ERRCODE_INTERNAL_ERROR),
errmsg("Maximum duplicate error count exceeded")));
if (itup2 == NULL)
{
if (itup == NULL)
break;
}
else if (itup != NULL)
{
compare = compare_indextuple(itup, itup2, indexScanKey,
keysz, tupdes, &hasnull);
if (compare == 0 && !hasnull && btspool->isunique)
{
ItemPointerData t_tid2;
/*
* t_tid is update by heap_is_visible(), because use it for an
* index, t_tid backup
*/
ItemPointerCopy(&itup2->t_tid, &t_tid2);
/* The tuple pointed by the old index should not be visible. */
if (!heap_is_visible(heapRel, &itup->t_tid))
{
itup = BTSpoolGetNextItem(btspool, itup, &should_free);
}
else if (!heap_is_visible(heapRel, &itup2->t_tid))
{
itup2 = BTReaderGetNextItem(btspool2);
}
else
{
if (on_duplicate == ON_DUPLICATE_KEEP_NEW)
{
self->dup_old++;
remove_duplicate(self, heapRel, itup2,
RelationGetRelationName(wstate->index));
itup2 = BTReaderGetNextItem(btspool2);
}
else
{
ItemPointerCopy(&t_tid2, &itup2->t_tid);
self->dup_new++;
remove_duplicate(self, heapRel, itup,
RelationGetRelationName(wstate->index));
itup = BTSpoolGetNextItem(btspool, itup, &should_free);
}
}
continue;
}
else if (compare > 0)
load1 = false;
}
else
load1 = false;
BULKLOAD_PROFILE(&prof_merge_unique);
/* When we see first tuple, create first index page */
if (state == NULL)
state = _bt_pagestate(wstate, 0);
if (load1)
{
IndexTuple next_itup = NULL;
bool next_should_free = false;
for (;;)
{
/* get next item */
next_itup = BTSpoolGetNextItem(btspool, next_itup,
&next_should_free);
if (!btspool->isunique || next_itup == NULL)
break;
compare = compare_indextuple(itup, next_itup, indexScanKey,
keysz, tupdes, &hasnull);
if (compare < 0 || hasnull)
break;
if (compare > 0)
{
/* shouldn't happen */
elog(ERROR, "faild in tuplesort_performsort");
}
/*
* If tupple is deleted by other unique indexes, not visible
*/
if (!heap_is_visible(heapRel, &next_itup->t_tid))
{
continue;
}
if (!heap_is_visible(heapRel, &itup->t_tid))
{
if (should_free)
pfree(itup);
itup = next_itup;
should_free = next_should_free;
next_should_free = false;
continue;
}
/* not unique between input files */
self->dup_new++;
remove_duplicate(self, heapRel, next_itup,
RelationGetRelationName(wstate->index));
if (self->dup_old + self->dup_new > self->max_dup_errors)
ereport(ERROR,
(errcode(ERRCODE_INTERNAL_ERROR),
errmsg("Maximum duplicate error count exceeded")));
}
_bt_buildadd(wstate, state, itup);
if (should_free)
pfree(itup);
itup = next_itup;
should_free = next_should_free;
}
else
{
_bt_buildadd(wstate, state, itup2);
itup2 = BTReaderGetNextItem(btspool2);
}
BULKLOAD_PROFILE(&prof_merge_insert);
}
_bt_freeskey(indexScanKey);
/* Close down final pages and write the metapage */
_bt_uppershutdown(wstate, state);
/*
* If the index isn't temp, we must fsync it down to disk before it's safe
* to commit the transaction. (For a temp index we don't care since the
* index will be uninteresting after a crash anyway.)
*
* It's obvious that we must do this when not WAL-logging the build. It's
* less obvious that we have to do it even if we did WAL-log the index
* pages. The reason is that since we're building outside shared buffers,
* a CHECKPOINT occurring during the build has no way to flush the
* previously written data to disk (indeed it won't know the index even
* exists). A crash later on would replay WAL from the checkpoint,
* therefore it wouldn't replay our earlier WAL entries. If we do not
* fsync those pages here, they might still not be on disk when the crash
* occurs.
*/
if (!RELATION_IS_LOCAL(wstate->index))
{
RelationOpenSmgr(wstate->index);
smgrimmedsync(wstate->index->rd_smgr, MAIN_FORKNUM);
}
BULKLOAD_PROFILE(&prof_merge_term);
}
int main(int argc,char *argv[]){
if( argc != 2){ //Check to see if enough arguments were given
err_exit("ERROR: You did not give 1 arguments.");
}
int kid_count = atoi(argv[1]); //stores first argument as number of children to create
char* token = NULL;
int traffic_cop = 0;
int length;
int status;
pid_t* sort_id = NULL;
pid_t supp_id;
int** pipe_farm_ps = NULL; // fds for pipes for parent to sorts
int** pipe_farm_sr = NULL; // fds for pipes for sorts to suppressor
FILE** pp_ps = NULL; //pipe pointers for parent to sorts
FILE** pp_sr = NULL; //pipe pointers for sorts to suppressor
//Lock memory for pipes, pointers, and pids.
sort_id = (pid_t*) malloc(sizeof(pid_t) * kid_count);
pipe_farm_ps = (int**) malloc(sizeof(int*) * kid_count);
pipe_farm_sr = (int**) malloc(sizeof(int*) * kid_count);
pp_ps = (FILE**) malloc(sizeof(FILE*) * kid_count);
pp_sr = (FILE**) malloc(sizeof(FILE*) * kid_count);
token = (char*) malloc(sizeof(char) * MAX_TOKEN);
for(int i = 0; i < kid_count; i++){
pipe_farm_ps[i] = malloc(sizeof(int) * 2);
pipe_farm_sr[i] = malloc(sizeof(int) * 2);
if( pipe(pipe_farm_ps[i]) == -1 ) { //create pipes in pipe_farm_ps
err_exit("ERROR: Problem creating pipe ps");
}
if((pp_ps[i] = fdopen(pipe_farm_ps[i][1],"w")) == NULL){
err_exit("ERROR: Problem making pointer to pfdps.");
}
if( pipe(pipe_farm_sr[i]) == -1 ) { //create pipes in pipe_farm_sr
err_exit("ERROR: Problem creating pipe sr");
}
if((pp_sr[i] = fdopen(pipe_farm_ps[i][1],"w")) == NULL){
err_exit("ERROR: Problem making pointer to pfdsr.");
}
}
for(int i = 0; i < kid_count; i++){ //Sorting kids
if((sort_id[i] = fork()) == 0){
for(int k = 0; k < kid_count; k++){
if(i == k){
if(close(pipe_farm_ps[i][1]) != 0){
err_exit("ERROR: closing write end of pipe in child\n");
}
if(close(pipe_farm_sr[i][0]) != 0){
err_exit("ERROR: closing read end of pipe in child\n");
}
dup2(pipe_farm_ps[i][0], 0);
dup2(pipe_farm_sr[i][1], 1);
}
else{
if(close(pipe_farm_ps[k][1]) != 0){
err_exit("ERROR: closing write end of pipe in child\n");
}
if(close(pipe_farm_ps[k][0]) != 0){
err_exit("ERROR: closing read end of pipe in child\n");
}
if(close(pipe_farm_sr[k][1]) != 0){
err_exit("ERROR: closing write end of pipe in child\n");
}
if(close(pipe_farm_sr[k][0]) != 0){
err_exit("ERROR: closing read end of pipe in child\n");
}
}
}
execl("/usr/bin/sort","sort",NULL); // make child into sort();
_exit(1);
}
} // END Sorting kids
fflush(stdout);
if((supp_id = fork()) == 0){ //Suppresor kid
int sorters = kid_count;
int* valid_sources = NULL;
int token_count = 0;
char* last_word = NULL;
char** words = NULL;
valid_sources = init_reader_table(sorters);
words = (char**) malloc(sizeof(char*) * MAX_TOKEN);
last_word = (char*) malloc(sizeof(char) * WORD_SIZE);
printf("LOLZ\n");
printf("%d%s\n",valid_sources[2],"Suppressor Check 1: \n");
for(int i = 0; i < kid_count; i++){
if(close(pipe_farm_ps[i][1]) != 0){
err_exit("ERROR: closing write end of pipe in child\n");
}
if(close(pipe_farm_ps[i][0]) != 0){
err_exit("ERROR: closing read end of pipe in child\n");
}
if(close(pipe_farm_sr[i][1]) != 0){
err_exit("ERROR: closing write end of pipe in child\n");
}
if((pp_sr[i] = fdopen(pipe_farm_sr[i][0], "r")) == NULL){
err_exit("ERROR:creating file pointer from file descriptor suppressor\n");
}
}
printf("%s \n", "Suppressor Check 2: ");
while(sorters > 0){
printf("%s \n", "Suppressor Check 3a: ");
for(int i = 0; i < sorters; i++){
traffic_cop = valid_sources[i];
printf("%d",traffic_cop);
printf("%s \n", "Suppressor Check 3b: ");
if(fgets(token, WORD_SIZE , pp_sr[traffic_cop]) != NULL){
printf("%s \n", token);
if((length = strlen(token)) <= 2){
printf("%s \n","I AM HERE 1");
continue;
}
printf("%s \n", "Suppressor Check 3c: ");
if(token_count < MAX_TOKEN){
words[token_count] = (char*) malloc(sizeof(char) * (length + 1 ));
strcpy(words[token_count],token);
token_count++;
insert_sort(words, token_count);
}
else{
token_count--;
if(strcmp(last_word, words[token_count]) != 0){
strcpy(last_word, words[token_count]);
printf("%s", words[token_count]);
}
token_count = remove_duplicate(words, token_count, words[token_count]);
length = strlen(words[token_count]);
strcpy(words[token_count], token);
token_count++;
insert_sort(words, token_count);
}
}
else{
printf("Kid dying: %d\n",traffic_cop);
sorters--;
remove_sorter(valid_sources,sorters,traffic_cop);
}
}
}
printf("%s \n", "Suppressor Check 4: ");
free(words);
words = NULL;
for(int i = 0; i < kid_count; i++){
if(close(pipe_farm_sr[i][0]) != 0){
err_exit("ERROR: closing pipe in suppressor");
}
free(pipe_farm_sr[i]);
pipe_farm_sr[i] = NULL;
free(pipe_farm_ps[i]);
pipe_farm_ps[i] = NULL;
}
printf("%d",token_count);
free(token);
token = NULL;
free(last_word);
last_word = NULL;
free(pp_sr);
pp_sr = NULL;
free(pp_ps);
pp_ps = NULL;
printf("Close Kid\n");
_exit(EXIT_SUCCESS);
} //END Supressor kid
fflush(stdout);
//Finish parent instructions
while(fscanf(stdin,"%s",token) != EOF) {
length = strlen(token);
add_cr(token,length);
lower_case(token, length);
fputs(token, pp_ps[traffic_cop]);
printf("%s\n",token);
if(traffic_cop == (kid_count - 1)){ // if we used last pipe, wrap around
traffic_cop = -1;
}
traffic_cop++;
printf("%d",traffic_cop);
}
fflush(stdout);
for(int i = 0; i < kid_count; i++){
if(close(pipe_farm_ps[i][1]) != 0){
err_exit("Error closing write end of pipe in parent\n");
}
if(close(pipe_farm_ps[i][0]) != 0){
err_exit("Error closing read end of pipe in parent\n");
}
free(pipe_farm_ps[i]);
free(pipe_farm_sr[i]);
}
while (waitpid(-1,&status,WNOHANG) > 0){
printf("Child exited");
}
free(token);
token = NULL;
free(pp_ps);
pp_ps = NULL;
free(pipe_farm_ps);
free(pipe_farm_sr);
exit(EXIT_SUCCESS);
}// END main
int main()
{
char str[] = "ababababababab";
remove_duplicate(str);
char *pt;
}
