CareerCup

c# implementation.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading;

namespace PhoneBook {

    public struct Person {

        public Person( string name, string phoneNumber, string address ) {
            Name = name;
            PhoneNumber = phoneNumber;
	    Address = address;
        }

        public string Name { get; }
        public string PhoneNumber { get; }
        public string Address { get; }
    }

    public class Phonebook {

        private readonly object _lock = new object();

        private readonly ConcurrentDictionary<string, Person> _indexByName;

        private readonly ConcurrentDictionary<string, Person> _indexByPhoneNumber;

        public Phonebook( IEnumerable<Person> people ) {
        
            _indexByName = new ConcurrentDictionary<string, Person>();
            _indexByPhoneNumber = new ConcurrentDictionary<string, Person>();

            foreach ( var p in people ) {
                _indexByName.AddOrUpdate( p.Name, p, (s, pers) => pers );
                _indexByPhoneNumber.AddOrUpdate( p.PhoneNumber, p, (s, pers) => pers );
            }
        }

        public Person? LookupByName( string name ) {

            Person pers;
            var res = _indexByName.TryGetValue( name, out pers );
            return res ? (Person?)pers : null;
        }

        public Person? LookupByPhoneNumber( string phoneNumber ) {

            Person pers;
            var res = _indexByPhoneNumber.TryGetValue( phoneNumber, out pers );
            return res ? (Person?)pers : null;
        }

        public void AddPerson( Person person ) {

            Monitor.Enter( _lock );

            var res1 = LookupByName( person.Name );
            var res2 = LookupByPhoneNumber( person.PhoneNumber );

            if ( res1 != null && res2 != null ) {
                Monitor.Exit( _lock );
                return;
            }

            Person p;

            if ( res1 != null ) {
                
                _indexByPhoneNumber.TryRemove( ((Person)res1).PhoneNumber, out p );
                _indexByPhoneNumber.TryAdd( person.PhoneNumber, person );
            }
            
            if ( res2 != null ) {

                _indexByName.TryRemove( ((Person)res2).Name, out p );
                _indexByName.TryAdd( person.Name, person );
            }

            _indexByName.AddOrUpdate( person.Name, person, (s, pers) => person );
            _indexByPhoneNumber.AddOrUpdate( person.PhoneNumber, person, (s, pers) => person );

            Monitor.Exit( _lock );
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

namespace Employee
{
    public class Contact
    {

        public string Name { get; private set; }
        public string PhoneNumber { get; private set; }
        public string Address { get; private set; }

        public Contact(string name, string phoneNumber, string address)
        {
            this.Name = name;
            this.PhoneNumber = phoneNumber;
            this.Address = address;
        }
    }

    public class PhoneBook
    {
        private readonly IEnumerable<Contact> _contact;

        public PhoneBook(IEnumerable<Contact> contact)
        {
            this._contact = contact;
        }
        public IEnumerable<Contact> lookForName(string name)
        {
            var lookup = _contact.ToLookup(nd => nd.Name);
            return lookup[name];
        }
        public IEnumerable<Contact> lookForPhoneNumber(string phoneNumber)
        {
            var lookup = _contact.ToLookup(nd => nd.PhoneNumber);
            return lookup[phoneNumber];
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

namespace Employee
{
    public class Contact
    {

        public string Name { get; private set; }
        public string PhoneNumber { get; private set; }
        public string Address { get; private set; }

        public Contact(string name, string phoneNumber, string address)
        {
            this.Name = name;
            this.PhoneNumber = phoneNumber;
            this.Address = address;
        }
    }

    public class PhoneBook
    {
        private readonly IEnumerable<Contact> _contact;

        public PhoneBook(IEnumerable<Contact> contact)
        {
            this._contact = contact;
        }
        public IEnumerable<Contact> lookForName(string name)
        {
            var lookup = _contact.ToLookup(nd => nd.Name);
            return lookup[name];
        }
        public IEnumerable<Contact> lookForPhoneNumber(string phoneNumber)
        {
            var lookup = _contact.ToLookup(nd => nd.PhoneNumber);
            return lookup[phoneNumber];
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

namespace Employee
{
    public class Contact
    {

        public string Name { get; private set; }
        public string PhoneNumber { get; private set; }
        public string Address { get; private set; }
        public string _All
        {
            get
            {
                return string.Format("{0}:{1}:{2}",
                    this.Name,
                    this.PhoneNumber,
                    this.Address).ToLower();
            }
        }

        public Contact(string name, string phoneNumber, string address)
        {
            this.Name = name;
            this.PhoneNumber = phoneNumber;
            this.Address = address;
        }

       
    }

    public class PhoneBook
    {
        private readonly IEnumerable<Contact> _contact;

        public PhoneBook(IEnumerable<Contact> contact)
        {
            this._contact = contact;
        }
        public IEnumerable<Contact> lookForName(string name)
        {
            var lookup = _contact.ToLookup(nd => nd.Name);
            return lookup[name];
        }
        public IEnumerable<Contact> lookForPhoneNumber(string phoneNumber)
        {
            var lookup = _contact.ToLookup(nd => nd.PhoneNumber);
            return lookup[phoneNumber];
        }

        public IEnumerable<Contact> lookForAlphabet(char letter)
        {
            var lookup = _contact.ToLookup(p => Convert.ToChar(p.Name.Substring(0, 1)),
                  p => p);
            return lookup[letter];
        }

        public IEnumerable<Contact> lookForAll(string anyVal)
        {
            var lookup = _contact.Where(p => p._All.Contains(anyVal.ToLower()));
            return lookup;
        }
    }

    class CustomComparer : IEqualityComparer<Contact>
    { 
    
    }
}

class PersonDetails{
String Name;
long PhoneNumber;
String Email;
int EmployeeId;

public void PersonDetails(String Name, long PhoneNumber, String Email, int EmployeeId){
this.Name = Name;
this.PhoneNumber = PhoneNumber;
this.Email = Email;
this.EmployeeId = EmployeeId;
}

public void PersonDetails(){
this.Name = null;
this.PhoneNumber = 0;
this.Email = null;
this.EmployeeId = 0;
}

public String getName(){
return this.Name;
}

public long getPhoneNumber(){
return this.PhoneNumber;
}

public String getEmail(){
return this.Email;
}

public int getEmployeeId(){
return this.EmployeeId;
}
}

class SearchResult{

public void SearchResult(String Name, HashMap<Integer, Object> map){
Iterator it = map.keySet().iterator();
while(it.hasNext()){
int key = (int) it.next();
PersonDetails PDet = (PersonDetails) map.get(key);
if(PDet.getName().equalsIgnoreCase(Name)){
System.out.println("\n Name: "+PDet.getName());
System.out.println("\n PhoneNumber: "+PDet.getPhoneNumber());
System.out.println("\n EmailID: "+PDet.getEmail());
System.out.println("\n EmployeeID: "+PDet.getEmployeeId());
System.out.println("\n");
System.out.println("\n");
}
}
}