python int to binary and count the number of 1

import collections
class Solution(object):
    def hammingWeight(self,n):
        """

        :param n:int
        :return: int
        """
        k="{0:b}".format(n)
        m=collections.Counter(k)
        return m['1']

p=Solution()
print p.hammingWeight(11)
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Write a program to 1.Setup a simulating backing store in memory. Read the data from pdata.bin to this backing store. 2.Initialize a page table for process p, set the frame number to be -1 for each page, indicating that the page is not loaded into memory yet. 3.Read logical addresses one by one from la.txt. 4.For each logical address, a)if its page has been loaded into physical memory, simply find the frame number in the page table, then generate physical address, find and print out the physical address and data inside this address. b)if the page is used for the first time, i.e., in page table, its frame number is -1,then the page that contains this address should be loaded into a free frame in physical memory (RAM). Then update the page table by adding the frame number to the right index in the page table. Then repeat 4a). Assumption: 1.Assume the file la.txt includes the sequence of generated addresses from CPU. 2.Use a part of memory as backing store that store data for a process. 3.The backing store size is 128 bytes 4.The size of process p is 128 bytes. 5.The contents of p is included in a file pdata.bin which is a binary file. 6.Use a part of memory as RAM. The size of physical memory is 256 bytes, from 0 to 255. All the physical memory is available, allocating starting from beginning in sequence. That is, allocate frame 0 first, then frame 1, then frame 2…. 7.The size of a frame is 32 bytes, i.e., 5 bits for the offset in a frame, total number of frames is 8. At beginning, no page table is available for process p.
05-24
Here is a sample program that implements the steps you described: ```python BACKING_STORE_SIZE = 128 PHYSICAL_MEMORY_SIZE = 256 PAGE_SIZE = 32 NUM_FRAMES = PHYSICAL_MEMORY_SIZE // PAGE_SIZE # Initialize backing store backing_store = bytearray(BACKING_STORE_SIZE) with open("pdata.bin", "rb") as f: pdata = f.read() backing_store[:len(pdata)] = pdata # Initialize page table page_table = [-1] * (BACKING_STORE_SIZE // PAGE_SIZE) # Initialize physical memory physical_memory = [bytearray(PAGE_SIZE) for _ in range(NUM_FRAMES)] # Read logical addresses from la.txt with open("la.txt", "r") as f: for line in f: logical_address = int(line.strip()) page_number = logical_address // PAGE_SIZE offset = logical_address % PAGE_SIZE # Check if page is already in physical memory frame_number = page_table[page_number] if frame_number != -1: physical_address = frame_number * PAGE_SIZE + offset data = physical_memory[frame_number][offset] print("Physical address:", physical_address, "Data:", data) # If page is not in physical memory, load it else: # Find a free frame in physical memory frame_number = None for i in range(NUM_FRAMES): if page_table.count(i) == 0: frame_number = i break if frame_number is None: print("Error: no free frame available in physical memory") break # Load page from backing store to physical memory page_start = page_number * PAGE_SIZE page_data = backing_store[page_start:page_start + PAGE_SIZE] physical_memory[frame_number][:] = page_data # Update page table page_table[page_number] = frame_number # Print physical address and data physical_address = frame_number * PAGE_SIZE + offset data = physical_memory[frame_number][offset] print("Physical address:", physical_address, "Data:", data) ``` Here is an overview of how the program works: 1. The program initializes the backing store by reading the contents of `pdata.bin` into a byte array. It also initializes the page table with -1 values, indicating that no pages are loaded into physical memory yet. 2. The program creates a byte array for each frame in physical memory, and initializes them all to 0. 3. The program reads logical addresses from `la.txt` one by one. 4. For each logical address, the program computes the page number and offset. 5. If the page is already loaded into physical memory (i.e., its frame number is not -1), the program computes the physical address and reads the data from the corresponding byte array in physical memory. 6. If the page is not yet loaded into physical memory, the program searches for a free frame, loads the page from the backing store to the frame, updates the page table with the frame number, and then reads the data from the corresponding byte array in physical memory. 7. The program prints the physical address and data for each logical address. Note that this program assumes that there is always at least one free frame in physical memory. If there are no free frames, the program will print an error message and stop.
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值