Generate all the possible substrings using the characters of a given string. 

#import <Foundation/Foundation.h>
@interface PrintStrings: NSObject{
   
}
@end
@implementation PrintStrings{
   
}
-(void)printStr:(NSString*)str index:(int)start{
    int length = [str length];
    if(start>length)
        return;
    for(int i = 0 ; i < length ; i++){
        if(i>0)
        printf("%s ",[[str substringToIndex:i] UTF8String]);
     }
     printf("%s ",[str UTF8String]);
    if(length>1)
    [self printStr:[str substringWithRange:NSMakeRange(start+1,length-1)] index:start];
 
 }
@end
int main(int argc, const char * argv[]){
     
    char a[] = "";
    scanf("%s",a);
    NSString *str = [NSString stringWithFormat:@"%s",a];
    PrintStrings *obj = [[PrintStrings alloc]init];
    [obj printStr:str index:0];
   
    return 0;
}

Given a string as input, print all its permutations in sorted order.

https://www.hackerrank.com/contests/crescent-practice-3rd-years/challenges/permute-the-string

//Enter your code here. Read input from STDIN. Print output to STDOUT

#import <Foundation/Foundation.h>
@interface Generator : NSObject{
}
-(void)permutateString:(NSString*)str startIndex:(int)start endIndex:(int)end;
-(NSString*)swap:(NSString*)str startIndex:(int)start endIndex:(int)end;
@end
@implementation Generator {
}
 
    -(void)permutateString:(NSString*)str startIndex:(int)start endIndex:(int)end{
        int i ;
        if(start == end){
           printf("%s\n",[str UTF8String]);
         }
        else{
            for( i = start ; i<= end; i++){
               str= [self swap:str startIndex:start endIndex:i];
                [self permutateString:str startIndex:start+1 endIndex:end];
               str=  [self swap:str startIndex:start endIndex:i];
              }
        }
    }
    -(NSString*)swap:(NSString*)str startIndex:(int)start endIndex:(int)end{
        NSMutableArray *array = [NSMutableArray array];
        for (int i = 0; i < [str length]; i++) {
        NSString *temp = str;
        NSString *ch = [temp substringWithRange:NSMakeRange(i, 1)];
        [array addObject:ch];
        }
        NSString *str1  = [array objectAtIndex:start];
        NSString *str2  = [array objectAtIndex:end];
        [array replaceObjectAtIndex:start withObject:str2];
        [array replaceObjectAtIndex:end withObject:str1];
         
        return [array componentsJoinedByString:@""];
 }
@end  

int main(){
    char str[] = "";
    scanf("%s",str);
    NSString *finalStr = [NSString stringWithFormat:@"%s",str];
    int length = [finalStr length]-1 ;
    Generator *obj = [[Generator alloc]init];
    [obj permutateString:finalStr startIndex:0 endIndex:length];
    return 0;
}

https://www.hackerrank.com/challenges/ctci-making-anagrams


http://www.devinline.com/2016/08/minimum-number-of-character-deletions.html





#import <Foundation/Foundation.h>
@interface FindAnagram:NSObject{
   
}
-(int) characterToDelete:(NSString*)str1 second:(NSString*)str2;
@end
@implementation FindAnagram{
}
    -(int) characterToDelete:(NSString*)str1 second:(NSString*)str2{
        int count = 0;
        NSMutableDictionary *dict = [[NSMutableDictionary alloc] init];
        int length = str2.length;
        for(int i = 0 ; i < length ; i++){
            NSString *key = [str2 substringWithRange:NSMakeRange(i,1)];
            if([dict valueForKey:key] == nil){
                [dict setObject:[NSNumber numberWithInt:1]  forKey:key];
            }
            else{
                int value = [[dict valueForKey:key] intValue];
                //[dict setObjectForKey:[NSNumber numberWithInt:value+1]];
                 [dict setObject:[NSNumber numberWithInt:value+1]  forKey:key];
            }
        }
       
         for(int i = 0 ; i < str1.length ; i++){
            NSString *key = [str1 substringWithRange:NSMakeRange(i,1)];
           
            if([dict valueForKey:key] != nil){
                int value = [[dict valueForKey:key] intValue];
                if(value!=0){
                    // [dict setObjectForKey:[NSNumber numberWithInt:value-1]];
                     [dict setObject:[NSNumber numberWithInt:value-1]  forKey:key];
                   
                }
                else{
                    count++;
                }
             
            }
            else{
              count++;
            }
        }
        int temp = 0;
        NSArray *arr = [dict allKeys];
       // NSLog(@"%@",dict);
        for(int i = 0 ;i < arr.count; i++){
             int value = [[dict valueForKey:[arr objectAtIndex:i]] intValue];
            temp = temp+ value;
        }
       
       
        return temp+count;
    }

@end
int main(int argc, const char * argv[]){
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    NSString* a;
    char* a_temp = (char *)malloc(512000 * sizeof(char));
    scanf("%s",a_temp);
    a = [NSString stringWithFormat:@"%s", a_temp];
    NSString* b;
    char* b_temp = (char *)malloc(512000 * sizeof(char));
    scanf("%s",b_temp);
    b = [NSString stringWithFormat:@"%s", b_temp];
    FindAnagram *obj = [[FindAnagram alloc] init];
    int result = [obj characterToDelete:a second:b];
    printf("%i",result);
    [pool drain];
    return 0;
}

check-for-balanced-parentheses-in-an-expression

#import <Foundation/Foundation.h>

@interface Stack:NSObject{

    

}

-(void)push:(NSString *)str;

-(void)pop;

@end

@implementation Stack{

    NSMutableArray *stackArray;

}

-(id)initWithArray:(NSMutableArray*)arr{

    self = [super init];

    if(self){

        stackArray = arr;

    }

    return self;

}

-(id)init{

    return [self initWithArray:[[NSMutableArray alloc] init]];

}

-(BOOL)isEmpty:(NSMutableArray*)arr{

    if(arr.count){

       return NO; 

    }

    else{

      return YES;  

    }

}

-(void)push:(NSString *)str{

    [stackArray addObject:str];

}

-(void)pop{

    

    [stackArray removeLastObject];

}

-(BOOL)isValidSequence:(NSString*)sequence{

    NSDictionary *dict = [[NSDictionary alloc]initWithObjectsAndKeys:@")",@"(",@"}",@"{",@"]",@"[",nil];

    NSArray *arrValues = [dict allValues];

    NSArray *arrKeys = [dict allKeys];

    int length = [sequence length];

    int index = 0;

    while(length>0){

       NSString *str  = [sequence substringWithRange:NSMakeRange(index,1)];

       // NSLog(@"arrk %@\n", arrKeys);

      // NSLog(@"str %@\n", str);

        if([arrKeys containsObject:str]){

           [self push:str];

          // NSLog(@"pushed %@\n", str);

       } 

       

       if(stackArray.count==0){

         return NO;

     } 

        

       NSString *key = [[stackArray lastObject] copy];

      // NSLog(@"key %@\n", key);

        if([arrValues containsObject:str]) {

            if([str isEqualToString:[dict valueForKey:key]]){

                 [self pop]; 

                //

               // NSLog(@"poped %@\n", [dict valueForKey:key]);

            }

            else{

              return NO;

            }

        }

      

       index++;

       length--;

       

    }

     if([self isEmpty:stackArray]==YES){

         return YES;

     }

     return NO;

}

@end    

    

int main(int argc, const char * argv[]){

    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    int t;

    scanf("%i",&t);

    for(int a0 = 0; a0 < t; a0++){

        NSString* expression;

        char* expression_temp = (char *)malloc(512000 * sizeof(char));

        scanf("%s",expression_temp);

        expression = [NSString stringWithFormat:@"%s", expression_temp];

        Stack* stack = [[Stack alloc] initWithArray:[[NSMutableArray alloc]init ]];

        BOOL flag = [stack isValidSequence:expression];

        if(flag){

           // NSLog(@"%@\n",@"YES");

            printf("YES\n");

        }

        else{

            //NSLog(@"%@",@"NO"); 

             printf("NO\n");

        }

    }

    [pool drain];

    return 0;

}

https://www.hackerrank.com/challenges/ctci-array-left-rotation

 http://www.geeksforgeeks.org/program-for-array-rotation-continued-reversal-algorithm/
#import <Foundation/Foundation.h>

// C/C++ program for reversal algorithm of array rotation
#include<stdio.h>



@interface Demo: NSObject{
   
}
-(void) rvereseArray:(int []) arr  s:(int) start  e:(int) end;
@end
@implementation Demo
/* Function to left rotate arr[] of size n by d */
-(void) leftRotate:(int []) arr rotation:(int) d  size:(int) n
{
   [self rvereseArray:arr s:0 e:d-1];
   [self rvereseArray:arr s:d e:n-1];
   [self rvereseArray:arr s:0 e: n-1];
}

/*UTILITY FUNCTIONS*/
/* function to print an array */
-(void) printArray:(int [])arr length: (int) size
{
    int i;
    for (i = 0; i < size; i++)
        printf("%d ", arr[i]);
}

/*Function to reverse arr[] from index start to end*/
-(void) rvereseArray:(int []) arr  s:(int) start  e:(int) end
{
    int temp;
    while (start < end)
    {
        temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
        start++;
        end--;
    }
}
@end  

int main(int argc, const char * argv[]){
  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    int n;
    int k;
    scanf("%i %i",&n,&k);
    int a[n];
    for(int a_i = 0; a_i < n; a_i++){
       scanf("%d",&a[a_i]);
    }
    int first = a[0];
    int length = (sizeof a )/( sizeof a[0]);
 
    Demo *obj = [[Demo alloc]init];
    [obj leftRotate:a rotation:k size:n];
    [obj printArray:a  length:n];
    [pool drain];
    return 0;
}