Vivo X60 Pro Price in India, Specifications, Features, Pros and Cons
Vivo has launched its new X series phone.
The X series is one of the most popular series of Vivo and many people love this series.
Vivo phones are good but the price of them is a bit high but the Vivo customers don't have any issue with the price.
The Vivo fans buy there phones no matter what are the specifications and what and how high is the price of the existing phone.
The phone is overpriced as we see the specs of the phone.
For this price, you can get a flagship phone with the powerful SoC ever build (Qualcomm Snapdragon 888)
But I know that Vivo has a different audience so they will definitely buy this phone.
Vivo X60 Pro is good for those who want good looking phone and high storage.
Special Features:
Specification of Vivo X60 Pro :
| Vivo X60 Pro | |
|---|---|
| Network | GSM / CDMA / HSPA / LTE / 5G |
| 2G bands |
GSM 850 / 900 / 1800 / 1900 CDMA 800 & TD-SCDMA |
| 3G bands | HSDPA 850 / 900 / 1700(AWS) / 1900 / 2100 |
| 4G bands | 1, 2, 3, 4, 5, 7, 8, 12, 17, 18, 19, 25, 26, 28, ,34, 38, 39, 40, 41 |
| 5G bands | 1, 3, 28, 41, 77, 78, 79 SA/NSA |
| Speed | HSPA 42.2/5.76 Mbps, LTE-A, 5G |
| OS and Hardware |
|
|---|---|
| OS | Android 11, Origin OS |
| Processor | Octa-core (1x2.8 GHz & 3x2.6 GHz & 4x2.0GHz) |
| Chipset | Exynos 1080 |
| Process technology | 5nm |
| GPU | Mali G78 |
| General | |
|---|---|
| Brand | Vivo |
| Released Date | 8th January 2021 |
| Launched in India | Not yet |
| Model | Vivo X60 Pro |
| Custom UI | Origin OS |
| Charger Speed | 33W charger in the box |
| Sim size | Nano (Both slots) |
| Body | |
|---|---|
| Dimensions | 158.7 x 73.2 x 7.6 mm |
| Weight | 178 g |
| Colors | Huacai, Force |
| Build | Glass front, glass back, aluminum frame |
| SIM | Dual sim slot |
| Display | |
|---|---|
| Type |
AMOLED display HDR10+ |
| Screen Size | 6.56 inches |
| Resolution | 1080 x 2376 pixels (FHD+) |
| Multitouch | Yes |
| Storage | |
|---|---|
| Memory Card slot | No |
| Variants | 12/256 GB |
| Internal storage type | UFS 3.1 |
| RAM | 12 GB |
| Camera |
|
|---|---|
| Rear camera |
48 MP, f/1.8 (wide) 13 MP, f/2.2 (ultrawide) 13 MP, f/2.4 (portrait) 8 MP, f/2.4 (telephoto) |
| Video quality |
4K: 30fps 1080p: 30,60fps Gyro-EIS |
| Front camera | 32 MP, f/2.4 (wide) |
| Video quality | 1080p: 30fps |
| Battery and Power | |
|---|---|
| Type | Non-removable Li-Po 4200 mAh battery |
| Charger Speed | 33W |
| Charging speed supported | 33W |
| Connectivity | |
|---|---|
| WiFi | Wi-Fi 802.11 a/b/g/n/ac/6, dual band WiFi |
| Bluetooth | Yes, Version 5.1 |
| GPS | Yes |
| Radio | No |
| USB | Yes, Type C |
| Loudspeaker | Yes |
| 3.5mm jack | No |
| Special Features | |
|---|---|
| Fingerprint sensor | Yes |
| Fingerprint sensor position | Under display |
| Other sensors | Gyroscope, Accelerometer, Proximity, Compass |
| Price | |
|---|---|
| Indian Rs. | 12/256: Rs. 50,775 |
| US Dollar | 12/256: $695 |
| Chinese Yuan | 12/256: ¥4,498 |
Colors of Vivo X60 Pro
|
| Huacai |
 |
| Force |
Pros and Cons
Pros
- 5G supported
- Flagship SoC (Exynos 1080)
- Flash charger (33W)
- Under display fingerprint
- Light weight (178 g)
- WiFi 6 available
- AMOLED display
Cons
- No MicroSD card slot
- No 3.5mm jack
- No Radio
- Small battery (4200 mAh)
Practical 1: Abstract Data Type
Practical 2: Singly linked list with
Insertion, Traversal operation
Practical 3: Singly linked list with
Insertion, Deletion and Traversal Operation
Practical 4: Doubly linked list with
Insertion, Deletion and Traversal Operation
Practical 5: Queue with Insertion,
Deletion and Traversal operation
Practical 6: Priority Queue
with Insertion, Deletion and Traversal operation
Practical 7: Implementation of BST with
Insertion, Deletion and Traversal operation
Practical 8: Binary Tree with
Insertion operation
Pract 1 Abstract Data Type:
def create_stack():
stack = []
return stack
def check_empty(stack ):
return len(stack)
== 0
def push(stack, item):
stack.append(item)
print("Pushed Item : " + item)
def pop(stack):
if
check_empty(stack):
return
"Stack is empty."
return stack.pop()
stack = create_stack()
push(stack, str(1))
push(stack, str(2))
push(stack, str(3))
push(stack, str(4))
print("Popped Item : " + pop(stack))
print("Stack after popping an element : " +
str(stack))
Pract 2 Singly linked
list with Insertion, Traversal operation:
class Node:
def __init__(self,
dataval=None):
self.dataval =
dataval
self.nextval =
None
class SLinkedList:
def __init__(self):
self.headval =
None
def listprint(self):
printval =
self.headval
while printval is
not None:
print(printval.dataval)
printval =
printval.nextval
def AtBegining(self,
newdata):
NewData =
Node(newdata)
NewData.nextval =
self.headval
self.headval =
NewData
list = SLinkedList()
list.headval = Node("MON")
e2 = Node("TUE")
e3 = Node("WED")
list.headval.nextval = e2
e2.nextval = e3
list.AtBegining("SUN")
list.listprint()
Pract 3 Singly linked
list with Insertion, Deletion and Traversal Operation
#Node class
class Node:
#Constructor to initialize the node object
def
__init__(self,data):
self.data = data
self.next = None
class LinkedList:
#Functin to
initialise head
def
__init__(self):
self.head = None
#Function
to insert new node at the beginning
def
push(self, new_data):
new_node = Node(new_data)
new_node.next = self.head
self.head = new_node
#Given a
reference to head of a list and a key,
#Delete the
first occurence of key in linked list
def
deleteNode(self, key):
#Store head node
temp = self.head
#If head node itself holds the key to be deleted
if (temp is not None):
if (temp.data
== key):
self.head = temp.next
temp = None
return
#Search for
the key to be deleted,kep track of the previous node as we need to change 'prev.next'
while(temp is
not None):
if
temp.data == key:
break
prev = temp
temp = temp.next
#If key was
not present in linked list
if(temp ==
None):
return
#Unlink the node from linked list
prev.next =
temp.next
temp = None
#Utility
function to print the linked LinkedList
def
printList(self):
temp = self.head
while (temp):
print("%d" %(temp.data)),
temp =
temp.next
#Driver program
llist = LinkedList()
llist.push(8)
llist.push(1)
llist.push(3)
llist.push(2)
print ("Created Linked List: ")
llist.printList()
llist.deleteNode(8)
print("\nLinked List after Deletion of: ")
llist.printList()
Pract 4 Doubly linked
list with Insertion, Deletion and Traversal Operation:
class Node:
def __init__(self,
data):
self.data =
data
self.next =
None
self.prev =
None
class DoublyLinkedList:
def
__init__(self):
self.start_node = None
def
InsertToEmptyList(self, data):
if
self.start_node is None:
self.start_node = Node(data)
return
else:
print("List is not empty.")
def
InsertAtEnd(self, data):
if
self.start_node is None:
self.start_node = Node(data)
return
n =
self.start_node
while n.next
is not None:
n = n.next
n.next =
Node(data)
n.next.prev =
n
def
DeleteAtStart(self):
if
self.start_node is None:
print("List is empty, no element to delete.")
return
if
self.start_node.next is None:
self.start_node = None
return
self.start_node = self.start_node.next
self.start_node.prev = None
def
DeleteAtEnd(self):
if self.start_node
is None:
print("List is empty, no element to delete.")
return
if
self.start_node.next is None:
self.start_node = None
return
n =
self.start_node
while n.next
is not None:
n = n.next
n.prev.next =
None
def Display(self):
if
self.start_node is None:
print("List is empty, no elements to display.")
else:
n =
self.start_node
while n is
not None:
print(n.data)
n =
n.next
list = DoublyLinkedList()
list.InsertToEmptyList(10)
list.InsertAtEnd(20)
list.InsertAtEnd(30)
list.InsertAtEnd(40)
list.InsertAtEnd(50)
list.InsertAtEnd(60)
print("Created Linked List :")
list.Display()
list.DeleteAtStart()
list.DeleteAtEnd()
print("Linked List after deleting start and end element
:")
list.Display()
Pract 5 Queue with
Insertion, Deletion and Traversal operation:
class Queue:
def __init__(self):
self.queue=[]
def
enqueue(self,item):
self.queue.append(item)
def dequeue(self):
if
len(self.queue)<1:
return
None
return
self.queue.pop(0)
def display(self):
print(self.queue)
def size(self):
print(len(self.queue))
q=Queue()
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
q.enqueue(4)
q.enqueue(5)
q.enqueue(6)
q.enqueue(7)
q.enqueue(8)
q.enqueue(9)
q.enqueue(10)
print("After Adding An Element")
q.display()
print("Initial Size of queue")
q.size()
q.dequeue()
print("After Removing an element")
q.display()
print("After Popping element size of Queue: ")
q.size()
Pract 6 Priority Queue with Insertion,
Deletion and Traversal operation:
class PriorityQueue(object):
def
__init__(self):
self.queue = []
def
__str__(self):
return '-'.join([str(i) for i in self.queue])
#Check if
the queue is empty or not
def
isEmpty(self):
return len(self.queue) == 0
#Insert
some elements in the queue
def
insert(self,data):
self.queue.append(data)
#Pop(delete) an element based on high priority
def
delete(self):
try:
max_val = 0
for i in
range(len(self.queue)):
if
self.queue[i]>self.queue[max_val]:
max_val
= i
item =
self.queue[max_val]
del
self.queue[max_val]
return item
except IndexError:
print()
exit()
if __name__ == '__main__':
myQueue =
PriorityQueue()
myQueue.insert(12)
myQueue.insert(1)
myQueue.insert(14)
myQueue.insert(7)
myQueue.insert(21)
myQueue.insert(10)
print(myQueue)
while not
myQueue.isEmpty():
print(myQueue.delete())
Pract 7 Implementation
of BST with Insertion, Deletion and Traversal operation:
class Node:
def
__init__(self, key):
self.left
= None
self.right
= None
self.val
= key
def insert(root, key):
if root
is None:
return
Node(key)
else:
if
root.val == key:
return
root
elif
root.val < key:
root.right
= insert(root.right, key)
else:
root.left
= insert(root.left, key)
return
root
def inorder(root):
if
root:
inorder(root.left)
print(root.val)
inorder(root.right)
r = Node(50)
r = insert(r, 30)
r = insert(r, 20)
r = insert(r, 40)
r = insert(r, 70)
r = insert(r, 60)
r = insert(r, 80)
inorder(r)
Pract 8 Binary
Tree with Insertion operation:
class Tree:
def
__init__(node,value):
node.value = value
node.left = None
node.right = None
def
Inorder(node,Root):
if(Root is None):
return
node.Inorder(Root.left)
print(Root.value,end = '')
node.Inorder(Root.right)
def
Insert(node,value):
if node is None:
node =
Tree(value)
elif value < node.value:
if node.left is
None:
node.left = Tree(value)
else:
node.left.Insert(value)
else:
if node.right
is None:
node.right = Tree(value)
else:
node.right.Insert(value)
def Delete(node,temp,value):
if value < node.value:
temp = node
node.left.Delete(temp,value)
elif(value > node.value):
temp = node
node.right.Delete(temp,value)
else:
if (node.left
is None and node.right is None):
if(temp.left == node):
temp.left
= None
else:
temp.right = None
node = None
elif node.right is None:
if(temp.left == node):
temp.left = node.left
else:
temp.right = node.left
node = None
elif node.left
is None:
if(temp.left == node):
temp.left = node.right
else:
temp.right = node.right
node
= None
else:
temp = node.right
while(temp.left is not None):
temp = temp.left
node.value = temp.value
node.right.Delete(temp,temp.value)
Root = Tree(6)
Root.Insert(4)
Root.Insert(2)
Root.Insert(5)
Root.Insert(9)
Root.Insert(8)
Root.Insert(10)
print("Inorder traversal after insertion: ",end =
'')
Root.Inorder(Root)
Root.Delete(Root,2)
print("\n 2 is deleted: ", end = '')
Root.Inorder(Root)
Root.Delete(Root,4)
print("\n 4 is deleted: ", end = '')
Root.Inorder(Root)
Root.Delete(Root,6)
print("\n 6 is deleted: ", end = '')
Root.Inorder(Root)