From 11178540905f03b2ed2a1feb12b1fe418aabe378 Mon Sep 17 00:00:00 2001
From: Maria <46182261+Maria16pca111@users.noreply.github.com>
Date: Sun, 7 Apr 2019 21:51:42 +0530
Subject: [PATCH 1/2] 42 out of 50

still working on it
---
 UnsortedArray/Attendance_Registry.py          | 22 ++++++++++++++++
 UnsortedArray/Attendance_Registry_re1.py      | 12 +++++++++
 .../FindValue_After_R_Rotations_Left.py       | 15 +++++++++++
 UnsortedArray/Find_Value_After_R_Rotations.py | 16 ++++++++++++
 UnsortedArray/Index_After_Rotations_Left.py   | 14 +++++++++++
 UnsortedArray/Index_After_Two_Rotations.py    | 14 +++++++++++
 UnsortedArray/SubsetA_a_adds_gives_X.py       | 15 +++++++++++
 UnsortedArray/Two_arrays_Same.py              | 13 ++++++++++
 UnsortedArray/array_conatain_perfectsquare.py | 13 ++++++++++
 UnsortedArray/array_contains_x.py             | 14 +++++++++++
 UnsortedArray/array_duplicate_removed.py      |  7 ++++++
 UnsortedArray/array_exe.py                    |  9 +++++++
 UnsortedArray/array_input_return_output.py    |  7 ++++++
 UnsortedArray/array_largest.py                | 10 ++++++++
 UnsortedArray/array_morethan_once.py          | 12 +++++++++
 UnsortedArray/array_return_evenno.py          | 11 ++++++++
 UnsortedArray/array_return_oddno.py           |  7 ++++++
 UnsortedArray/array_return_primeno.py         | 25 +++++++++++++++++++
 UnsortedArray/array_rev_order.py              | 17 +++++++++++++
 UnsortedArray/array_reverse_order.py          | 10 ++++++++
 UnsortedArray/array_smallest.py               | 11 ++++++++
 UnsortedArray/array_subset_indices_adds_x.py  | 20 +++++++++++++++
 UnsortedArray/counttime_apperars_array.py     | 12 +++++++++
 UnsortedArray/countvalues_givenrange.py       | 13 ++++++++++
 UnsortedArray/findX.py                        |  9 +++++++
 UnsortedArray/indices_which_adds_x.py         | 22 ++++++++++++++++
 UnsortedArray/kth_largest_array.py            |  8 ++++++
 UnsortedArray/kthsmallest_Array.py            |  9 +++++++
 UnsortedArray/leftby1position.py              |  9 +++++++
 UnsortedArray/loc_of_array_value.py           | 12 +++++++++
 UnsortedArray/meanarray.py                    | 11 ++++++++
 UnsortedArray/mode_array.py                   | 20 +++++++++++++++
 UnsortedArray/number_times_largest_found.py   | 19 ++++++++++++++
 UnsortedArray/number_times_x.py               | 14 +++++++++++
 UnsortedArray/numer_Smallest_array_found.py   | 15 +++++++++++
 UnsortedArray/palindrome.py                   | 13 ++++++++++
 UnsortedArray/rightby1position.py             | 10 ++++++++
 UnsortedArray/secondlargest_smallest_array.py | 15 +++++++++++
 .../subset_adds_x_values_variations.py        | 14 +++++++++++
 UnsortedArray/sumelementsa.py                 |  9 +++++++
 UnsortedArray/tworightbyposition.py           | 14 +++++++++++
 UnsortedArray/values_count_lessthan.py        | 12 +++++++++
 42 files changed, 554 insertions(+)
 create mode 100644 UnsortedArray/Attendance_Registry.py
 create mode 100644 UnsortedArray/Attendance_Registry_re1.py
 create mode 100644 UnsortedArray/FindValue_After_R_Rotations_Left.py
 create mode 100644 UnsortedArray/Find_Value_After_R_Rotations.py
 create mode 100644 UnsortedArray/Index_After_Rotations_Left.py
 create mode 100644 UnsortedArray/Index_After_Two_Rotations.py
 create mode 100644 UnsortedArray/SubsetA_a_adds_gives_X.py
 create mode 100644 UnsortedArray/Two_arrays_Same.py
 create mode 100644 UnsortedArray/array_conatain_perfectsquare.py
 create mode 100644 UnsortedArray/array_contains_x.py
 create mode 100644 UnsortedArray/array_duplicate_removed.py
 create mode 100644 UnsortedArray/array_exe.py
 create mode 100644 UnsortedArray/array_input_return_output.py
 create mode 100644 UnsortedArray/array_largest.py
 create mode 100644 UnsortedArray/array_morethan_once.py
 create mode 100644 UnsortedArray/array_return_evenno.py
 create mode 100644 UnsortedArray/array_return_oddno.py
 create mode 100644 UnsortedArray/array_return_primeno.py
 create mode 100644 UnsortedArray/array_rev_order.py
 create mode 100644 UnsortedArray/array_reverse_order.py
 create mode 100644 UnsortedArray/array_smallest.py
 create mode 100644 UnsortedArray/array_subset_indices_adds_x.py
 create mode 100644 UnsortedArray/counttime_apperars_array.py
 create mode 100644 UnsortedArray/countvalues_givenrange.py
 create mode 100644 UnsortedArray/findX.py
 create mode 100644 UnsortedArray/indices_which_adds_x.py
 create mode 100644 UnsortedArray/kth_largest_array.py
 create mode 100644 UnsortedArray/kthsmallest_Array.py
 create mode 100644 UnsortedArray/leftby1position.py
 create mode 100644 UnsortedArray/loc_of_array_value.py
 create mode 100644 UnsortedArray/meanarray.py
 create mode 100644 UnsortedArray/mode_array.py
 create mode 100644 UnsortedArray/number_times_largest_found.py
 create mode 100644 UnsortedArray/number_times_x.py
 create mode 100644 UnsortedArray/numer_Smallest_array_found.py
 create mode 100644 UnsortedArray/palindrome.py
 create mode 100644 UnsortedArray/rightby1position.py
 create mode 100644 UnsortedArray/secondlargest_smallest_array.py
 create mode 100644 UnsortedArray/subset_adds_x_values_variations.py
 create mode 100644 UnsortedArray/sumelementsa.py
 create mode 100644 UnsortedArray/tworightbyposition.py
 create mode 100644 UnsortedArray/values_count_lessthan.py

diff --git a/UnsortedArray/Attendance_Registry.py b/UnsortedArray/Attendance_Registry.py
new file mode 100644
index 0000000..ce80396
--- /dev/null
+++ b/UnsortedArray/Attendance_Registry.py
@@ -0,0 +1,22 @@
+def Attendance_Registry(Entry):
+    Count=0
+    CountMax=0
+    for x in range(0,10):
+        if not (x==Entry):
+            Entry.insert(0,x)
+            print'Welcome'
+            Count+=1
+            print(Entry)
+    for y in Entry:
+        for z in Entry:
+            if(y==z):
+                Updated_Entry=Entry.remove(z)
+                print'Bye! See you Again'               
+                CountMax+=1
+                print(Updated_Entry)
+                print(Entry)
+    print Count,CountMax
+            
+Entry=[20]
+Attendance_Registry(Entry)
+            
\ No newline at end of file
diff --git a/UnsortedArray/Attendance_Registry_re1.py b/UnsortedArray/Attendance_Registry_re1.py
new file mode 100644
index 0000000..b6c2c63
--- /dev/null
+++ b/UnsortedArray/Attendance_Registry_re1.py
@@ -0,0 +1,12 @@
+n=input('number')
+data=[1,2,3,4,5]
+for x in data:
+    if not(n==x):
+        data.append(n)
+        print('yes! you are Inside')
+        
+    else:
+        data.pop(n)
+        print('You are out')
+print(data)
+    
\ No newline at end of file
diff --git a/UnsortedArray/FindValue_After_R_Rotations_Left.py b/UnsortedArray/FindValue_After_R_Rotations_Left.py
new file mode 100644
index 0000000..5289a36
--- /dev/null
+++ b/UnsortedArray/FindValue_After_R_Rotations_Left.py
@@ -0,0 +1,15 @@
+# find the value after the r rotations left 
+
+def Value_After_R_Rotations_Left(a,k):
+    count=0
+    while(count!=k):
+        x=a.pop(-1)
+        count+=1
+        a.insert(0,x)
+    count+1
+    return a,a[Index]
+    
+a=[1,2,3,4,5,6,7,8,9]
+k=5
+Index=3
+print(Value_After_R_Rotations_Left(a,k))
\ No newline at end of file
diff --git a/UnsortedArray/Find_Value_After_R_Rotations.py b/UnsortedArray/Find_Value_After_R_Rotations.py
new file mode 100644
index 0000000..8f99c2b
--- /dev/null
+++ b/UnsortedArray/Find_Value_After_R_Rotations.py
@@ -0,0 +1,16 @@
+# Find the value which will be in index and get after R Rotations to the Right
+
+def Index_R_Rotations_Find_I(a,I,R):
+    rotation=1
+    while(rotation<R):
+        x=a.pop(-1)
+        a.insert(0,x)
+        rotation+=1
+    Value=-1
+    if(I<len(a)):
+        Value=a[I]
+    return Value
+a=[1,2,3,4,5,6,7,8,9,10]
+I=5
+R=5
+print(Index_R_Rotations_Find_I(a,I,R))
\ No newline at end of file
diff --git a/UnsortedArray/Index_After_Rotations_Left.py b/UnsortedArray/Index_After_Rotations_Left.py
new file mode 100644
index 0000000..9adb724
--- /dev/null
+++ b/UnsortedArray/Index_After_Rotations_Left.py
@@ -0,0 +1,14 @@
+#third position after index upto array two rotations left
+
+def Third_Position_Array_Two_Rotation(a):
+    count=0
+    while(count!=2):
+        array=a.pop(-1)
+        a.insert(0,array)
+        count+=1
+        
+    count+=1
+    return a,array
+a=[1,2,3,4,5,6,7,8]
+print(Third_Position_Array_Two_Rotation(a))
+    
\ No newline at end of file
diff --git a/UnsortedArray/Index_After_Two_Rotations.py b/UnsortedArray/Index_After_Two_Rotations.py
new file mode 100644
index 0000000..e27945e
--- /dev/null
+++ b/UnsortedArray/Index_After_Two_Rotations.py
@@ -0,0 +1,14 @@
+#third position after index upto array two rotations
+
+def Third_Position_Array_Two_Rotation(a):
+    count=0
+    while(count!=2):
+        array=a.pop(0)
+        count+=1
+        a.append(array)
+    count+=1
+    return a,array
+a=[1,2,3,4,5,6,7,8]
+print(Third_Position_Array_Two_Rotation(a))
+    
+
diff --git a/UnsortedArray/SubsetA_a_adds_gives_X.py b/UnsortedArray/SubsetA_a_adds_gives_X.py
new file mode 100644
index 0000000..c090fdb
--- /dev/null
+++ b/UnsortedArray/SubsetA_a_adds_gives_X.py
@@ -0,0 +1,15 @@
+#integer array A and a value X, check if there exists a subset of A of size two that adds upto X (Subset sum for a pair).
+
+def Subset_Pair_X(A,a,X):
+    
+    for x in A:
+        for y in a:
+            if(x+y==X):
+                print x,y
+    return 0               
+
+A=[1,2,3,4,6,7]
+a=[1,2,3,4,5]
+X=8
+print(Subset_Pair_X(A,a,X))
+            
\ No newline at end of file
diff --git a/UnsortedArray/Two_arrays_Same.py b/UnsortedArray/Two_arrays_Same.py
new file mode 100644
index 0000000..b846969
--- /dev/null
+++ b/UnsortedArray/Two_arrays_Same.py
@@ -0,0 +1,13 @@
+# find the two unsorted array is same if same returns true if not returns false
+
+def Array_Compare(arr1,arr2):
+    flag=False
+    if(len(arr1)==len(arr2)):
+        for x in arr1:
+            for y in arr2:
+                if(x==y):
+                    flag=True
+    return flag           
+arr1=[1,2,3,4,5,6,7]
+arr2=[1,2,3,4,5,6,7]
+print(Array_Compare(arr1,arr2))
\ No newline at end of file
diff --git a/UnsortedArray/array_conatain_perfectsquare.py b/UnsortedArray/array_conatain_perfectsquare.py
new file mode 100644
index 0000000..eba7457
--- /dev/null
+++ b/UnsortedArray/array_conatain_perfectsquare.py
@@ -0,0 +1,13 @@
+#find the elements of array whether it is perfect or not,if perfect print the perfect no
+import math
+def perfectsquare_array(a):
+    count=0
+    for i in a:
+        x=math.sqrt(i)
+        m=round(x)
+        if(m-x==0):
+            print(i)
+            count+=1
+    return count
+a=[1,2,3,4,6,16] 
+print(perfectsquare_array(a))
diff --git a/UnsortedArray/array_contains_x.py b/UnsortedArray/array_contains_x.py
new file mode 100644
index 0000000..002eb3f
--- /dev/null
+++ b/UnsortedArray/array_contains_x.py
@@ -0,0 +1,14 @@
+#Array Contains X
+def indexarray(arr,x):
+    index=-1
+    count=0
+    for i in arr:
+        if(i==x):
+            index=count
+            break
+        count+=1
+        
+    return index
+arr=[1,2,3,4,5,6,7]
+print(indexarray(arr,8))
+        
diff --git a/UnsortedArray/array_duplicate_removed.py b/UnsortedArray/array_duplicate_removed.py
new file mode 100644
index 0000000..898a678
--- /dev/null
+++ b/UnsortedArray/array_duplicate_removed.py
@@ -0,0 +1,7 @@
+#print the array without duplicates
+
+def array_no_duplicates(arr):
+    x=set(arr) 
+    
+arr=[1,1,2,2,3,4,5]
+print(array_no_duplicates(arr))
\ No newline at end of file
diff --git a/UnsortedArray/array_exe.py b/UnsortedArray/array_exe.py
new file mode 100644
index 0000000..971b28d
--- /dev/null
+++ b/UnsortedArray/array_exe.py
@@ -0,0 +1,9 @@
+#length of the Array Questions
+
+def lengthofarray(arr):
+    count=0
+    for _ in arr:
+        count+=1
+    return count
+arr=[1,2,3,4,5,6,2,1,3,4]
+print(lengthofarray(arr))
\ No newline at end of file
diff --git a/UnsortedArray/array_input_return_output.py b/UnsortedArray/array_input_return_output.py
new file mode 100644
index 0000000..6c302dc
--- /dev/null
+++ b/UnsortedArray/array_input_return_output.py
@@ -0,0 +1,7 @@
+def array_input_return_output(arr):
+    b=[]
+    for x in arr:       
+        b.append(x)
+    return b
+arr=[1,2,3,4,5]
+print(array_input_return_output(arr))
diff --git a/UnsortedArray/array_largest.py b/UnsortedArray/array_largest.py
new file mode 100644
index 0000000..958ab48
--- /dev/null
+++ b/UnsortedArray/array_largest.py
@@ -0,0 +1,10 @@
+#Find the largest array of an integer
+
+def Largest_Array(arr):
+    Init_Large=arr[0]
+    for x in arr:
+        if(x>Init_Large):
+            Init_Large=x
+    return Init_Large
+arr=[11,20,3,4,0]
+print(Largest_Array(arr))
diff --git a/UnsortedArray/array_morethan_once.py b/UnsortedArray/array_morethan_once.py
new file mode 100644
index 0000000..51e186a
--- /dev/null
+++ b/UnsortedArray/array_morethan_once.py
@@ -0,0 +1,12 @@
+#array contains more than once 
+def more_than_once(arr,x):
+    flag=False
+    count=0
+    for i in arr:
+        if i==x:
+            count+=1
+            if count>1:
+                flag=True
+    return flag
+arr=[5,2,7,3,1]
+print(more_than_once(arr,2))
\ No newline at end of file
diff --git a/UnsortedArray/array_return_evenno.py b/UnsortedArray/array_return_evenno.py
new file mode 100644
index 0000000..2cc6ca9
--- /dev/null
+++ b/UnsortedArray/array_return_evenno.py
@@ -0,0 +1,11 @@
+#return the even no in an array of elements
+
+def evenno_array(arr):
+    flag=False
+    for x in arr:
+        if(x%2==0):
+            flag=True
+            print(x)
+    return flag
+arr=[1,3,4,5,5,7,2,10]
+print(evenno_array(arr))
\ No newline at end of file
diff --git a/UnsortedArray/array_return_oddno.py b/UnsortedArray/array_return_oddno.py
new file mode 100644
index 0000000..f2ab515
--- /dev/null
+++ b/UnsortedArray/array_return_oddno.py
@@ -0,0 +1,7 @@
+#display the odd numbers in an array
+def oddno_array(arr):
+    for x in arr:
+        if not(x%2==0):
+            print(x)
+arr=[1,3,4,5,5,7,2,10]
+print(oddno_array(arr))
\ No newline at end of file
diff --git a/UnsortedArray/array_return_primeno.py b/UnsortedArray/array_return_primeno.py
new file mode 100644
index 0000000..02dbfbe
--- /dev/null
+++ b/UnsortedArray/array_return_primeno.py
@@ -0,0 +1,25 @@
+#return the no of primeno in an array
+import math
+def IsPrime(n):
+    flag=True
+    for i in range(2,n**1/2):
+        if(n%i==0):
+                flag=False
+                break                
+    return flag
+
+def array_contain_prime(arr):        
+        flag=False        
+        for x in arr:
+                if(IsPrime(x)):
+                        flag=True
+                        print(x)
+        return flag
+
+arr=[1,2,5,6,7,11,15]
+# arr = int(raw_input('Enter how many elements you want: '))
+# for i in range(0, arr):
+#     x = raw_input('Enter the numbers into the array: ')
+print(array_contain_prime(arr))
+
+
diff --git a/UnsortedArray/array_rev_order.py b/UnsortedArray/array_rev_order.py
new file mode 100644
index 0000000..6066d91
--- /dev/null
+++ b/UnsortedArray/array_rev_order.py
@@ -0,0 +1,17 @@
+#print the contents of the array of reverse in order
+
+# def Array_Reverse_Order(arr):
+#     b=[]
+#     x=arr[-1]
+#     y=arr[0]
+#     for z in range(x,y,-1):
+#         b.append(z)
+#     print(b)
+# arr=[1,2,3,4,5]
+# Array_Reverse_Order(arr)
+
+def reverse(a):
+    x=a[::-1]
+    print(x)
+a=[1,3,5,6,7,8]
+reverse(a)
\ No newline at end of file
diff --git a/UnsortedArray/array_reverse_order.py b/UnsortedArray/array_reverse_order.py
new file mode 100644
index 0000000..9b4b319
--- /dev/null
+++ b/UnsortedArray/array_reverse_order.py
@@ -0,0 +1,10 @@
+# array reverse order
+
+def reverse_order_array(array):
+        b=[]
+        for x in range(array[-1],array[0],-1):
+                b.append(x)
+        print(b)
+
+array=[1,2,3,4,5]
+reverse_order_array(array)
diff --git a/UnsortedArray/array_smallest.py b/UnsortedArray/array_smallest.py
new file mode 100644
index 0000000..d7b0d33
--- /dev/null
+++ b/UnsortedArray/array_smallest.py
@@ -0,0 +1,11 @@
+#Find the smallest array of an integer
+
+def Smallest_Array(arr):
+    Init_Small=arr[0]
+    for x in arr:
+        if(x<Init_Small):
+            Init_Small=x
+            
+    return Init_Small
+arr=[11,20,3,4,0]
+print(Smallest_Array(arr))
diff --git a/UnsortedArray/array_subset_indices_adds_x.py b/UnsortedArray/array_subset_indices_adds_x.py
new file mode 100644
index 0000000..3cd701e
--- /dev/null
+++ b/UnsortedArray/array_subset_indices_adds_x.py
@@ -0,0 +1,20 @@
+
+#42. Given an unsorted integer array A and a value X, check if there exists a subset of A of size two that adds upto X and print the indices of the values that adds upto X.
+import math
+def subset_return_index(a,b,c):
+        for x in a:
+                a.index(x)
+                for y in b:
+                        if(x+y==c):
+                                b.index(y)
+                                print x,y
+        return x,y
+a=[1,2,3,4,5]
+b=[1,2,3]
+c=5
+subset_return_index(a,b,c)
+
+
+
+
+
diff --git a/UnsortedArray/counttime_apperars_array.py b/UnsortedArray/counttime_apperars_array.py
new file mode 100644
index 0000000..a5d31e2
--- /dev/null
+++ b/UnsortedArray/counttime_apperars_array.py
@@ -0,0 +1,12 @@
+# count the no of times appears in the array
+
+def count_no_element_times(array):
+    count=0
+    for x in a:
+        for y in a:
+            if(x==y):
+                count+=1
+                print(y)
+        return count
+a=[1,2,3,4,5,6,1]
+count_no_element_times(a)    
\ No newline at end of file
diff --git a/UnsortedArray/countvalues_givenrange.py b/UnsortedArray/countvalues_givenrange.py
new file mode 100644
index 0000000..d00c7d7
--- /dev/null
+++ b/UnsortedArray/countvalues_givenrange.py
@@ -0,0 +1,13 @@
+# return the count of values with falls in a given range
+
+def Count_Values_Falls_Range(a):
+    flag=False    
+    for x in a:
+        for y in a:
+            if not (x==y):
+                flag=True
+    return y,flag
+a=[1,2,2,1,22,2,3]
+print(Count_Values_Falls_Range(a))
+
+
diff --git a/UnsortedArray/findX.py b/UnsortedArray/findX.py
new file mode 100644
index 0000000..95cb788
--- /dev/null
+++ b/UnsortedArray/findX.py
@@ -0,0 +1,9 @@
+def findX(arr,x):
+    flag=False
+    for a in arr:
+        if(arr[a]==x):
+            flag=True
+            print'x is availble in array'
+    return flag
+arr=[1,2,3,4,4,5,6]
+print(findX(arr,8))
\ No newline at end of file
diff --git a/UnsortedArray/indices_which_adds_x.py b/UnsortedArray/indices_which_adds_x.py
new file mode 100644
index 0000000..9f8c5ba
--- /dev/null
+++ b/UnsortedArray/indices_which_adds_x.py
@@ -0,0 +1,22 @@
+#Return the Indices of Values which adds upto x
+
+
+def Subset_Pair_X(A,a,X):    
+    for x in A:
+        for y in a:
+            if(x+y==X):
+                print x,y
+    return 0             
+def subset_adds_return_indices(array1,array2,x):
+    Count=0
+    for x in array1:
+        for y in array2:
+            if(Subset_Pair_X(array1,array2,x)==True):
+                Count+=1
+                print(array1[x],array2[y])
+    return False
+array1=[1,2,3,4,5]
+array2=[1,3,5,6]
+x=4
+subset_adds_return_indices(array1,array2,x)
+    
diff --git a/UnsortedArray/kth_largest_array.py b/UnsortedArray/kth_largest_array.py
new file mode 100644
index 0000000..fd6c81e
--- /dev/null
+++ b/UnsortedArray/kth_largest_array.py
@@ -0,0 +1,8 @@
+# find the elements in array by considering the kth largest
+
+def kth_largest(a):
+    a.sort()
+    k=int(input('enter element k'))
+    return(a[-k])
+a=[1,2,3,4,8,7,9,10,11,6]
+print(kth_largest(a))
\ No newline at end of file
diff --git a/UnsortedArray/kthsmallest_Array.py b/UnsortedArray/kthsmallest_Array.py
new file mode 100644
index 0000000..d11ddf2
--- /dev/null
+++ b/UnsortedArray/kthsmallest_Array.py
@@ -0,0 +1,9 @@
+def kthSmallest_Array(a):
+    a.sort()
+    k=input('enter the input')
+    return a[k-1]
+#a = int(raw_input('Enter how many elements you want: '))
+#for i in range(0, a):
+ #   x = raw_input('Enter the numbers into the array: ')
+a=[4,10,23,12,11]
+print(kthSmallest_Array(a))
\ No newline at end of file
diff --git a/UnsortedArray/leftby1position.py b/UnsortedArray/leftby1position.py
new file mode 100644
index 0000000..4b982bf
--- /dev/null
+++ b/UnsortedArray/leftby1position.py
@@ -0,0 +1,9 @@
+#Left by one Position in array 
+
+def Rotate_Left_one_position(array):
+    x=array.pop(0)
+    array.append(x)    
+    return array
+array=[1,2,34,5]
+
+print(Rotate_Left_one_position(array))
diff --git a/UnsortedArray/loc_of_array_value.py b/UnsortedArray/loc_of_array_value.py
new file mode 100644
index 0000000..7244198
--- /dev/null
+++ b/UnsortedArray/loc_of_array_value.py
@@ -0,0 +1,12 @@
+#exercise 6
+
+def loc_Array_value(arr,x):
+    index=0
+    count=0
+    for i in arr:
+        if(i==x):
+            index=count
+        count+=1
+    return index
+arr=[1,2,3,5,5,2,1,4]
+print(loc_Array_value(arr,5))
\ No newline at end of file
diff --git a/UnsortedArray/meanarray.py b/UnsortedArray/meanarray.py
new file mode 100644
index 0000000..b0487a3
--- /dev/null
+++ b/UnsortedArray/meanarray.py
@@ -0,0 +1,11 @@
+def meanArray(x):
+    sum1=0
+    count=0
+    mean=0
+    for i in x:
+        sum1+=i
+        count+=1
+        mean=sum1/count
+    return mean
+x=[7,9,8]
+print(meanArray(x))
\ No newline at end of file
diff --git a/UnsortedArray/mode_array.py b/UnsortedArray/mode_array.py
new file mode 100644
index 0000000..a43aafc
--- /dev/null
+++ b/UnsortedArray/mode_array.py
@@ -0,0 +1,20 @@
+def mode_array(arr):
+    count=0
+    countmax=0  
+    mode=0  
+    for i in arr:
+        count=0
+        for j in arr:
+            if(i==j):
+                count+=1
+
+        if(count>countmax):
+            countmax=count
+            mode=i
+
+    return mode
+arr=[5,8,3,2,3,3,3,2,6,9]
+print(mode_array(arr))
+            
+            
+
diff --git a/UnsortedArray/number_times_largest_found.py b/UnsortedArray/number_times_largest_found.py
new file mode 100644
index 0000000..e62ac11
--- /dev/null
+++ b/UnsortedArray/number_times_largest_found.py
@@ -0,0 +1,19 @@
+#found the no of times largest integer is found in array
+
+def Largest_Array(arr):
+    Init_Large=arr[0]
+    for x in arr:
+        if(x>Init_Large):
+            Init_Large=x
+    return Init_Large
+
+def Largest_Array_Count(arr):
+    count=0
+    for x in arr:
+        if(Largest_Array(arr)==x):
+            count+=1
+        
+    return count,Largest_Array(arr)
+arr=[1,2,3,4,5,5,5,1]
+print(Largest_Array_Count(arr))
+
diff --git a/UnsortedArray/number_times_x.py b/UnsortedArray/number_times_x.py
new file mode 100644
index 0000000..8007173
--- /dev/null
+++ b/UnsortedArray/number_times_x.py
@@ -0,0 +1,14 @@
+#return the no of times found in x
+
+def number_times(arr,x):
+    count=0
+    
+    for i in arr:
+        if i==x:
+            count+=1        
+    return count   
+arr=[1,2,3,4,3,1]
+
+print(number_times(arr,1))
+
+        
\ No newline at end of file
diff --git a/UnsortedArray/numer_Smallest_array_found.py b/UnsortedArray/numer_Smallest_array_found.py
new file mode 100644
index 0000000..f6174eb
--- /dev/null
+++ b/UnsortedArray/numer_Smallest_array_found.py
@@ -0,0 +1,15 @@
+#found the no of times smallest integer is found in array
+def smallest_count(array):
+    smallest=array[0]
+    count=0
+    for arr in array:               
+        if(arr<smallest):
+            arr=smallest
+            count+=1
+    return count
+array=[5,8,7,1,2,3,2,1,1,1]
+print(smallest_count(array))
+
+            
+
+
diff --git a/UnsortedArray/palindrome.py b/UnsortedArray/palindrome.py
new file mode 100644
index 0000000..f38b508
--- /dev/null
+++ b/UnsortedArray/palindrome.py
@@ -0,0 +1,13 @@
+#check if the array A is a palindrome or not.
+
+def palindrome(A):
+    x=A[::-1]
+    if(x==A):
+        print'1'
+            
+    return 0    
+A=[1,2,1]
+(palindrome(A))
+
+
+
diff --git a/UnsortedArray/rightby1position.py b/UnsortedArray/rightby1position.py
new file mode 100644
index 0000000..0767cdd
--- /dev/null
+++ b/UnsortedArray/rightby1position.py
@@ -0,0 +1,10 @@
+#return the contents of the array rotate by right one position
+
+def Rotate_Right_one_position(array):
+    x=array.pop(-1)
+    array.insert(0,x)
+    return array
+array=[1,2,34,5]
+print(Rotate_Right_one_position(array))
+    
+        
\ No newline at end of file
diff --git a/UnsortedArray/secondlargest_smallest_array.py b/UnsortedArray/secondlargest_smallest_array.py
new file mode 100644
index 0000000..6cf21a3
--- /dev/null
+++ b/UnsortedArray/secondlargest_smallest_array.py
@@ -0,0 +1,15 @@
+# print the second largest element and second smallest element in array
+
+def Smallest_Array_Second(a,k):
+        a.sort()
+        count=0
+        for x in a:
+                
+                count+=1
+                if(count==k):
+                        print(x)
+a=[25,4,57,8,12]
+k=2
+Smallest_Array_Second(a,k)        
+
+
diff --git a/UnsortedArray/subset_adds_x_values_variations.py b/UnsortedArray/subset_adds_x_values_variations.py
new file mode 100644
index 0000000..1f46131
--- /dev/null
+++ b/UnsortedArray/subset_adds_x_values_variations.py
@@ -0,0 +1,14 @@
+#a subset of A of size two that adds upto X and print the values that adds upto X.
+
+def subset_adds_values(a,A,x):    
+    for i in a:
+        for j in A:
+            if i+j==x:
+                print(i,j)
+a=[1,2,3,4,5]
+A=[15,3,2]
+x=20
+print(subset_adds_values(a,A,x))
+
+#notes:
+#sum function does not applied due to error results
diff --git a/UnsortedArray/sumelementsa.py b/UnsortedArray/sumelementsa.py
new file mode 100644
index 0000000..613bb55
--- /dev/null
+++ b/UnsortedArray/sumelementsa.py
@@ -0,0 +1,9 @@
+# sum of all elements in a
+
+def sumArray(arr):
+    sum=0
+    for x in arr:
+        sum=sum+x
+    return sum
+arr=[1,2,3,4,5,9]
+print(sumArray(arr))
\ No newline at end of file
diff --git a/UnsortedArray/tworightbyposition.py b/UnsortedArray/tworightbyposition.py
new file mode 100644
index 0000000..2a1105c
--- /dev/null
+++ b/UnsortedArray/tworightbyposition.py
@@ -0,0 +1,14 @@
+# return the array contents after rotating right two position
+
+def Rotate_Right_Two_position(array):
+    count=0
+    for x in array:
+        x=array.pop(-1)
+        array.insert(0,x)
+        count+=1
+        if(count==2):
+            break
+    return array
+array=[1,2,34,5]
+print(Rotate_Right_Two_position(array))
+    
\ No newline at end of file
diff --git a/UnsortedArray/values_count_lessthan.py b/UnsortedArray/values_count_lessthan.py
new file mode 100644
index 0000000..beaabbb
--- /dev/null
+++ b/UnsortedArray/values_count_lessthan.py
@@ -0,0 +1,12 @@
+#return the count of values less than or equal to x
+
+def Count_Values_x(array,k):
+    count=0
+    for x in array:
+        if(x>k):
+            count+=1
+    return count
+array=[1,4,8,12,4,6,2]
+k=2
+print(Count_Values_x(array,k))
+                

From 3a99d146cc7481a65c16d74a85bc6cf010ab3f34 Mon Sep 17 00:00:00 2001
From: Maria <46182261+Maria16pca111@users.noreply.github.com>
Date: Fri, 12 Apr 2019 10:43:15 +0530
Subject: [PATCH 2/2] Set theme jekyll-theme-leap-day

---
 _config.yml | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 _config.yml

diff --git a/_config.yml b/_config.yml
new file mode 100644
index 0000000..b849713
--- /dev/null
+++ b/_config.yml
@@ -0,0 +1 @@
+theme: jekyll-theme-leap-day
\ No newline at end of file