Implement a function search which looks for item x in a 2D matrix m. Return indices i, j of the matching cell. Think of the most idiomatic way in the language to return the two values at the same time.
fun search(m: Array<Array<Int>>, x: Int): Pair<Int, Int>? {
m.forEachIndexed { i, row ->
row.forEachIndexed { j, value ->
if (value == x) {
return Pair(i, j)
}
}
}
return null
}
The lambda expression pulls out the field you want to sort by. If you want to sort in reverse order, add reverse=True to the argument list.
Alternative implementation:
from operator import attrgetter
items = sorted(items, key=attrgetter('p'))
We use attrgetter to avoid having to write a lambda. The Operator module contains lots of useful functions that can be passed to higher-order functions.
Remove i-th item from list items. This will alter the original list or return a new list, depending on which is more idiomatic. Note that in most languages, the smallest valid value for i is 0.
Launch the concurrent execution of the procedure f with parameter i from 1 to 1000. Tasks are independent and f(i) doesn't return any value. Tasks need not run all at the same time, so you may use a pool.
Find substring t consisting in characters i (included) to j (excluded) of string s. Character indices start at 0 unless specified otherwise. Make sure that multibyte characters are properly handled.
Create the string t containing the same characters as the string s, in reverse order. The original string s must remain unaltered. Each character must be handled correctly regardless its number of bytes in memory.
Print each item v of list a which is not contained in list b. For this, write an outer loop to iterate on a and an inner loop to iterate on b.
for v in a:
try:
for u in b:
if v == u:
raise Exception()
print(v)
except Exception:
continue
Note that using two loops like this in python is by itself very un-idiomatic. Also one would be wise to define a custom exception to avoid hiding "real" exceptions.
Alternative implementation:
for v in a:
keep = True
for w in b:
if w == v:
keep = False
break
if keep:
print(v)
class BreakOuterLoop (Exception): pass
try:
position = None
for row in m:
for column in m[row]:
if m[row][column] == v:
position = (row, column)
raise BreakOuterLoop
except BreakOuterLoop:
pass
This is ugly because the pythonic way to solve this problem would be to refactor so that one doesn't have to break out of multiple loops. See PEP3136
Alternative implementation:
def loop_breaking(m, v):
for i, row in enumerate(m):
for j, value in enumerate(row):
if value == v:
return (i, j)
return None
print(loop_breaking(([1,2,3],[4,5,6],[7,8,9]), 6))
Rather than set break flags, it is better to refactor into a function, then use return to break from all nested loops.
Alternative implementation:
from itertools import chain
matrix = [[1,2,3],[4,-5,6],[7,8,9]]
try:
print(next(i for i in chain.from_iterable(matrix) if i < 0))
except StopIteration:
pass
We make a generator that will return negative values from a list (and use chain.from_iterable(matrix) to lazily extract the values) and only take one value from it with the next function. The generator will not continue until we call next again.
This will raise StopIteration if it doesn't find the value so we need to account for it.
"... String literals that are part of a single expression and have only whitespace between them will be implicitly converted to a single string literal."
If sep is not specified or is None, a different splitting algorithm is applied: runs of consecutive ASCII whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the sequence has leading or trailing whitespace. Consequently, splitting an empty sequence or a sequence consisting solely of ASCII whitespace without a specified separator returns [].
Fork-join : launch the concurrent execution of procedure f with parameter i from 1 to 1000. Tasks are independent and f(i) doesn't return any value. Tasks need not run all at the same time, so you may use a pool. Wait for the completion of the 1000 tasks and then print "Finished".
For more complicated file operations, use a context manager with with
Alternative implementation:
with open(f) as fo:
lines = fo.read()
The with statement creates a contextmanager, which automatically handles closing the file for you when you're done. Without this, you should be manually closing file objects so that you are not relying on the garbage collector to do this for you.
Create an object x to store n bits (n being potentially large).
from __future__ import division
import math
x = bytearray(int(math.ceil(n / 8.0)))
Alternative implementation:
class BitSet:
def __init__(self, n):
self.a = [False] * n
def __getitem__(self, i):
return self.a[i]
def __setitem__(self, k, v):
self.a[k] = v
def __str__(self):
s = ('01'[x] for x in self.a)
return ''.join(s)
x = BitSet(n)
If s is constant, the generator output will be the same each time the program runs. If s is based on the current value of the system clock, the generator output will be different each time.
Get the current datetime and provide it as a seed to a random generator. The generator sequence will be different at each run.
import random
rand = random.Random()
the constructor uses the current time if used without arguments. you could also use the functions of the random module (they are using a shared ``Random`` object which is constructed the first time random is imported
Basic implementation of the Echo program: Print all arguments except the program name, separated by space, followed by newline. The idiom demonstrates how to skip the first argument if necessary, concatenate arguments as strings, append newline and print it to stdout.
fun main(args: Array<String>) = args.forEach(::println)
Declare integer y and initialize it with the value of floating point number x . Ignore non-integer digits of x . Make sure to truncate towards zero: a negative x must yield the closest greater integer (not lesser).
Declare the integer y and initialize it with the rounded value of the floating point number x . Ties (when the fractional part of x is exactly .5) must be rounded up (to positive infinity).
y = int(x + 0.5)
Alternative implementation:
from decimal import Decimal, Context, ROUND_HALF_UP
c = Context(rounding=ROUND_HALF_UP)
y = round(Decimal(x, c))
You've detected that the integer value of argument x passed to the current function is invalid. Write the idiomatic way to abort the function execution and signal the problem.
Make an HTTP request with method GET to the URL u, then store the body of the response in the file result.txt. Try to save the data as it arrives if possible, without having all its content in memory at once.
sys.argv[0] holds the name of the currently running script, you might use __file__, but if called from within a module you would then get the module's __file__ attribute.
Print the value of variable x, but only if x has been declared in this program. This makes sense in some languages, not all of them. (Null values are not the point, rather the very existence of the variable.)
Set boolean b to true if objects x and y contain the same values, recursively comparing all referenced elements in x and y. Tell if the code correctly handles recursive types.
b = x == y
The classes of x and y need to delegate to any contained objects' _eq__ implementation. All objects in the standard library do so.
Verify that predicate isConsistent returns true, otherwise report assertion violation. Explain if the assertion is executed even in production environment or not.
assert isConsistent
raises AssertionError Exception.
Running Python with option -O or with PYTHONOPTIMZE environment variable suppresses all asserts.
Call the function f on every vertex accessible from the vertex start, in breadth-first prefix order
from collections import deque
def breadth_first(start, f):
seen = set()
q = deque([start])
while q:
vertex = q.popleft()
f(vertex)
seen.add(vertex)
q.extend(v for v in vertex.adjacent if v not in seen)
It's best to not recurse in Python when the structure size is unknown, since we have a fixed, small stack size.
Call th function f on every vertex accessible from the vertex v, in depth-first prefix order
def depth_first(start, f):
seen = set()
stack = [start]
while stack:
vertex = stack.pop()
f(vertex)
seen.add(vertex)
stack.extend(
v for v in vertex.adjacent if v not in seen
)
It's best to not recurse in Python when the structure size is unknown, since we have a fixed, small stack size.
Execute f1 if condition c1 is true, or else f2 if condition c2 is true, or else f3 if condition c3 is true. Don't evaluate a condition when a previous condition was true.
Remove at most 1 item from list items, having the value x. This will alter the original list or return a new list, depending on which is more idiomatic. If there are several occurrences of x in items, remove only one of them. If x is absent, keep items unchanged.
c, c1, c2 are strings of hex color codes: 7 chars, beginning with a number sign # . Assume linear computations, ignore gamma corrections.
r1, g1, b1 = [int(c1[p:p+2], 16) for p in range(1,6,2)]
r2, g2, b2 = [int(c2[p:p+2], 16) for p in range(1,6,2)]
c = '#{:02x}{:02x}{:02x}'.format((r1+r2) // 2, (g1+g2) //2, (b1+b2)// 2)
Alternative implementation:
import numpy
class RGB(numpy.ndarray):
@classmethod
def from_str(cls, rgbstr):
return numpy.array([
int(rgbstr[i:i+2], 16)
for i in range(1, len(rgbstr), 2)
]).view(cls)
def __str__(self):
self = self.astype(numpy.uint8)
return '#' + ''.join(format(n, 'x') for n in self)
c1 = RGB.from_str('#a1b1c1')
print(c1)
c2 = RGB.from_str('#1A1B1C')
print(c2)
print((c1 + c2) / 2)
numpy is standard for array numerics, and works nicely for this problem. We can represent a RGB value as a special numpy array.
Alternative implementation:
a = bytes.fromhex(c1[1:])
b = bytes.fromhex(c2[1:])
r, g, b = (sum(x) // 2 for x in zip(a, b))
c = (r << 16) + (g << 8) + b
c = f'{c:06x}'
Create a new list y from randomly picking exactly k elements from list x.
It is assumed that x has at least k elements. Each element must have same probability to be picked. Each element from x must be picked atmostonce. Explain if the original ordering is preserved or not.
Execute f32() if platform is 32-bit, or f64() if platform is 64-bit. This can be either a compile-time condition (depending on target) or a runtime detection.
Print all the list elements, two by two, assuming list length is even.
for x in zip(list[::2], list[1::2]):
print(x)
original list is called list
Alternative implementation:
from itertools import tee
def pairwise(iterable):
"s -> (s0,s1), (s1,s2), (s2, s3), ..."
a, b = tee(iterable)
next(b, None)
return zip(a, b)
for a, b in pairwise(list):
print(a, b)
Official documentation suggestion. Works for any iterable
Assign to the integer n the number of characters of the string s. Make sure that multibyte characters are properly handled. n can be different from the number of bytes of s.
From the array a of n bytes, build the equivalent hex string s of 2n digits. Each byte (256 possible values) is encoded as two hexadecimal characters (16 possible values per digit).
From hex string s of 2n digits, build the equivalent array a of n bytes. Each pair of hexadecimal characters (16 possible values per digit) is decoded into one byte (256 possible values).
Construct a list L that contains all filenames that have the extension ".jpg" , ".jpeg" or ".png" in directory D and all its subdirectories.
import os
extensions = [".jpg", ".jpeg", ".png"]
L = [f for f in os.listdir(D) if os.path.splitext(f)[1] in extensions]
Doesn't look in subdirectories because I didn't read the question properly.
Alternative implementation:
import re
import os
filtered_files = ["{}/{}".format(dirpath, filename) for dirpath, _, filenames in os.walk(D) for filename in filenames if re.match(r'^.*\.(?:jpg|jpeg|png)$', filename)]
* list comprehension * iterate over all files and all directories in tree under D (os module) * iterate over all files found * filter with regex matching the end of the filename (re module) * regex is cached, but may be compiled beforehands
Alternative implementation:
import glob
import itertools
list(itertools.chain(*(glob.glob("*/**.%s" % ext) for ext in ["jpg", "jpeg", "png"])))
Alternative implementation:
import glob
import os
extensions = [".jpg", ".jpeg", ".png"]
L = [f for f in glob.glob(os.path.join(D, "**/*"), recursive=True) if os.path.splitext(f)[1] in extensions]
Set boolean b to true if if the point with coordinates (x,y) is inside the rectangle with coordinates (x1,y1,x2,y2) , or to false otherwise. Describe if the edges are considered to be inside the rectangle.
class Rectangle:
def __init__(self, x, y, w, h):
self.x, self.y = x, y
self.w, self.h = w, h
def contains(self, x, y):
a, b = self.x, self.y
w, h = self.w, self.h
return a <= x <= (a + w) and \
b <= y <= (b + h)
w, h = x2 - x1, y2 - y1
r = Rectangle(x1, y1, w, h)
b = r.contains(x, y)
data class Point(val x: Double, val y: Double)
data class Rectangle(val x1: Double, val y1: Double, val x2: Double, val y2: Double){
fun center() = Point( x = (x1 + x2)/2, y =(y1 + y2)/2)
}
Output the source of the current program. A quine is a computer program that takes no input and produces a copy of its own source code as its only output.
Since exit() ultimately “only” raises an exception, it will only exit the process when called from the main thread, and the exception is not intercepted.
Disjoint Sets hold elements that are partitioned into a number of disjoint (non-overlapping) sets.
class UnionFind:
def __init__(self, size):
self.rank = [0] * size
self.p = [i for i in range(size)]
def find_set(self, i):
if self.p[i] == i:
return i
else:
self.p[i] = self.find_set(self.p[i])
return self.p[i]
def is_same_set(self, i, j):
return self.find_set(i) == self.find_set(j)
def union_set(self, i, j):
if not self.is_same_set(i, j):
x, y = self.find_set(i), self.find_set(j)
Perform matrix multiplication of a real matrix a with nx rows and ny columns, a real matrix b with ny rows and nz columns and assign the value to a real matrix c with nx rows and nz columns.
import numpy as np
c = a @ b
Python 3.5 (PEP465) introduced the @ operator for matrix multiplication.
Declare two two-dimensional arrays a and b of dimension n*m and m*n, respectively. Assign to b the transpose of a (i.e. the value with index interchange).
import numpy as np
a = np.array([[1,2], [3,4], [5,6]])
b = a.T
Alternative implementation:
a = [[1,2], [3,4], [5,6]]
b = list(map(list, zip(*a)))
Alternative implementation:
b = [*zip(*a)]
"... Another way to think of zip() is that it turns rows into columns, and columns into rows. This is similar to transposing a matrix."
Given an array a, set b to an array which has the values of a along its second dimension shifted by n. Elements shifted out should come back at the other end.
Pass an array a of real numbers to the procedure (resp. function) foo. Output the size of the array, and the sum of all its elements when each element is multiplied with the array indices i and j (assuming they start from one).
def foo(a):
print(len(a))
print(sum(
x*(i+1) + y*(i+1)*2 for i, (x, y) in enumerate(a)
))
Alternative implementation:
from functools import reduce
from operator import mul
from itertools import starmap
def foo(a):
z, f = 0, lambda a, b: a + (i * b)
for i, x in enumerate(a, 1):
x = starmap(mul, enumerate(x, 1))
z = z + reduce(f, x, 0)
print(len(a), z)
foo(a)
Alternative implementation:
def foo(a):
z = 0
for i, x in enumerate(a, 1):
for j, y in enumerate(x, 1):
# z = z + (y * i) + (y * j)
z = z + (y * i * j)
print(len(a), z)
foo(a)
Given an integer array a of size n, pass the first, third, fifth and seventh, ... up to the m th element to a routine foo which sets all these elements to 42.
Given a real number a, print the fractional part and the exponent of the internal representation of that number. For 3.14, this should print (approximately)
Read an environment variable with the name "FOO" and assign it to the string variable foo. If it does not exist or if the system does not support environment variables, assign a value of "none".
Execute different procedures foo, bar, baz and barfl if the string str contains the name of the respective procedure. Do it in a way natural to the language.
switch = {'foo': foo,
'bar': bar,
'baz': baz,
'barfl': barfl
}
switch_funct = switch.get(string)
if switch_funct : switch_funct()
Python does not natively support switch statements, but we can use a dictionary to replicate one.
The get() method will return the value of the given key if it exists and None otherwise where foo, bar, baz, and barf1 are all declared functions.
We then can check if the get method returned a value, and if it did, execute the returned function.
Alternative implementation:
match str:
case 'foo': foo()
case 'bar': bar()
case 'baz': baz()
case 'barfl': barfl()
Allocate a list a containing n elements (n assumed to be too large for a stack) that is automatically deallocated when the program exits the scope it is declared in.
def func():
a = [0] * n
# local variable automatically deallocated at end of function
return
Declare a type t which contains a string s and an integer array n with variable size, and allocate a variable v of type t. Allocate v.s and v.n and set them to the values "Hello, world!" for s and [1,4,9,16,25], respectively. Deallocate v, automatically deallocating v.s and v.n (no memory leaks).
class T:
def __init__(self, s, n):
self.s = s
self.n = n
return
v = T('hello world', [1, 4, 9, 16, 25])
del v
Assign, at runtime, the compiler version and the options the program was compiled with to variables version and options, respectively, and print them. For interpreted languages, substitute the version of the interpreter.
Example output:
GCC version 10.0.0 20190914 (experimental) -mtune=generic -march=x86-64
Compare four strings in pair-wise variations. The string comparison can be implemented with an equality test or a containment test, must be case-insensitive and must apply Unicode casefolding.
import itertools
strings = ['ᾲ στο διάολο',
'ὰι στο διάολο',
'Ὰͅ ΣΤΟ ΔΙΆΟΛΟ',
'ᾺΙ ΣΤΟ ΔΙΆΟΛΟ']
for a, b in itertools.combinations(strings, 2):
print(a, b, a.casefold() == b.casefold())
Append extra character c at the end of string s to make sure its length is at least m. The length is the number of characters, not the number of bytes.
Prepend extra character c at the beginning of string s to make sure its length is at least m. The length is the number of characters, not the number of bytes.
Add the extra character c at the beginning and ending of string s to make sure its length is at least m. After the padding the original content of s should be at the center of the result. The length is the number of characters, not the number of bytes.
E.g. with s="abcd", m=10 and c="X" the result should be "XXXabcdXXX".
Create the list c containing all unique elements that are contained in both lists a and b. c should not contain any duplicates, even if a and b do. The order of c doesn't matter.
c = list(set(a) & set(b))
Alternative implementation:
c = list(set(a).intersection(b))
This avoids converting b into a set prior to the intersection.
Loop through list items checking a condition. Do something else if no matches are found.
A typical use case is looping through a series of containers looking for one that matches a condition. If found, an item is inserted; otherwise, a new container is created.
These are mostly used as an inner nested loop, and in a location where refactoring inner logic into a separate function reduces clarity.
items.find { it == "baz" }
?.let { println("found it") }
?: println("never found it")
Alternative implementation:
if(items.any { it == "baz" })
println("found it")
else
println("never found it")
Construct the "double precision" (64-bit) floating point number d from the mantissa m, the exponent e and the sign flag s (true means the sign is negative).
'... If the target list contains one target prefixed with an asterisk, called a “starred” target: The object must be an iterable with at least as many items as there are targets in the target list, minus one.'
Write two functions log2d and log2u, which calculate the binary logarithm of their argument n rounded down and up, respectively. n is assumed to be positive. Print the result of these functions for numbers from 1 to 12.
import math
def log2d(n):
return math.floor(math.log2(n))
def log2u(n):
return math.ceil(math.log2(n))
for n in range(1, 13):
print(n, log2d(n), log2u(n))
Functions accept both int and float parameters
Alternative implementation:
from math import log2, floor, ceil
log2d = lambda x: floor(log2(x))
log2u = lambda x: ceil(log2(x))
for i in range(1, 13):
print(i, log2d(i), log2u(i))
Pass a two-dimensional integer array a to a procedure foo and print the size of the array in each dimension. Do not pass the bounds manually. Call the procedure with a two-dimensional array.
def foo(a):
print(len(a), len(a[0]))
return
a = [[1,2,3], [4,5,6]]
foo(a)
Alternative implementation:
foo = lambda a: \
print(*(len(x) for x in a))
foo(a)
Define a type vector containing three floating point numbers x, y, and z. Write a user-defined operator x that calculates the cross product of two vectors a and b.
class Vector:
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
return
def __mul__(self, other):
return Vector(self.y * other.z - self.z * other.y,
self.z * other.x - self.x * other.z,
self.x * other.y - self.y * other.x)
result = a * b
Python doesn't allow operators with user-defined names
Alternative implementation:
class Vector:
def __init__(self, x, y, z):
self.a = x, y, z
def __getitem__(self, i):
return self.a[i]
def __mul__(self, b):
a = self.a
return {
'x': a[1] * b[2] - a[2] * b[1],
'y': a[2] * b[0] - a[0] * b[2],
'z': a[0] * b[1] - a[1] * b[0]
}
a = Vector(.1, .2, .3)
b = Vector(.4, .5, .6)
x = a * b
Given the enumerated type t with 3 possible values: bike, car, horse. Set the enum value e to one of the allowed values of t. Set the string s to hold the string representation of e (so, not the ordinal value). Print s.
Given a floating point number r1 classify it as follows: If it is a signaling NaN, print "This is a signaling NaN." If it is a quiet NaN, print "This s a quiet NaN." If it is not a NaN, print "This is a number."
import math
if math.isnan(r1):
print('This is a quiet NaN.')
else:
print('This is a number.')
Python makes no effort to distinguish signaling NaNs from quiet NaNs, and behavior for signaling NaNs remains unspecified. Typical behavior is to treat all NaNs as though they were quiet.
d = Decimal(r1)
if d.is_snan(): print('This is a signaling NaN.')
if d.is_qnan(): print('This s a quiet NaN.')
if not d.is_nan(): print('This is a number.')
If a variable x passed to procedure tst is of type foo, print "Same type." If it is of a type that extends foo, print "Extends type." If it is neither, print "Not related."
Fizz buzz is a children's counting game, and a trivial programming task used to affirm that a programmer knows the basics of a language: loops, conditions and I/O.
The typical fizz buzz game is to count from 1 to 100, saying each number in turn. When the number is divisible by 3, instead say "Fizz". When the number is divisible by 5, instead say "Buzz". When the number is divisible by both 3 and 5, say "FizzBuzz"
for i in range(1,101):
if i % 15 == 0:
print("FizzBuzz")
elif i % 3 == 0:
print("Fizz")
elif i % 5 == 0:
print("Buzz")
else:
print(i)
for i in range(100, 1):
if i % 5 == 0 and not i % 3 == 0:
print(i, "Buzz");
if i % 3 == 0 and not i % 5 == 0:
print(i, "Fizz");
if i % 3 == 0 and i % 5 == 0:
print(i, "FizzBuzz");
Alternative implementation:
for i in range(1, 100+1):
out = ""
if i % 3 == 0:
out += "Fizz"
if i % 5 == 0:
out += "Buzz"
print(out or i)
"... If sep is not specified or is None, a different splitting algorithm is applied: runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace."
From the string s consisting of 8n binary digit characters ('0' or '1'), build the equivalent array a of n bytes. Each chunk of 8 binary digits (2 possible values per digit) is decoded into one byte (256 possible values).
n = (len(s) - 1) // 8 + 1
a = bytearray(n)
for i in range(n):
b = int(s[i * 8:(i + 1) * 8], 2)
a[i] = b
You have a Point with integer coordinates x and y. Create a map m with key type Point (or equivalent) and value type string. Insert "Hello" at position (42, 5).
m = dict()
p = Point(x=42, y=5)
m[p] = 'Hello'
Dictionary keys must be hashable objects. User-defined classes are hashable by default.
Alternative implementation:
from collections import namedtuple
Point = namedtuple('Point', 'x y')
p = Point(42, 5)
m = {p: "Hello"}
m = {Point(42, 5): "Hello"} would work just fine, as well! Naming the point in advance, has the advantage of using both p and Point(42, 5) as a key
Given two floating point variables a and b, set a to a to a quiet NaN and b to a signalling NaN. Use standard features of the language only, without invoking undefined behavior.
a = float('nan')
Python makes no effort to distinguish signaling NaNs from quiet NaNs, and behavior for signaling NaNs remains unspecified. Typical behavior is to treat all NaNs as though they were quiet.
This can be different from the number of characters. If n includes more bytes than the characters per se (trailing zero, length field, etc.) then explain it. One byte is 8 bits.
n = len(s.encode('utf8'))
Python strings are sequences of Unicode codepoints, the internal representation is implementation dependent. But you can easily determine the length of a specific byte encoding.
Create the string representation s of the integer value n in base b.
18 in base 3 -> "200" 26 in base 5 -> "101" 121 in base 12 -> "a1"
def int_to_base_str(n, b):
digits = '0123456789abcdefghijklmnopqrstuvwxyz'
s = ''
if n == 0: return '0'
while n:
n, remainder = divmod(n, b)
s = digits[remainder] + s
return s
Make an HTTP request with method GET to the URL u, with the request header "accept-encoding: gzip", then store the body of the response in the buffer data.
import requests
response = requests.get(u, headers={'accept-encoding': 'gzip'})
data = response.content[:]
Parse a number, a, into a mathematical fraction, f.
For example, 0.5 is `1/2`, and 3.125 is `3 1/8`.
https://en.wikipedia.org/wiki/Fraction
from math import gcd
s = str(a).split('.')
i, n = map(int, s)
d = 10 ** len(str(n))
v = gcd(n, d) or 1
n, d = n // v, d // v
if not n: f = str(i)
elif i: f = f'{i} {n}/{d}'
else: f = f'{n}/{d}'
Generate a "zipped" list z of pairs of elements from the lists a, b having the same length n.
The result z will contain n pairs.
z = zip(a, b)
"... One thing to consider is that the iterables passed to zip() could have different lengths .... Python offers three different approaches to dealing with this issue"
Create the end-user text, s, specifying the value a, in units of x.
For example, "0 files", "1 file", or "1,000 files".
class Unit:
def __init__(self, symbol):
self.s, self.a = symbol, []
def cond(self, x, y):
self.a.append((x, 'f' + repr(y)))
def parse(self, x):
for a, b in self.a:
if a(x): return eval(b)
else: return f'{x} {self.s}'
x = Unit('files')
x.cond(lambda x: not x, '0 files')
x.cond(lambda x: x == 1, '1 file')
x.cond(lambda x: x > 999, '{x:,} files')
s = x.parse(a)
This routine can be used to parse a unit-system as well, e.g., 'B', 'kB', 'MB', etc.
Alternative implementation:
s = f'{a:,} {('file', 'files')[a != 1]}'
Alternative implementation:
x = {
f'{a / 1e9} GB': a > 999_999_999,
f'{a / 1e6} MB': a > 999_999,
f'{a / 1e3} kB': a > 999,
f'{a} B': True,
}
for k, v in x.items():
if v:
s = k
break
Create the end-user text, s, specifying the contents of collection a.
For example, "A", "A and B", "A, B, and C", etc.
match len(a):
case 1: s = a[0]
case 2: s = ' and '.join(a)
case _:
s = ', '.join(a[:-1])
s = s + ', and ' + a[-1]
Alternative implementation:
class List:
def __init__(self):
self.m = []
def apply(self, /, *x, y='', z=''):
self.m.append((x, y, z))
def parse(self, x):
x = [*map(str, x)]
for a, y, z in self.m:
for i in a: x[i] = y + x[i] + z
return ''.join(x)
x = List()
match n := len(a):
case 1: ...
case 2: x.apply(0, z=' and ')
case _:
x.apply(*range(n - 1), z=', ')
x.apply(-1, y='and ')
s = x.parse(a)
This function will apply a prefix and suffix, given a sequence of index values, x.
Calculate the SI (International System of Units) prefix, x, of value a.
For example, 'k', 'M', 'G', 'T', etc.
https://en.wikipedia.org/wiki/Metric_prefix
from math import log
from enum import Enum, auto
class SI(Enum):
k = 'kilo', auto()
M = 'mega', auto()
G = 'giga', auto()
T = 'tera', auto()
def __init__(self, x, y):
self.x, self.y = x, y
@classmethod
def get(cls, a):
i = log(a) // log(1_000)
for x in cls:
if x.y == i: return x
si = SI.get(a)
a = a / (1_000 ** si.y)
x = si.name
class Units:
def __init__(self, x, y):
self.a = [(x, y)]
def set(self, x, y):
a = self.a
a.append((x, y * a[-1][1]))
def get(self, x):
m = dict()
for y, z in reversed(self.a):
if x >= z:
m[y], x = divmod(x, z)
return m
u = Units('ms', 1)
u.set('s', 1_000)
u.set('m', 60)
u.set('h', 60)
u.set('d', 24)
u.set('y', 365.2425)
m = u.get(a)
u = [('ms', 1)]
def units(x, y):
u.append((x, y * u[-1][1]))
units('s', 1_000)
units('m', 60)
units('h', 60)
units('d', 24)
units('y', 365.2425)
m, x = dict(), a
for u in reversed(u):
if x >= (y := u[1]):
m[u], x = divmod(x, y)
Kotlin
Python