Почему мой оператор по модулю возвращает удвоенный размер блока для входных данных размером 1 байт?

Question

Идея состоит в том, чтобы создать функцию под названием калькулятор, которая принимает входные данные и сравнивает их с переменной. Сравните размер файла с размером блока и, если есть остаток, удвойте размер блока, чтобы учесть его использование. Моя проблема в том, что при вводе 1 я все равно получаю 8192? Однако остальные расчеты оказались верными. Я знаю, что деление этажа дает только целое число, а не число с плавающей запятой (что, как я думал, может быть лучшим способом сделать это, потому что мне нужно было действительное число), но когда я пытаюсь переместить его, я получаю тот же результат. Я также пробовал плавать в другом месте, но с неверными или теми же результатами, что и выше. Когда я изменил порядок по модулю, ответ кажется правильным, но мне сообщили, что это неверно, и мне сказали сделать это больше, чем вы видите здесь, с разделением этажей и модулем в этом порядке.

Итак, мой вопрос: почему я получаю 8192 при вводе 1, а остальные верны?

def calculator(somedata):                 # calculator function, 'somedata' is the input
    blocksize = 4096                      # what block size on the partition
                                          # calculate how many blocks are fully occupied
    fullblock = somedata // blocksize     # floor division will give back only the integer yes?
                                          # modulo to check whether there's any remainder
    bytesremain = somedata % blocksize    # which will say 1 or None unless I float yes?
                                          # return the block usage based on byte count?
    if bytesremain > 0:                   # if there's anything left over in the bytesremain
      return(blocksize * 2)               # double the block usage to 2
    return blocksize                      # otherwise return the block usage

print(calculator(1))                      # Should be 4096 
print(calculator(4096))                   # Should be 4096 
print(calculator(4097))                   # Should be 8192 
print(calculator(6000))                   # Should be 8192

Answer 1

Вы наверняка ищете:

def calculator(somedata):
    blocksize = 4096
    fullblock = (somedata-1) // blocksize 
    return blocksize*(fullblock+1)

Answer 2

full_blocks = filesize // block_size 

partial_block_remainder = block_size % filesize

Answer 3

      def calculate_storage(filesize):
    block_size = 4096
    # Use floor division to calculate how many blocks are fully occupied
    full_blocks = filesize // block_size
    # Use the modulo operator to check whether there's any remainder
    partial_block_remainder = filesize % block_size
    # Depending on whether there's a remainder or not, return
    # the total number of bytes required to allocate enough blocks
    # to store your data.
    if partial_block_remainder > 0:
        return full_blocks * block_size + block_size
    return full_blocks * block_size

Answer 4

def calculate_storage(filesize):
    block_size = 4096
    # Use floor division to calculate how many blocks are fully occupied
    full_blocks = filesize // block_size
    # Use the modulo operator to check whether there's any remainder
    partial_block_remainder = filesize % block_size
    # Depending on whether there's a remainder or not, return
    # the total number of bytes required to allocate enough blocks
    # to store your data.
    if partial_block_remainder > 0:
        return block_size*(full_blocks+1)
    return block_size

print(calculate_storage(1))    # Should be 4096
print(calculate_storage(4096)) # Should be 4096
print(calculate_storage(4097)) # Should be 8192
print(calculate_storage(6000)) # Should be 8192

Answer 5

def calculate_storage(filesize):
    block_size = 4096

    # Use floor division to calculate how many blocks are fully occupied
    full_blocks = filesize//block_size

    # Use the modulo operator to check whether there's any remainder
    partial_block_remainder = filesize%block_size

    # Depending on whether there's a remainder or not, return
    # the total number of bytes required to allocate enough blocks
    # to store your data.
    if partial_block_remainder > 0:
        return (full_blocks*4096)+4096
    return (full_blocks*4096)

print(calculate_storage(1))    # Should be 4096
print(calculate_storage(4096)) # Should be 4096
print(calculate_storage(4097)) # Should be 8192
print(calculate_storage(6000)) # Should be 8192

Answer 6

      def calculate_storage(filesize):
    block_size = 4096
    full_blocks = filesize//block_size
    if filesize > block_size:
        return block_size*2
    return block_size

Думаю, это лучшее решение для всех случаев в формате файлов!

Answer 7

Something else to remember here
is the format of modulo arithmetic. The divisor is always to
the right of the modulo operator. E.g.- 2 = 6 % 4 <- This is
the divisor.   

 def calculate_storage(filesize):
        block_size = 4096
        # Use floor division to calculate how many blocks are fully occupied
        full_blocks = filesize//block_size
        # Use the modulo operator to check whether there's any remainder
        partial_block_remainder = block_size%filesize
        # Depending on whether there's a remainder or not, return
        # the total number of bytes required to allocate enough blocks
        # to store your data.
        if partial_block_remainder > 0:
            return block_size*2
        return block_size
    
    print(calculate_storage(1))    # Should be 4096
    print(calculate_storage(4096)) # Should be 4096
    print(calculate_storage(4097)) # Should be 8192
    print(calculate_storage(6000)) # Should be 8192

Answer 8

<pre><code>
def cstorage(fsize):
    bsize = 4096
    fblocks = fsize // bsize

    pbremainder = fsize % bsize

    if pbremainder > 0:
        return bsize*(fblocks+1)
    return bsize*fblocks

print(cstorage(1))  
print(cstorage(4096))
print(cstorage(4097)) 
print(cstorage(6000))
</pre></code>

Answer 9

Я пробовал следующее:

      import math
def calculate_storage(filesize):
    block_size = 4096
    full_blocks = math.ceil(filesize/block_size)
    return full_blocks*block_size


print(calculate_storage(1))    
print(calculate_storage(4096)) 
print(calculate_storage(4097)) 
print(calculate_storage(9000)) 

Answer 10

      def calculate_storage(filesize):
    block_size = 4096
    # Use floor division to calculate how many blocks are fully occupied
    full_blocks = filesize // block_size
    # Use the modulo operator to check whether there's any remainder
    partial_block_remainder = filesize % block_size
    # Depending on whether there's a remainder or not, return
    # the total number of bytes required to allocate enough blocks
    # to store your data.
    if partial_block_remainder > 0 and full_blocks >= 1:
        return block_size * 2
    return block_size

print(calculate_storage(1))    # Should be 4096
print(calculate_storage(4096)) # Should be 4096
print(calculate_storage(4097)  # Should be 8192
print(calculate_storage(6000)) # Should be 8192

1. Мы используем разделение этажей, чтобы вести запись в памяти, чтобы увидеть, сколько блоков потребуется (4096 блоков)

2. Затем мы проверяем, нет ли блоков напоминаний, которые остались бы при проверке размеров блоков. Это связано с тем, что, хотя размер блока равен 1, но если требуется еще 0,5 размера блока, один блок не сможет его сопровождать.

3. Наконец, мы создаем два аргумента. Первый - если остаток частичного блока больше нуля, а полные блоки больше или равны единице, размер блока следует удвоить.

Здесь важно отметить, что если мы не поместим предложение AND с full_blocks> = 1, мы не получим правильный ответ для первого, то есть (print (calculate_storage(1)), поскольку нам нужно вычислить, сколько блоков нужны для 1 размера файла.

Когда мы проверяем остаток частичного блока для этого аргумента, то есть (print (calculate_storage(1)), мы получим ответ как 0,000244140625, что означает, что он квалифицирует этот аргумент. Но как только мы добавим аргумент AND с full_blocks> = 1, он будет не соответствует требованиям, потому что ответом для этого будет 0 (full_blocks = 0). Это потому, что, когда вы разделите 1 на 4096, целое число будет равно нулю и с некоторыми десятичными знаками. Поскольку мы используем деление пола для вычисления full_blocks, мы принимаем только учитывайте целую часть, которая равна 0, а не десятичные значения.

Следовательно, если full_blocks больше или равно единице и если partial_block_remainder больше 0, размер блока должен быть удвоен. Если нет, верните размер блока.