Input: str = "Wikitechy"
Output: 
        W 1
        i 2
        k 1
        t 1
        e 1
        c 1
        h 1
        y 1

// Java prorgam to count frequencies of 
// characters in string using Hashmap 
import java.io.*; 
import java.util.*; 
class OccurenceOfCharInString { 
	static void characterCount(String inputString) 
	{ 
		// Creating a HashMap containing char 
		// as a key and occurrences as a value 
		HashMap charCountMap = new HashMap(); 

		// Converting given string to char array 

		char[] strArray = inputString.toCharArray(); 

		// checking each char of strArray 
		for (char c : strArray) { 
			if (charCountMap.containsKey(c)) { 

				// If char is present in charCountMap, 
				// incrementing it's count by 1 
				charCountMap.put(c, charCountMap.get(c) + 1); 
			} 
			else { 

				// If char is not present in charCountMap, 
				// putting this char to charCountMap with 1 as it's value 
				charCountMap.put(c, 1); 
			} 
		} 

		// Printing the charCountMap 
		for (Map.Entry entry : charCountMap.entrySet()) { 
			System.out.println(entry.getKey() + " " + entry.getValue()); 
		} 
	} 

	// Driver Code 
	public static void main(String[] args) 
	{ 
		String str = "Wikitechy"; 
		characterCount(str); 
	} 
} 

Output
c 1
t 1
e 1
W 1
h 1
i 2
y 1
k 1

Input:
   List1: 20->25->4->30
   lsit2:  8->4->2->20
Output:
   Intersection List: 4->20

/ C program to get intersection point of two linked list  
#include 
#include 
  
/* Link list node */
struct Node 
{ 
  int data; 
  struct Node* next; 
}; 
  
/* Function to get the counts of node in a linked list */
int getCount(struct Node* head); 
  
/* function to get the intersection point of two linked 
   lists head1 and head2 where head1 has d more nodes than 
   head2 */
int _getIntesectionNode(int d, struct Node* head1, struct Node* head2); 
  
/* function to get the intersection point of two linked 
   lists head1 and head2 */
int getIntesectionNode(struct Node* head1, struct Node* head2) 
{ 
  int c1 = getCount(head1); 
  int c2 = getCount(head2); 
  int d; 
  
  if(c1 > c2) 
  { 
    d = c1 - c2; 
    return _getIntesectionNode(d, head1, head2); 
  } 
  else
  { 
    d = c2 - c1; 
    return _getIntesectionNode(d, head2, head1); 
  } 
} 
  
/* function to get the intersection point of two linked 
   lists head1 and head2 where head1 has d more nodes than 
   head2 */
int _getIntesectionNode(int d, struct Node* head1, struct Node* head2) 
{ 
  int i; 
  struct Node* current1 = head1; 
  struct Node* current2 = head2; 
  
  for(i = 0; i < d; i++) 
  { 
    if(current1 == NULL) 
    {  return -1; } 
    current1 = current1->next; 
  } 
  
  while(current1 !=  NULL && current2 != NULL) 
  { 
    if(current1 == current2) 
      return current1->data; 
    current1= current1->next; 
    current2= current2->next; 
  } 
  
  return -1; 
} 
  
/* Takes head pointer of the linked list and 
   returns the count of nodes in the list */
int getCount(struct Node* head) 
{ 
  struct Node* current = head; 
  int count = 0; 
  
  while (current != NULL) 
  { 
    count++; 
    current = current->next; 
  } 
  
  return count; 
} 
  
/* IGNORE THE BELOW LINES OF CODE. THESE LINES 
   ARE JUST TO QUICKLY TEST THE ABOVE FUNCTION */
int main() 
{ 
  /* 
    Create two linked lists 
  
    1st 3->6->9->15->30 
    2nd 10->15->30 
  
    15 is the intersection point 
  */
  
  struct Node* newNode; 
  struct Node* head1 = 
            (struct Node*) malloc(sizeof(struct Node)); 
  head1->data  = 10; 
  
  struct Node* head2 = 
            (struct Node*) malloc(sizeof(struct Node)); 
  head2->data  = 3; 
  
  newNode = (struct Node*) malloc (sizeof(struct Node)); 
  newNode->data = 6; 
  head2->next = newNode; 
  
  newNode = (struct Node*) malloc (sizeof(struct Node)); 
  newNode->data = 9; 
  head2->next->next = newNode; 
  
  newNode = (struct Node*) malloc (sizeof(struct Node)); 
  newNode->data = 15; 
  head1->next = newNode; 
  head2->next->next->next  = newNode; 
  
  newNode = (struct Node*) malloc (sizeof(struct Node)); 
  newNode->data = 30; 
  head1->next->next= newNode; 
  
  head1->next->next->next = NULL; 
  
  printf("\n The node of intersection is %d \n", 
          getIntesectionNode(head1, head2)); 
  
  getchar(); 
} 

Input: position = 1, Linked List = 9->2->3->7->6
Output: Linked List =  9->3->7->6

Input: position = 0, Linked List = 9->2->3->7->6
Output: Linked List = 2->3->7->6

#include  
#include  

// A linked list node 
struct Node 
{ 
	int data; 
	struct Node *next; 
}; 

/* Given a reference (pointer to pointer) to the head of a list 
and an int, inserts a new node on the front of the list. */
void push(struct Node** head_ref, int new_data) 
{ 
	struct Node* new_node = (struct Node*) malloc(sizeof(struct Node)); 
	new_node->data = new_data; 
	new_node->next = (*head_ref); 
	(*head_ref) = new_node; 
} 

/* Given a reference (pointer to pointer) to the head of a list 
and a position, deletes the node at the given position */
void deleteNode(struct Node **head_ref, int position) 
{ 
// If linked list is empty 
if (*head_ref == NULL) 
	return; 

// Store head node 
struct Node* temp = *head_ref; 

	// If head needs to be removed 
	if (position == 0) 
	{ 
		*head_ref = temp->next; // Change head 
		free(temp);			 // free old head 
		return; 
	} 

	// Find previous node of the node to be deleted 
	for (int i=0; temp!=NULL && i		temp = temp->next; 

	// If position is more than number of ndoes 
	if (temp == NULL || temp->next == NULL) 
		return; 

	// Node temp->next is the node to be deleted 
	// Store pointer to the next of node to be deleted 
	struct Node *next = temp->next->next; 

	// Unlink the node from linked list 
	free(temp->next); // Free memory 

	temp->next = next; // Unlink the deleted node from list 
} 

// This function prints contents of linked list starting from 
// the given node 
void printList(struct Node *node) 
{ 
	while (node != NULL) 
	{ 
		printf(" %d ", node->data); 
		node = node->next; 
	} 
} 

/* Drier program to test above functions*/
int main() 
{ 
	/* Start with the empty list */
	struct Node* head = NULL; 

	push(&head, 6); 
	push(&head, 7); 
	push(&head, 3); 
	push(&head, 2); 
	push(&head, 9); 

	puts("Created Linked List: "); 
	printList(head); 
	deleteNode(&head, 4); 
	puts("\nLinked List after Deletion at position 4: "); 
	printList(head); 
	return 0; 
}

Created Linked List: 
 9  2  3  7  6 
Linked List after Deletion at position 4: 
 9  2  3  7

Input :  {0, 1, 2, 0, 1, 2}
Output : {0, 0, 1, 1, 2, 2}
Input :  {0, 1, 1, 0, 1, 2, 1, 2, 0, 0, 0, 1}
Output : {0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2}