CareerCup

public static void main(String[] args) throws Exception{
		
		String str = "aazzzeeeefffmtttdd";
		
		char temp = str.charAt(0);
		int count = 1;
		
		for(int i=1; i<str.length(); i++){
			if(str.charAt(i) != temp){
				if(count == 1){
					System.out.println(str.charAt(i-1));
					break;
				}else{
					count = 1;
					temp = str.charAt(i);
				}
			}else{
				count++;
			}
		}
		

	}

#include<iostream>

char * firstUnqChar(char* str)
{
  char prev = 0; // null char

  while(*str)
  {
    if((prev != *str) && (*str != *(str+1)))
    { return str;}
    prev = *str;
    ++str;
  }

  return NULL;
}

int main(int argc, char* argv[])
{
  if(argc != 2)
     return 0;

  if(char *p=firstUnqChar(argv[1]))
  {
    std::cout<<"unique char: "<<*p<<std::endl;
  }
  else
  {
    std::cout<<"no unique char"<<std::endl;
  }

  return 0;

}

#include<stdio.h>
#include<conio.h>
#include<string.h>


int main(){
char str[]="aabbbccccddefffggh";
for(int i=1;str[i]!='\0';i++){
if(str[i]!=str[i-1] && str[i]!=str[i+1]){
printf("%c",str[i]);
getch();
return 0;
}
}


}

my solution was..

void fn(char * str)
{
    int i=0;
    int a[26]={0};
    while(str[i])
        a[str[i++]-'a']++;
    i=0;
    while(str[i])
    {
        if(a[str[i++]-'a']==1)
        {
            printf("First non repeating character is %c\n", str[i-1]);
            break;
        }
    }
    if(str[i]=='\0')
        printf("All characters are repeating");
}

the up one is a wrong answer, like aaaazddddddejjjjjj

int main()
{
    int char1 = getchar(), char2 = getchar(), char3;
    if (char1 != char2) printf("%c", char1);
    while((char3 = getchar())!=EOF) {
        if ((char1 != char2) && (char2 != char3)) 
            printf("%c", char2);
        char1 = char2;
        char2 = char3;
    }
}

//input is char a[]

int temp[26]={0};
int i;
for(i=0; i<alen; i++)
{
temp[a[i]-'a']++
}

for(i=0; i<26; i++)
{
if(temp[i]==1)
printf("%d\n", i+'a');
}

adobe-interview-questions 3 Answers

what will be the output of this code..please explain

#include <iostream>

using namespace std;
int main()
{
int *i, *j;
i=(int *)60;
j=(int *)20;
printf("%d %d %d\n",i,j,i-j);
getchar();
getchar();
return 0;
}

Algorithm: Iterate through the string and for every element except the start and the last one check his two neighbouring elements. If they are different characters - then this is the unique character. The firs and the last element must be compared only with their closest neighbour - only one element each.

public class FirstNRC {
	public static void main(String[] args) {
		String str ="aabbbccccddeffffgg";
		System.out.println(FindFirstNonChar(str));
	}
	
	private static Character FindFirstNonChar(String str)
	{
		if(str.length()==0)
			return ' ';
		
		if(str.charAt(0)!=str.charAt(1))
			return str.charAt(0);
		
		for(int i=1; i<str.length()-1; i++)
		{
			if(str.charAt(i)!=str.charAt(i-1)&&str.charAt(i)!=str.charAt(i+1))
				return str.charAt(i);
		}
		
		if(str.charAt(str.length()-1)!=str.charAt(str.length()-2))
		{
			return str.charAt(str.length()-1);
		}
		return ' ';
	}
}

#include<stdio.h>
#include<stdlib.h>
#define NO_OF_CHARS 256

int *getCharCountArray(char *str)
{
int *count=(int*)calloc(sixeof(int),NO_OF_CHARS);
int i;
for(i=0;*(str+i);i++)
count[*(str+i)]++;
return count;
}

int firstNonRepeating(*str)
{
int *count=getCharCount(str);
int index=-1,i;
for(i=0;*(str+1);i++)
{
if (count[*(str++)]==1)
{index=i;
break;}}
return index;
}

int main()
{
char str[]="hheeyyy you can inpur any string here";
int index=firstNonRepeating(str);
if(index==-1)
{printf("Either all char are repeating or string is empty");}
else{printf("First non-repeating character is%c",str[index]);}
getchar();
return 0;}

Is this ok?

int main()
{
    char *str="aaabbbcccdddeggg";
    char c='0';
    int i=0;
    char *str2= new char[strlen(str)];
    strcpy(str2,str);
    int flag=0;
    
    
    while(str[i]!='\0')
    {
              c=str[i];
              int j=0;
              int count=0;
              while(str2[j]!='\0')
              {
                               if(str2[j]==c)
                               {
                                             count++;
                               }
                               j++;
              }
              if(count==1)
              {
                          cout<<"non repeative char is "<<c;
                          flag=1;
                          break;
              }
              i++;
              }
              if(flag==0)
                         cout<<"not found";
              getch();
              return 1;
}

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

char first_non_repeat(char *s) {
char *p = s;
char temp;
int count = 0;
char result;
while(*p) {
temp = *p;
count = 0;
while(*p == temp) {
p++;
count++;
}
if(count == 1) {
result = temp;
break;
}
}
if(count == 1) {
return temp;
} else {
return '\0';
}
}

void main() {
char s[] = "aabbbccccddeffffgg";
char result = first_non_repeat(s);
if(result) {
printf("%c\n", result);
} else {
printf("no.\n");
}
getchar();
}

int firstNonRepeatingChar(const char *in)
{
int i;
i=0;
if(*in=='\0')
{
printf("There is not any non repating character\n");
return 1;
}
in++;
i++;
do
{
if(*in!=*(in-1))
{
i++;
}
else
{
i=0;
}
if(i>=2)
{
printf("1st non repeating character is <%c>\n",*(in-1));
break;
}
}while(*in++);
return 0;
}

Alright I wrote an answer that does not require an array for storing repeating characters. It only requires 2 pointers and a flag. The algorithm looks at two characters at a time and sets a flag if they are the same. If they are not the same and the flag is unset then we have our first non repeating character.

public static char retFirstNonRep(string vars)
        {
            int length = vars.Length;

            //handle base cases
            if (length == 1)
                return vars[0];
            if (length == 2)
            {
                if (vars[0] != vars[1])
                    return vars[0];
            }

            int a = 0;
            int b = 1;
            bool rpt = false;

            while (b < length)
            {
                //check matching
                if (vars[a] == vars[b])
                    rpt = true;
                else
                {
                    //check repeat flag
                    if (rpt == false)
                        return vars[a];
                    else
                        rpt = false;
                }
                //increment ptrs
                a++;
                b++;
            }

            b--;
            a--;

            if (vars[a] != vars[b])
            {
                return vars[b];
            }

            return '\0';
        }

#include<stdio.h>
#include<string.h>
char non_repeatchar(char *p)
{
int l=strlen(p),i=0;
for(i=0;i<l;i++)
{
if(p[i]!=p[i+1])
return p[i];
else
{while(p[i]==p[i+1])
i++;}

}
return NULL;
}
int main()
{
char p[]="aaabcd";
char c;
c=non_repeatchar(p);
printf("%c\n",c);
return 0;
}

I think this approach would be simple and fast, (I am using Java)

Take 2 arraylists, L1 and L2, I will use L1 for all the characters which are non - repeating and L2 for the characters which are repeating.

Consider the example: aabcccddddebfff

Iterate through the characters in the array, so first alphabet is 'a' and put it in L1 assuming this is not repeating, but 2nd character is 'a' again, so check if L1 already has it or not, in this case L1 already had it, so that means it is repeating, so remove 'a' from L1 and put it in L2 (which contains the repeating characters), keep on doing this for all the remaining characters as well, and after the iteration completes, if L1.get(0) is null then all the characters are repeating else L1.get(0) gives you the first non repeating character and L1.get(1) gives you 2nd non repeating character and so on....


I think this solution will work for both aaabbbbcccdeeee and aaabccccdeeebbb type of strings as well, where the repeating characters may not be adjacent.

If you want to make it more fast you can also use LinkedHashMap instead of ArrayLists which will make the running time of the above algorithm as O(n)

#include<stdio.h>
main()
{
char *s = "aaaazddddddejjjjjj";
char *d = s;
while(*d != '\0')
{
if(d==s && (*d != *(d+1)))
break;
if((*d != *(d+1)) && (*d != *(d-1)))
break;
else
d++;
}
printf("%c",*d);
}

public static void finds(char[] n)
	{
		Hashtable<Character, Integer> table = new Hashtable<Character, Integer>();
		
		for (int i=0;i<n.length;i++)
		{
			if(!table.containsKey(n[i]))
			{
				table.put(n[i], 1);
			}
			else
			{
				int times = table.get(n[i]);
				table.put(n[i],times+1);
			}
			
		}
		
		for (int i=0;i<n.length;i++)
		{
			
			//System.out.println("The number of times i've seen "+n[i]+" is: "+table.get(n[i]));
			
			if(table.get(n[i])==1)
			{
				System.out.println("FOUND IT: "+n[i]);
			
			
			}
		
		}
	
		
	}

public class NonRepeatingCharacter {

public String str;
public Character ch;
public static void main(String args[])
{
NonRepeatingCharacter n = new NonRepeatingCharacter();
n.setStr("aabbbccccddffffgd");
Character c=n.getNonRepeatingCharacter();
System.out.println(c);
}
public NonRepeatingCharacter()
{
str = "";
ch='A';
}
public void setStr(String str)
{
this.str = str;
}
public Character getNonRepeatingCharacter()
{
int n=str.length();
int i=0,j=0;;

for(i=0,j=2*i+1;j<n-1;i++,j=2*i+1)
{
//System.out.println(str.charAt(j));
if(str.charAt(j)!=str.charAt(j-1) && str.charAt(j)!=str.charAt(j+1))
{
ch=str.charAt(j);

break;

}

}
if(n%2 == 0)
{
if(str.charAt(j-1)!=str.charAt(j))
ch=str.charAt(j);
}
return ch;
}
}

public static void main(String[] args) {
String abc="aabbbccccdeeffffg";
for(int i=0;i<abc.length();i++){
char c=abc.charAt(i);
if(abc.indexOf(c)==abc.lastIndexOf(c)){
System.out.println("The character is ==>"+c);
}
}

You can also put a break one find the first match to make it more efficient.

public void firstNon_repeatingChar(String str){
LinkedHashMap<Character, Integer> hashMap = new LinkedHashMap<Character, Integer>();
for(int i = 0; i < str.length(); i++){
Character c = str.charAt(i);
if(hashMap.get(c) != null){
int value = ((Integer)hashMap.get(c)).intValue();
value++;
hashMap.put(c, value);
}else{
hashMap.put(c, 1);
}
}
Iterator it = hashMap.entrySet().iterator();
boolean first = false;
while(it.hasNext()){
Map.Entry map = (Map.Entry)it.next();
if((Integer)map.getValue() == 1){
if(!first){
System.out.println("first non-repeating character is:" + map.getKey());
first = true;
}
}
}
}

You can use LinkedHashMap

Find all non-repeating:

char str[] = "aaabbbcccddefffgghhiiijjjklllmnoopqqr";
    int changed = 0;
    int len = strlen(str);
    for(int i = 1; i < len; i++)
    {
        if(str[i-1] != str[i])
            changed++;
        else changed = 0;
        if(changed > 1)
            fprintf(stderr, "non-repeating: %c\n", str[i-1]);
        if(i == len-1)
            fprintf(stderr, "non-repeating: %c\n", str[i]);
    }

static char printUniquechar(char a[]){
		char unique='\u0000';
		int count=0,i=0;
		while(i<a.length){
			if(unique!=a[i]){
				if(count==1)break;
				unique=a[i];
				count=0;
				count++;
			}else{
				  count++;	
			}
		i++;
		}
		
		if(count!=1) 
			{unique='\u0000';}
		
		return unique;
	}
	
	
}

Time=O(N)

#include <iostream>

char getFirstNonRepeating (const char * p)
{
  while (*p != '\0' && *p == *(p+1))
  {
    ++p;
    while (*p == *(++p))
    {
    }
  }
  return *p;
}

int main (void)
{
  const char str[] = "aabbbccccddeffffgg";
  std::cout << getFirstNonRepeating (str) << std::endl;
}

Solution using java.

package com.algo;

import java.util.HashSet;
import java.util.Set;

public class FirstNonRepeatChar {

	public static void main(String[] args) {
		Set<Character> alpha = new HashSet<Character>();
		Boolean prev = null;
		for (int index = 0; index < args[0].length(); index++) {
			boolean curr = alpha.add(args[0].charAt(index));
			if (curr && Boolean.TRUE.equals(prev)) {
				System.out.println("found: " + args[0].charAt(index - 1));
				break;
			}
			prev = curr;
		}
	}
}

public class FirstNonRepetative {
	public static void main(String[] args) {
		String str = "aabbbccccddeffffgg";
		char[] strInChar = str.toCharArray();
		char c = getFirstNonRepChar(strInChar, 1);
		System.out.println(c);
	}

	private static char getFirstNonRepChar(char[] strInChar, int i) {
		if (i == 1 && strInChar[0] != strInChar[1]) {
			return strInChar[0];
		}
		else if ((strInChar[i] != strInChar[i - 1]) && (strInChar[i] != strInChar[i + 1])) {
			return strInChar[i];
		} else {
			return getFirstNonRepChar(strInChar, ++i);
		}
	}
}

#include<stdio.h>
#include<conio.h>
int main()
{
char a[]="aaabbbgsjdgggdudggsiuii";
char *ptr;
ptr=a;
char var[26]={0};
int i=0;
while((*ptr++))
{
var[a[i]-'a']++;
i++;
}
for(int j=0;j<26;j++)
{
if(var[j]==1);
{ printf("first non repiting character \n");
printf("%c",var[j+65]);
break;}
}
getch();
return 0;
}

{{
char * FirstUniqueChar( char * text )
{
int len = strlen( text );
char ch;
if( len < 1 )
{
return NULL;
}
int i = 1;
for( ; i < len-1; i++ )
{
if( text[i-1] != text[i] && text[i] != text[i+1] )
{
return &text[i];
}
}
if( i>= len - 1 )
{
if( text[i-1] != text[i] )
{
return &text[i];
}
}
return NULL;
}

int main( int argc, char ** argv )
{
char buf[] = "aabbccccddefffgg";
char * r = FirstUniqueChar( buf );
printf("%c\n", *r );
return 0;
}

}}

Here is algorithm in java to print first no-repeated character in given string :

public void printFirstOneRepeatedChar(String str) {
		if (str.length() == 0) return;
		else if (str.length() == 1) System.out.println(str);
		else if (str.length() == 2) {
			if ( str.charAt(0) != str.charAt(1))
				System.out.println(str.charAt(0));
			else
				return;
		}
		else {
			
			for (int i=1; i<str.length(); i++) {
				
				boolean unique =  (i < str.length()) ? ( (str.charAt(i-1) == str.charAt(i)) || (str.charAt(i) == str.charAt(i+1)) ) : (str.charAt(i-1) == str.charAt(i)); 
				if (unique)
					continue;
				else 
					System.out.println(str.charAt(i));
			}
		}
	}

I wrote the code as below.. Please provide suggestions how to optimize it further

//Find first non -repeatin character in string

int main()
{
    
  char string[20];
  gets(string);
  int i=0;
   if(string[i]!=string[i+1]){printf("%c",string[i]);return 0;}
  for(;i<strlen(string)-1;i++)
  
  {
                            
  if((string[i]!=string[i+1])&&(string[i]!=string[i-1])&&(i!=0))
   {printf("%c",string[i]); break;}
  }
  getch();
  return 0;    
}

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

int main()
{
	char c[] = "aabbbccccddeffffgg";
	char prev = c[0];int i;
	for(i = 0; i< strlen(c)-1;i++) {
		if((prev != c[i]) && (c[i] != c[i+1])) 
			printf("character %c\n",c[i]);
		prev = c[i];
	}
	return 0;
}

// TODO Auto-generated method stub

		final List<String> list = new ArrayList<String>();
		list.add("a");
		list.add("a");
		list.add("b");
		list.add("b");
		list.add("b");
		list.add("c");
		list.add("c");
		list.add("c");
		list.add("c");
		list.add("d");
		list.add("d");
		list.add("e");
		list.add("f");
		list.add("f");
		list.add("f");
		list.add("f");
		list.add("g");
		list.add("g");
		Object[] s = list.toArray();
		
		int i =0,j=1;
		boolean flag = true;
		for(i=0;i<(s.length)-1;)
			
		{
			i=j-1;
			int count =0;
			j=i+1;
			do
			{
				if(((String) s[i]).equalsIgnoreCase((String) s[j]) && (j<list.size()))
				{
					count++;
					flag= true;
				}
				else
				{
					flag = false;
				}
				if(j<(s.length)-1)
				j++;
			}while(flag) ;
			
			if(count == 0)
			{
				System.out.println("non repeating character is :::::::"+s[i]);
				break;
			}
			
		}

Using hash map , the question is pretty straightforward. Works for all the cases.

static void repeatStr(String str){
// brute force: store all in map and find the first non repeating
Map<Character,Integer> map = new HashMap<Character,Integer>();
for(int i=0;i<str.length();i++){
char ch = str.charAt(i);
if(map.containsKey(ch)){
map.put(ch,map.get(ch)+1);
}
else{
map.put(ch,1);
}
}

for(int i=0;i<str.length();i++){
char ch = str.charAt(i);
if(map.get(ch) == 1){
System.out.println("first non rep elem is: "+ch);
break;
}
else if(i==str.length()-1){
System.out.println("no such elem");
}
}


}

char first(cosnt std::string& n)
{
	std::vector<int> v(255, 0);
	string::iterator it = n.begin();
	for(; it != n.end(); ++it)
		v[*it] += 1;
	vector<int>::iterator hashIt = v.begin();
	for(;hashIt!= v.end();++hashIt)
	{
		if(*hashIt == 1)
			return (hashIt - v.begin());
	}
	return '$';
}

private static string FirstNonRepeat(string str)
        {
            int l = str.Length;
            int count = 0;
            for (int i = 0; i < l - 1; i++)
            {
                if (str[i] == str[i + 1])
                {
                    count++;
                }
                else
                {
                    if (count == 0)
                        return str[i].ToString();
                    else
                        count = 0;

                }
                
            }

            return "Nothing found";

}

String str = "aazzzeeeefffmtttdd";
		for(int i=1;i<str.length()-1;i++)
		{
			if(str.charAt(i)!=str.charAt(i-1)&&str.charAt(i)!=str.charAt(i+1))
			{
				System.out.println("Got u : "+str.charAt(i));
				break;
			}		
		}

public class FirstNonRepeating {

	
	public static void main(String[] args) {
	
		String str="aabbbccccddeffffgg";
		
		char ch[]=str.toCharArray();
	Map<Character,Integer> hs1=new LinkedHashMap<Character,Integer>();
	
		for(Character ch1:ch)
		{
			if(hs1.containsKey(ch1))
			{
				hs1.put(ch1,hs1.get(ch1)+1);
			}
			else
			{
				hs1.put(ch1,1);
			}
		}
		
		Character ch2=null;
		for(Character ch1:ch)
		{
			if(hs1.get(ch1)==1)
			{
				ch2=ch1;
				//System.out.println(ch1);
				break;
			}
		
		}
		
		System.out.println("So first non-repeating character="+ch2);
	}
}

In C#

String str = "aazzzeeeefffmtttdd";
Console.WriteLine((from m in str.Distinct() where str.Count(t => t == m) == 1 select m).FirstOrDefault());

int FindNonRep(char* s)
{
	int size=strlen(s);
	bool before=TRUE;

	if(size<=1) return 0;
	for(int i =0;i<size;i++)
	{
		if(*(s+i+1)!=0)
		{
			if(*(s+i+1)==*(s+i))
			{
				before=0;
			}
			else
			{   
				if(before==0)
				{
				before=1;
				}
				else
				{
					return i;
				}
			}
		}
	}
	return -1;

}

private static void getrepeating(){		
		String str="aabbbccccddeffffgg";
		char[] charArray = str.toCharArray();
		for(int i=0;i<charArray.length-1;i++){
			if((charArray[i]-charArray[i+1])!=0 && (charArray[i+1]-charArray[i+2])!=0){				
				System.out.println(charArray[i+1]);
			}			
		}
	}

Hi,
In C# with out using Linq

class Program
    {
        static void Main(string[] args)
        {
            string str = "aabbbcccccddddddeffffggg";
            string tempStr = str;
            int charCount = 0;
            foreach (char c in tempStr)
            {
                if (tempStr.Contains(c))
                {
                    charCount++;
                }
                if (charCount > 1)
                {
                    tempStr = tempStr.Replace(c.ToString(), string.Empty);
                    charCount = 0;
                }
            }
            Console.WriteLine("Answer = " + tempStr);
            Console.ReadLine();
        }
    }

In C#
Using Linq

class Program
    {
        static void Main(string[] args)
        {
            string str = "aabbbcccdccddddddeffffggg";            
            string st = str.GroupBy(x => x).First(g => g.Count() == 1).Key.ToString();            
            Console.WriteLine("Answer : " + st);
            Console.ReadLine();
        }
    }

public static void main(String[] args) {
String str = "aazzzeeeefffmtttddxyz";
char[] characters = str.toCharArray();
Map<Character,Integer> countMap = new HashMap<Character,Integer>();
int count = 0;
for (Character character : characters) {
if (countMap.containsKey(character)) {
countMap.put(character, countMap.get(character) + 1);
} else {
countMap.put(character, 1);
}
}
Set<Character> charSet = countMap.keySet();
for (Character c : charSet) {
if (countMap.get(c) == 1) {
System.out.println("Non Repeating character: " + c);
}
}
}

public static void main(String[] args) {
String str = "aazzzeeeefffmtttddxyz";
char[] characters = str.toCharArray();
Map<Character,Integer> countMap = new HashMap<Character,Integer>();
int count = 0;
for (Character character : characters) {
if (countMap.containsKey(character)) {
countMap.put(character, countMap.get(character) + 1);
} else {
countMap.put(character, 1);
}}
Set<Character> charSet = countMap.keySet();
for (Character c : charSet) {
if (countMap.get(c) == 1) {
System.out.println("Non Repeating character: " + c);
}}}