
"""simple docstring"""





from __future__ import annotations

from math import ceil, floor, sqrt



def 						_lowerCAmelCase				(				UpperCamelCase_ = 200_0000				):
		__SCREAMING_SNAKE_CASE            = [0]
		__SCREAMING_SNAKE_CASE            = 42

		for idx in range(1  ,				ceil(sqrt(target * 2				) * 1.1				)				):
				triangle_numbers.append(triangle_numbers[-1] + idx				)

		# we want this to be as close as possible to target
		__SCREAMING_SNAKE_CASE            = 0
		# the area corresponding to the grid that gives the product closest to target
		__SCREAMING_SNAKE_CASE            = 0
		# an estimate of b, using the quadratic formula
		__SCREAMING_SNAKE_CASE            = 42
		# the largest integer less than b_estimate
		__SCREAMING_SNAKE_CASE            = 42
		# the largest integer less than b_estimate
		__SCREAMING_SNAKE_CASE            = 42
		# the triangle number corresponding to b_floor
		__SCREAMING_SNAKE_CASE            = 42
		# the triangle number corresponding to b_ceil
		__SCREAMING_SNAKE_CASE            = 42

		for idx_a, triangle_a in enumerate(triangle_numbers[1:]  ,				1				):
				__SCREAMING_SNAKE_CASE            = (-1 + sqrt(1 + 8 * target / triangle_a				)) / 2
				__SCREAMING_SNAKE_CASE            = floor(UpperCamelCase_				)
				__SCREAMING_SNAKE_CASE            = ceil(UpperCamelCase_				)
				__SCREAMING_SNAKE_CASE            = triangle_numbers[b_floor]
				__SCREAMING_SNAKE_CASE            = triangle_numbers[b_ceil]

				if abs(target - triangle_b_first_guess * triangle_a				) < abs(
				    target - best_product				):
						__SCREAMING_SNAKE_CASE            = triangle_b_first_guess * triangle_a
						__SCREAMING_SNAKE_CASE            = idx_a * b_floor

				if abs(target - triangle_b_second_guess * triangle_a				) < abs(
				    target - best_product				):
						__SCREAMING_SNAKE_CASE            = triangle_b_second_guess * triangle_a
						__SCREAMING_SNAKE_CASE            = idx_a * b_ceil

		return area


if __name__ == "__main__":
							print(F"""{solution() = }""")






"""simple docstring"""





import pytest

from datasets.utils.sharding import _distribute_shards, _number_of_shards_in_gen_kwargs, _split_gen_kwargs



@pytest.mark.parametrize(
    """kwargs, expected"""  ,				[
        ({"""num_shards""": 0, """max_num_jobs""": 1}, []),
        ({"""num_shards""": 10, """max_num_jobs""": 1}, [range(10				)]),
        ({"""num_shards""": 10, """max_num_jobs""": 10}, [range(UpperCamelCase_  ,				i + 1				) for i in range(10				)]),
        ({"""num_shards""": 1, """max_num_jobs""": 10}, [range(1				)]),
        ({"""num_shards""": 10, """max_num_jobs""": 3}, [range(0  ,				4				), range(4  ,				7				), range(7  ,				10				)]),
        ({"""num_shards""": 3, """max_num_jobs""": 10}, [range(0  ,				1				), range(1  ,				2				), range(2  ,				3				)]),
    ]  ,				)
def 						_lowerCAmelCase				(				UpperCamelCase_  ,				UpperCamelCase_				):
		__SCREAMING_SNAKE_CASE            = _distribute_shards(**UpperCamelCase_				)
		assert out == expected



@pytest.mark.parametrize(
    """gen_kwargs, max_num_jobs, expected"""  ,				[
        ({"""foo""": 0}, 10, [{"""foo""": 0}]),
        ({"""shards""": [0, 1, 2, 3]}, 1, [{"""shards""": [0, 1, 2, 3]}]),
        ({"""shards""": [0, 1, 2, 3]}, 4, [{"""shards""": [0]}, {"""shards""": [1]}, {"""shards""": [2]}, {"""shards""": [3]}]),
        ({"""shards""": [0, 1]}, 4, [{"""shards""": [0]}, {"""shards""": [1]}]),
        ({"""shards""": [0, 1, 2, 3]}, 2, [{"""shards""": [0, 1]}, {"""shards""": [2, 3]}]),
    ]  ,				)
def 						_lowerCAmelCase				(				UpperCamelCase_  ,				UpperCamelCase_  ,				UpperCamelCase_				):
		__SCREAMING_SNAKE_CASE            = _split_gen_kwargs(UpperCamelCase_  ,				UpperCamelCase_				)
		assert out == expected



@pytest.mark.parametrize(
    """gen_kwargs, expected"""  ,				[
        ({"""foo""": 0}, 1),
        ({"""shards""": [0]}, 1),
        ({"""shards""": [0, 1, 2, 3]}, 4),
        ({"""shards""": [0, 1, 2, 3], """foo""": 0}, 4),
        ({"""shards""": [0, 1, 2, 3], """other""": (0, 1)}, 4),
        ({"""shards""": [0, 1, 2, 3], """shards2""": [0, 1]}, RuntimeError),
    ]  ,				)
def 						_lowerCAmelCase				(				UpperCamelCase_  ,				UpperCamelCase_				):
		if expected is RuntimeError:
				with pytest.raises(UpperCamelCase_				):
						_number_of_shards_in_gen_kwargs(UpperCamelCase_				)
		else:
				__SCREAMING_SNAKE_CASE            = _number_of_shards_in_gen_kwargs(UpperCamelCase_				)
				assert out == expected




