Offer to review (Simple 2)

Implement a function that takes an integer and outputs the number of 1s in the binary representation of that number. For example, 9 in binary is 1001 with two bits of 1. Therefore, if the input is 9, the function outputs 2.

Example 1:

Input: 00000000000000000000000000001011 output: 3: input binary string in 00000000000000000000000000001011, a total of three for the ‘1’. Example 2:

Input: 00000000000000000000000010000000 output: 1: input binary string in 00000000000000000000000010000000, a total of a ‘1’. Example 3:

Input: 11111111111111111111111111111101 output: 31 explanation: input binary string in 11111111111111111111111111111101, a total of 31 to ‘1’.

Answer:

java

public class Solution {
    // you need to treat n as an unsigned value
    int count = 0;
    public int hammingWeight(int n) {
        for(int i = 0; i < 32; i++){
            if(((n >>> i) & 1) = =1){ count++; }}returncount; }}Copy the code

python

class Solution(object):
    def hammingWeight(self, n):
        """
        :type n: int
        :rtype: int
        """
        res = 0
        while n:
            res += n & 1
            n >>= 1
        return res
Copy the code

Given a head pointer to a one-way linked list and the value of a node to delete, define a function to delete that node.

Returns the head node of the deleted list.

Note: this question has been changed from the original question

Example 1:

Input: head = [4,5,1,9], val = 5 Output: [4,1,9] Example 2:

Input: head = [4,5,1,9], val = 1 Output: [4,5,9]

If so, change the next point of the current node to the next point to the node. If the first point is to be deleted, return p.ext

java

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; }} * * /
class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        ListNode p = head;
        if(p.val == val) return p.next;
        while(p.next! =null){if(p.next.val == val){
                p.next =p.next.next;
                return head;
            }
            else{ p = p.next; }}returnhead; }}Copy the code

python

# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
    def deleteNode(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        p = head
        if p.val == val:
            return p.next
        while p.next :
            if p.next.val == val:
                
                p.next = p.next.next
                return head
            else:
                p = p.next
Copy the code

Input a linked list, output the last KTH node of the list. In order to conform to the convention of most people, this case counts from 1, i.e. the last node of the list is the last node from the last. For example, a linked list has six nodes, starting with the head node, whose values are 1, 2, 3, 4, 5, and 6. The third from last node of the list is the node with the value 4.

Example:

Given a linked list: 1->2->3->4->5, and k = 2.

Return to list 4->5.

When the pointer is quickly full, one goes k first, the other does not, and then goes together, knowing that the one that goes first is empty.

java

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; }} * * /
class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        ListNode m = head;
        ListNode n = head;

        for(int i=0; i<k; i++){ m = m.next; }while(m! =null){ m = m.next; n = n.next; }returnn; }}Copy the code

python

# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None

class Solution(object):
    def getKthFromEnd(self, head, k):
        """
        :type head: ListNode
        :type k: int
        :rtype: ListNode
        """
        m = head
        n = head

        for i in range(k):
            m = m.next
        while m :
            m = m.next
            n = n.next
        return n
Copy the code