Início / user-12671057

Kelly Bundy's questions

Martin Hope
Kelly Bundy
Asked: 2024-12-24 00:20:31 +0800 CST
  • 10

Com lst = [0] * 10**6eu chego em momentos como estes:

  5.4 ± 0.4 ms  bytearray(lst)
  5.6 ± 0.4 ms  bytes(bytearray(lst))
 13.1 ± 0.7 ms  bytes(lst)

Python:
3.13.0 (main, Nov  9 2024, 10:04:25) [GCC 14.2.1 20240910]
namespace(name='cpython', cache_tag='cpython-313', version=sys.version_info(major=3, minor=13, micro=0, releaselevel='final', serial=0), hexversion=51183856, _multiarch='x86_64-linux-gnu')

Eu esperaria que bytes(lst)e bytearray(lst)fosse igualmente rápido ou bytearray(lst)o mais lento, já que é o tipo mais complicado (tem mais funcionalidade, já que é mutável). Mas é o contrário. E até mesmo o desvio bytes(bytearray(lst))é muito mais rápido que bytes(lst)! Por que é bytes(lst)tão lento?

Script de referência ( tente isso online! ):

from timeit import timeit
from statistics import mean, stdev
import random
import sys

setup = 'lst = [0] * 10**6'

codes = [
    'bytes(lst)',
    'bytearray(lst)',
    'bytes(bytearray(lst))'
]

times = {c: [] for c in codes}
def stats(c):
    ts = [t * 1e3 for t in sorted(times[c])[:5]]
    return f'{mean(ts):5.1f} ± {stdev(ts):3.1f} ms '
for _ in range(25):
    random.shuffle(codes)
    for c in codes:
        t = timeit(c, setup, number=10) / 10
        times[c].append(t)
for c in sorted(codes, key=stats):
    print(stats(c), c)

print('\nPython:')
print(sys.version)
print(sys.implementation)

Inspirado por uma resposta que também se mostrou bytearraymais rápida.

python
Martin Hope
Kelly Bundy
Asked: 2024-01-17 07:48:17 +0800 CST
  • 5

Como podemos manter apenas elementos que possuem três ou mais elementos em cada lado? Por exemplo:

[1, 2, 3, 4]  =>  [1, 4]

  • O 1tem três elementos à sua direita, então o mantemos.

  • O 2e 3cada um tem apenas um ou dois elementos em cada lado, então os removemos.

  • O 4tem três elementos à sua esquerda, então o mantemos.

Mais exemplos:

[]  =>  []
[1]  =>  []
[1, 2]  =>  []
[1, 2, 3]  =>  []
[1, 2, 3, 4]  =>  [1, 4]
[1, 2, 3, 4, 5]  =>  [1, 2, 4, 5]
[1, 2, 3, 4, 5, 6]  =>  [1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 7]  =>  [1, 2, 3, 4, 5, 6, 7]

Editar: aqui está uma maneira ruim, caso alguém realmente se importe que eu não tenha fornecido nenhuma "tentativa":

L = [1, 2, 3, 4]

N = len(L)
for i in reversed(range(N)):
    left = i
    right = N - 1 - i
    if not (left >= 3 or right >= 3):
        L.pop(i)

print(L)
python