12345 равно 100: 1 2 3 4 5=100 расставить знаки

100 NumPy задач | Python 3 для начинающих и чайников

100 (на самом деле, пока меньше) задач для NumPy, перевод английского варианта https://github.com/rougier/numpy-100

import numpy as np

print(np.__version__)
np.show_config()

Z = np.zeros(10)
print(Z)

Z = np.ones(10)
print(Z)

Z = np.full(10, 2.5)
print(Z)

python3 -c "import numpy; numpy.info(numpy.add)"

Z = np.zeros(10)
Z[4] = 1
print(Z)

Z = np. arange(10,50)
print(Z)

Z = np.arange(50)
Z = Z[::-1]

Z = np.arange(9).reshape(3,3)
print(Z)

nz = np.nonzero([1,2,0,0,4,0])
print(nz)

Z = np.eye(3)
print(Z)

Z = np.random.random((3,3,3))
print(Z)

Z = np.random.random((10,10))
Zmin, Zmax = Z.min(), Z.max()
print(Zmin, Zmax)

Z = np.random.random(30)
m = Z.mean()
print(m)

Z = np.ones((10,10))
Z[1:-1,1:-1] = 0

0 * np. nan
np.nan == np.nan
np.inf > np.nan
np.nan - np.nan
0.3 == 3 * 0.1

Z = np.diag(np.arange(1, 5), k=-1)
print(Z)

Z = np.zeros((8,8), dtype=int)
Z[1::2,::2] = 1
Z[::2,1::2] = 1
print(Z)

print(np.unravel_index(100, (6,7,8)))

Z = np.tile(np.array([[0,1],[1,0]]), (4,4))
print(Z)

Z = np.dot(np.ones((5,3)), np.ones((3,2)))
print(Z)

Z = np.arange(11)
Z[(3 < Z) & (Z <= 8)] *= -1

Z = np.zeros((5,5))
Z += np.arange(5)
print(Z)

def generate():
    for x in xrange(10):
        yield x
Z = np. fromiter(generate(),dtype=float,count=-1)
print(Z)

Z = np.linspace(0,1,12)[1:-1]
print(Z)

Z = np.random.random(10)
Z.sort()
print(Z)

A = np.random.randint(0,2,5)
B = np.random.randint(0,2,5)
equal = np.allclose(A,B)
print(equal)

Z = np.zeros(10)
Z.flags.writeable = False
Z[0] = 1

Z = np.random.random((10,2))
X,Y = Z[:,0], Z[:,1]
R = np.hypot(X, Y)
T = np.arctan2(Y,X)
print(R)
print(T)

Z = np.random.random(10)
Z[Z.argmax()] = 0
print(Z)

Z = np.zeros((10,10), [('x',float),('y',float)])
Z['x'], Z['y'] = np. meshgrid(np.linspace(0,1,10),
                             np.linspace(0,1,10))
print(Z)

X = np.arange(8)
Y = X + 0.5
C = 1.0 / np.subtract.outer(X, Y)
print(np.linalg.det(C))

for dtype in [np.int8, np.int32, np.int64]:
   print(np.iinfo(dtype).min)
   print(np.iinfo(dtype).max)
for dtype in [np.float32, np.float64]:
   print(np.finfo(dtype).min)
   print(np.finfo(dtype).max)
   print(np.finfo(dtype).eps)

np.set_printoptions(threshold=np.nan)
Z = np.zeros((25,25))
print(Z)

Z = np.arange(100)
v = np.random.uniform(0,100)
index = (np.abs(Z-v)).argmin()
print(Z[index])

 Z = np. zeros(10, [ ('position', [ ('x', float, 1),
                                   ('y', float, 1)]),
                    ('color',    [ ('r', float, 1),
                                   ('g', float, 1),
                                   ('b', float, 1)])])
print(Z)

import scipy.spatial
Z = np.random.random((10,2))
D = scipy.spatial.distance.cdist(Z,Z)
print(D)

Z = np.arange(10, dtype=np.int32)
Z = Z.astype(np.float32, copy=False)

1,2,3,4,5
6,,,7,8
,,9,10,11

Z = np.genfromtxt("missing.dat", delimiter=",")

Z = np.arange(9).reshape(3,3)
for index, value in np.ndenumerate(Z):
    print(index, value)
for index in np.ndindex(Z.shape):
    print(index, Z[index])

X, Y = np. meshgrid(np.linspace(-1,1,10), np.linspace(-1,1,10))
D = np.hypot(X, Y)
sigma, mu = 1.0, 0.0
G = np.exp(-((D - mu) ** 2 / (2.0 * sigma ** 2)))
print(G)

n = 10
p = 3
Z = np.zeros((n,n))
np.put(Z, np.random.choice(range(n*n), p, replace=False), 1)

X = np.random.rand(5, 10)
Y = X - X.mean(axis=1, keepdims=True)

Z = np.random.randint(0,10,(3,3))
n = 1  # Нумерация с нуля
print(Z)
print(Z[Z[:,n].argsort()])

Z = np.random.randint(0,3,(3,10))
print((~Z.any(axis=0)).any())

Z = np.ones(10)
I = np.random.randint(0,len(Z),20)
Z += np.bincount(I, minlength=len(Z))
print(Z)

w,h = 16,16
I = np.
  random.randint(0, 2, (h,w,3)).astype(np.ubyte)
F = I[...,0] * 256 * 256 + I[...,1] * 256 + I[...,2]
n = len(np.unique(F))
print(np.unique(I))

A = np.random.randint(0,10, (3,4,3,4))
sum = A.reshape(A.shape[:-2] + (-1,)).sum(axis=-1)
print(sum)

# Slow version
np.diag(np.dot(A, B))
# Fast version
np.sum(A * B.T, axis=1)
# Faster version
np.einsum("ij,ji->i", A, B).

Z = np.array([1,2,3,4,5])
nz = 3
Z0 = np.zeros(len(Z) + (len(Z)-1)*(nz))
Z0[::nz+1] = Z
print(Z0)

A = np.arange(25).reshape(5,5)
A[[0,1]] = A[[1,0]]
print(A)

faces = np. random.randint(0,100,(10,3))
F = np.roll(faces.repeat(2,axis=1),-1,axis=1)
F = F.reshape(len(F)*3,2)
F = np.sort(F,axis=1)
G = F.view( dtype=[('p0',F.dtype),('p1',F.dtype)] )
G = np.unique(G)
print(G)

C = np.bincount([1,1,2,3,4,4,6])
A = np.repeat(np.arange(len(C)), C)
print(A)

def moving_average(a, n=3):
    ret = np.cumsum(a, dtype=float)
    ret[n:] = ret[n:] - ret[:-n]
    return ret[n - 1:] / n
print(moving_average(np.arange(20), 3))

from numpy.lib import stride_tricks
def rolling(a, window):
    shape = (a.size - window + 1, window)
    strides = (a.itemsize, a.itemsize)
    return stride_tricks.as_strided(a, shape=shape, strides=strides)
Z = rolling(np.arange(10), 3)
print(Z)

Z = np. random.randint(0,2,100)
np.logical_not(arr, out=arr)
Z = np.random.uniform(-1.0,1.0,100)
np.negative(arr, out=arr)

def distance(P0, P1, p):
    T = P1 - P0
    L = (T**2).sum(axis=1)
    U = -((P0[:,0] - p[...,0]) * T[:,0] + (P0[:,1] - p[...,1]) * T[:,1]) / L
    U = U.reshape(len(U),1)
    D = P0 + U * T - p
    return np.sqrt((D**2).sum(axis=1))
P0 = np.random.uniform(-10,10,(10,2))
P1 = np.random.uniform(-10,10,(10,2))
p  = np.random.uniform(-10,10,( 1,2))
print(distance(P0, P1, p))

Z = np.random.randint(0,10, (10,10))
shape = (5,5)
fill  = 0
position = (1,1)
R = np.ones(shape, dtype=Z.dtype)*fill
P  = np.array(list(position)).astype(int)
Rs = np.array(list(R.shape)). astype(int)
Zs = np.array(list(Z.shape)).astype(int)
R_start = np.zeros((len(shape),)).astype(int)
R_stop  = np.array(list(shape)).astype(int)
Z_start = (P - Rs//2)
Z_stop  = (P + Rs//2)+Rs%2
R_start = (R_start - np.minimum(Z_start, 0)).tolist()
Z_start = (np.maximum(Z_start, 0)).tolist()
R_stop = np.maximum(R_start, (R_stop - np.maximum(Z_stop-Zs,0))).tolist()
Z_stop = (np.minimum(Z_stop,Zs)).tolist()
r = [slice(start,stop) for start,stop in zip(R_start,R_stop)]
z = [slice(start,stop) for start,stop in zip(Z_start,Z_stop)]
R[r] = Z[z]
print(Z)
print(R)

Z = np.random.uniform(0,1,(10,10))
rank = np.linalg.matrix_rank(Z)

Z = np.random.randint(0,10,50)
print(np.bincount(Z).argmax())

Z = np.random.randint(0,5,(10,10))
n = 3
i = 1 + (Z.shape[0] - n)
j = 1 + (Z.shape[1] - n)
C = stride_tricks.as_strided(Z, shape=(i, j, n, n), strides=Z. strides + Z.strides)
print(C)

# Note: only works for 2d array and value setting using indices
class Symetric(np.ndarray):
    def __setitem__(self, (i,j), value):
        super(Symetric, self).__setitem__((i,j), value)
        super(Symetric, self).__setitem__((j,i), value)
def symetric(Z):
    return np.asarray(Z + Z.T - np.diag(Z.diagonal())).view(Symetric)
S = symetric(np.random.randint(0,10,(5,5)))
S[2,3] = 42
print(S)

p, n = 10, 20
M = np.ones((p,n,n))
V = np.ones((p,n,1))
S = np.tensordot(M, V, axes=[[0, 2], [0, 1]])
print(S)
# It works, because:
# M is (p,n,n)
# V is (p,n,1)
# Thus, summing over the paired axes 0 and 0 (of M and V independently),
# and 2 and 1, to remain with a (n,1) vector.

Z = np. ones((16,16))
k = 4
S = np.add.reduceat(np.add.reduceat(Z, np.arange(0, Z.shape[0], k), axis=0),
                                       np.arange(0, Z.shape[1], k), axis=1)

def iterate(Z):
    # Count neighbours
    N = (Z[0:-2,0:-2] + Z[0:-2,1:-1] + Z[0:-2,2:] +
         Z[1:-1,0:-2]                + Z[1:-1,2:] +
         Z[2:  ,0:-2] + Z[2:  ,1:-1] + Z[2:  ,2:])
    # Apply rules
    birth = (N == 3) & (Z[1:-1,1:-1]==0)
    survive = ((N == 2) | (N == 3)) & (Z[1:-1,1:-1] == 1)
    Z[...] = 0
    Z[1:-1,1:-1][birth | survive] = 1
    return Z
Z = np.random.randint(0,2,(50,50))
for i in range(100):
    print(Z)
    Z = iterate(Z)

Z = np.arange(10000)
np.random.shuffle(Z)
n = 5
print (Z[np.argpartition(-Z,n)[:n]])

def cartesian(arrays):
    arrays = [np.asarray(a) for a in arrays]
    shape = map(len, arrays)
    ix = np. indices(shape, dtype=int)
    ix = ix.reshape(len(arrays), -1).T
    for n, arr in enumerate(arrays):
        ix[:, n] = arrays[n][ix[:, n]]
    return ix
print(cartesian(([1, 2, 3], [4, 5], [6, 7])))

A = np.random.randint(0,5,(8,3))
B = np.random.randint(0,5,(2,2))
C = (A[..., np.newaxis, np.newaxis] == B)
rows = (C.sum(axis=(1,2,3)) >= B.shape[1]).nonzero()[0]
print(rows)

Z = np.random.randint(0,5,(10,3))
E = np.logical_and.reduce(Z[:,1:] == Z[:,:-1], axis=1)
U = Z[~E]
print(Z)
print(U)

I = np.array([0, 1, 2, 3, 15, 16, 32, 64, 128], dtype=np.uint8)
print(np.unpackbits(I[:, np.newaxis], axis=1))

Z = np. random.randint(0, 2, (6,3))
T = np.ascontiguousarray(Z).view(np.dtype((np.void, Z.dtype.itemsize * Z.shape[1])))
_, idx = np.unique(T, return_index=True)
uZ = Z[idx]
print(uZ)

# Make sure to read: http://ajcr.net/Basic-guide-to-einsum/
np.einsum('i->', A)       # np.sum(A)
np.einsum('i,i->i', A, B) # A * B
np.einsum('i,i', A, B)    # np.inner(A, B)
np.einsum('i,j', A, B)    # np.outer(A, B)

Kotlin. Массивы

Статья проплачена кошками — всемирно известными производителями котят.

Если статья вам понравилась, то можете поддержать проект.

Свойство indices
val vs var
Конструктор Array()
Класс Arrays
Перевернуть массив: reversedArray()
Перевернуть массив: reverse()
Сортировка элементов массива
Содержится ли элемент в массиве
Подсчитать сумму чисел в массиве
Найти среднее значение чисел в массиве
Найти наибольшее и наименьшее число в массиве
Функция intersect(): найти общие элементы двух массивов
Выбрать случайную строку из массива
shuffle(): Перемешать элементы (Kotlin 1. 40)
onEach(): Операция с каждым элементом массива по очереди (Kotlin 1.40)
Двумерные массивы

Рассмотрим работу с массивами в Kotlin, которые являются классами.

Массив можно создать двумя способами — через конструктор Array() или через методы arrayOf(), arrayOfNulls(), emptyArray().

arrayOf()

Создадим массив и получим значение третьего элемента.

val myArray = arrayOf(1, 2, 3, 4, 5)
println(myArray[2])

Узнать длину массива можно при помощи свойства size.

println(myArray.size) // 5

А что случится, если мы добавим в массив строки?

val myArray = arrayOf(1, 2, 3, 4, 5, "зайчик", "вышел", "погулять")
println(myArray[5])

Ничего страшного, у нас получился массив смешанного типа. Всё работает, ничего не ломается.

Если мы хотим строгого поведения и не хотим смешивать разные типы, то используем обобщения.

val myArray = arrayOf<Int>(1, 2, 3, 4, 5) // только числа Integer

Существует также синонимы метода, когда уже в имени содержится подсказка: intArrayOf(), harArrayOf(), booleanArrayOf(), longArrayOf(), shortArrayOf(), byteArrayOf().

Перепишем пример.

val myArray = intArrayOf(1, 2, 3, 4, 5)

Пройтись по элементам массива и узнать значение индекса можно с помощью метода withIndex():

val numbersArray = intArrayOf(1, 2, 3, 4, 5)
for ((index, value) in numbersArray.withIndex()) {
    println("Значение индекса $index равно $value")
}

Свойство indices

У массива есть свойство indices и мы можем переписать пример по другому.

val numbers = intArrayOf(1, 2, 3, 4, 5)
for (index in numbers.indices) {
    println("Значение индекса $index равно ${numbers[index]}")
}

Свойство возвращает интервал Range, который содержит все индексы массива. Это позволяет не выйти за пределы массива и избежать ошибки ArrayIndexOutOfBoundsException.

Но у свойства есть очень интересная особенность. Взгляните на код:

val numbers = intArrayOf(1, 2, 3, 4, 5)
for(index in numbers.indices - 2) {
    println(numbers[index])
}

// 1 2 4 5

Из интервала индексов массива мы убрали третий элемент (отсчёт от 0). И теперь при выводе элементов массива мы не увидим числа 3.

Можно сложить два массива.

val numbers = intArrayOf(1, 2, 3)
val numbers3 = intArrayOf(4, 5, 6)
val foo2 = numbers3 + numbers
println(foo2[5]) // 3

arrayOfNulls()

Для создания массива с заполненными значениями null можно использовать отдельную функцию arrayOfNulls().

Создадим массив с тремя элементами.

val array = arrayOfNulls(3) // [null, null, null]
// равносильно
// arrayOf(null, null, null)

Присвоим значения пустым элементам.

var arr2 = arrayOfNulls<String>(2)
arr2.set(0, "1")
arr2.set(1, "2")

// или
arr2[0] = "1"
arr2[1] = "2"

// получить значения
println(arr2[0]) // или arr2.get(0)
println(arr2[1])

emptyArray()

Создадим пустой массив и заполним его данными.

var arr = emptyArray<String>()
arr += "1"
arr += "2"
arr += "3"
arr += "4"
arr += "5"

val vs var

Нужно уяснить разницу между var и val при работе с массивами.

// Создали новый массив
var myArray = arrayOf(1, 2, 3)

// Это совершенно новый массив
myArray = arrayOf(4, 5)

Фактически мы уничтожили первый массив и создали вместо него второй массив.

Если мы попытаем написать такой же код с использованием val, то компилятор запретит такое действие.

// Создали новый массив
val myArray = arrayOf(1, 2, 3)

// Нельзя. Компилятор не пропустит
myArray = arrayOf(4, 5)

Но при этом вы можете менять значения элементов массива, созданного через val.

val myArray = arrayOf(1, 2)
myArray[0] = 3 // меняем первый элемент массива
myArray[1] = 4 // меняем второй элемент массива

Конструктор Array()

При использовании конструктора нужно указать размер массива в первом параметре и лямбда-выражение во втором.

val myArray = Array(5, { i -> i * 2 })
println(myArray[3])

Мы задали пять элементов и каждый элемент в цикле умножаем на 2. В итоге получим массив чисел 0, 2, 4, 6, 8.

Создадим массив строк от «A» до «Z»

val letters = Array<String>(26) { i -> ('A' + i).toString() }
println(letters.joinToString(""))

Лямбда-выражение принимает индекс элемента массива и возвращает значение, которое будет помещено в массив с этим индексом. Значение вычисляется путём сложения индекса с кодом символа и преобразованием результата в строку.

Можно опустить тип массива и написать Array(26), компилятор самостоятельно определит нужный тип.

Есть отдельные классы для каждого примитивного типа — IntArray, ByteArray, CharArray и т.д.

val zeros = IntArray(3) // первый способ
val zeros = intArrayOf(0, 0, 0) // второй способ при помощи фабричного метода
println(zeros.joinToString())

Можно использовать лямбда-выражение.

val intArray = IntArray(4){i -> i + i}
println(intArray.joinToString())

Класс Arrays

Для вывода значений массива используйте класс Arrays с методом toString(), который вернёт результат в удобном и читаемом виде. Сейчас в Kotlin появилась функция contentToString(), которая является предпочтительным вариантом.

println(Arrays.toString(arr)) // старый способ
println(arr.contentToString()) // рекомендуемый способ

Перебор элементов массива

Обычный перебор через for.

val arr = arrayOf(1, 2, 3, 4, 5)

for (i in arr) {
    println("Значение элемента равно $i")
}

Можно одной строкой через forEach.

arr.forEach { i -> println("Значение элемента равно $i") }

Если нужна информация не только о значении элемента, но и его индексе, то используем forEachIndexed.

arr.forEachIndexed { index, element ->
    println("$index : $element")
}

// Результат
0 : 1
1 : 2
2 : 3
3 : 4
4 : 5

Перевернуть массив: reversedArray()

Для операции создадим дополнительную переменную для нового массива с перевёрнутыми значениями. Оригинал останется без изменений.

val numbers: IntArray = intArrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
var reversedArray = numbers.reversedArray()

println(Arrays.toString(reversedArray))

Перевернуть массив: reverse()

Если оригинал массива нам точно не понадобится, то мы можем перевернуть его без создания нового массива.

val numbers: IntArray = intArrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
numbers.reverse()

println(Arrays.toString(numbers))

Сортировка элементов массива

В Kotlin очень просто сортировать элементы.

Вызываем метод sort(). Мы меняем существующий массив, а не создаём новый.

val numbers: IntArray = intArrayOf(7, 5, 8, 4, 9, 6, 1, 3, 2)
numbers.sort()

// println(Arrays.toString(numbers)) // старый способ
println("Sorted array: ${numbers.contentToString()}")

Сортировать можно не весь массив, а только определённый диапазон. Указываем начало и размер диапазона. Допустим, нам нужно отсортировать только первые три элемента из предыдущего примера.

numbers.sort(0, 3)

// 5, 7, 8, 4, 9, 6, 1, 3, 2

Сортировка в обратном порядке от наибольшего значения к наименьшему.

numbers.sortDescending()

Если нужно сохранить исходный массив, то вызываем другие функции, которые создадут новый массив.

val numbers: IntArray = intArrayOf(7, 5, 8, 4, 9, 6, 1, 3, 2)
val sortedNumbers: IntArray = numbers.sortedArray() // новый сортированный массив
val descendingSortedNumber: IntArray = numbers.sortedArrayDescending() // новый сортированный массив в обратном порядке

println("Original array ${numbers.contentToString()}:Sorted array ${sortedNumbers
        .contentToString()}")
// Original array [7, 5, 8, 4, 9, 6, 1, 3, 2]:Sorted array [1, 2, 3, 4, 5, 6, 7, 8, 9]

Для сортировки объектов указываем компаратор и условие сравнения. Например, мы хотим сравнить котов по их возрастам.

val cats = arrayOf(Cat("Барсик", 8), Cat("Мурзик", 4), Cat("Васька", 9))
// массив до сортировки
cats.forEach { println(it) }

// сортируем по возрасту
cats.sortWith(Comparator { c1: Cat, c2: Cat -> c1.age - c2.age })
cats.forEach { println(it) }


data class Cat(val name: String, val age: Int)

Вместо компаратора можно использовать функцию sortBy() с указанием условия. Сравним теперь котов не по возрасту, а по их именам.

val cats = arrayOf(Cat("Барсик", 8), Cat("Мурзик", 4), Cat("Васька", 9))
cats.forEach { println(it) }
cats.sortBy { cat -> cat.name }
cats.forEach { println(it) }


data class Cat(val name: String, val age: Int)

Содержится ли элемент в массиве

Если содержится, то возвращает true.

val array = arrayOf(1, 2, 3, 4, 5)
val isContains = array.contains(9)
println(isContains) // false

Найти среднее значение чисел в массиве

Используем функцию average(). Возвращается Double.

val array = arrayOf(1, 3, 5)
println(array.average()) // 3.0

Подсчитать сумму чисел в массиве

val array = arrayOf(1, 2, 3, 4, 5)
println(array.sum()) // 15

Найти наибольшее и наименьшее число в массиве

В цикле сравниваем каждое число с эталоном, которые вначале принимает значение первого элемента. Если следующее число массива больше эталона, то берём его значение. В итоге после перебора получим наибольшее число в массиве.

val numbers: IntArray = intArrayOf(4, 9, 3, 2, 6)
var largestElement = numbers[0]

for (number in numbers){
    if(largestElement < number)
        largestElement = number
}

println("Наибольшее число в массиве: $largestElement")

Но можно не писать свой код, а вызвать готовые функции min() и max().

println(numbers.min())
println(numbers.max())

Функция intersect(): найти общие элементы двух массивов

Есть два массива с числами. Нужно сравнить их и найти у них общие числа. Поможет нам функция intersect()

val firstArray = arrayOf(1, 2, 3, 4, 5)
val secondArray = arrayOf(3, 5, 6, 7, 8)

val intersectedArray = firstArray.intersect(secondArray.toList()).toIntArray()
println(Arrays.toString(intersectedArray))

//[3, 5]

Выбрать случайную строку из массива

Имеется массив строк. Сначала вычисляем размер массива. Затем генерируем случайное число в диапазоне от 0 до (почти) 1, которое умножаем на количество элементов в массиве. После этого результат преобразуется в целое число вызовом toInt(). Получается выражение типа 0.811948208873101 * 5 = 4. В Kotlin есть свой класс Random, поэтому случайное число можно получить другим способом.

val cats = arrayOf("Барсик", "Мурзик", "Васька", "Рыжик", "Персик")
val arraySize = cats.size

// Java-style
val rand = (Math.random() * arraySize).toInt()
val name = "${cats[rand]}}"
println(name)

// Kotlin-style
val rand = Random. nextInt(arraySize)
val name = "${cats[rand]}"
println(name)

По этому принципу можно создать игру «Камень, Ножницы, Бумага».

private fun getChoice(optionsParam: Array<String>) =
    optionsParam[Random.nextInt(optionsParam.size)]
	
val options = arrayOf("Камень", "Ножницы", "Бумага")
val choice = getChoice(options)
println(choice)

shuffle(): Перемешать элементы (Kotlin 1.40)

Перемешать элементы массива в случайном порядке можно при помощи нового метода shuffle().

val numbers = arrayOf(1, 2, 3, 4, 5)
numbers.shuffle()
println(numbers.contentToString())

onEach(): Операция с каждым элементом массива по очереди (Kotlin 1.40)

В коллекциях мы можем пройтись по всем элементам и что-то с каждым сделать. Теперь такое возможно и с элементами массива. Пройдёмся по всем числам массива, удвоим каждое число и конвертируем в строку.

var str = ""
val numbers = arrayOf(1, 2, 3, 4, 5)
numbers. onEach {str += it * 2}
println(str)

Двумерные массивы

Часто одного массива недостаточно. В некоторых случаях удобно использовать двумерные массивы. Визуально их легко представить в виде сетки. Типичный пример — зал в кинотеатре. Чтобы найти нужно место в большом зале, нам нужно знать ряд и место.

Двумерный массив — это массив, который содержит другие массивы. Создадим двумерный массив 5х5 и заполним его нулями.

// Создаём двумерный массив
var cinema = arrayOf<Array<Int>>()

// заполняем нулями
for (i in 0..4) {
    var array = arrayOf<Int>()
    for (j in 0..4) {
        array += 0
    }
    cinema += array
}

// выводим данные массива
for (array in cinema) {
    for (value in array) {
        print("$value ")
    }
    println()
}
// Результат
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

Сейчас в кинотеатре пусто. Первый зритель берёт билет в центре зала.

// центр зала
cinema[2][2] = 1

// три места во втором ряду
for (i in 1..3) {
    cinema[3][i] = 1
}

// весь первый ряд
for (i in 0..4) {
    cinema[4][i] = 1
}

// выводим данные массива
for (array in cinema) {
    for (value in array) {
        print("$value ")
    }
    println()
}

// Результат
0 0 0 0 0
0 0 0 0 0
0 0 1 0 0
0 1 1 1 0
1 1 1 1 1

По такому же принципу строится трёхмерный массив. На этот раз его можно представить не в виде сетки, а в виде куба. В этом случае сетки идут как бы друг за другом, образуя слои.

var rubikCube = arrayOf<Array<Array<Int>>>()
for (i in 0..2) {
    var piece = arrayOf<Array<Int>>()
    for (j in 0..2) {
        var array = arrayOf<Int>()
        for (k in 0..2) {
            array += 0
        }
        piece += array
    }
    rubikCube += piece
}

// второй слой, третий ряд, первое место
rubikCube[1][2][0] = 1
println(Arrays. deepToString(rubikCube))

// Результат
0, 0, 0 | 0, 0, 0 | 0, 0, 0
0, 0, 0 | 0, 0, 0 | 0, 0, 0
0, 0, 0 | 1, 0, 0 | 0, 0, 0

Реклама

. Создайте все числа от 0 до 100, используя только все числа 1, 2, 3, 4 и 5.

Я написал программу на Python 3:

 из коллекций import defaultdict
из functools импортировать lru_cache
из itertools импортировать комбинации, цепочка, продукт
из оператора import add, sub, mul, truediv, pow
импортировать случайный
@lru_cache (максимальный размер = нет)
по умолчанию мощность(и):
    return chain.from_iterable(комбинации(s, r) для r в диапазоне(1, len(s)))
операции = [
    ('+', добавить),
    ('-', суб),
    ('*', мул),
    ('/', truediv),
    ('**', пау),
]
защитная скобка (ы):
    если len(s) > 1:
        вернуть '(' + с + ')'
    вернуть с
образец (ы):
    вернуть random.sample(s, min(len(s), 5))
@lru_cache (максимальный размер = нет)
деф вычислить (числа):
    если длина (числа) == 1:
        число = число[0]
        вернуть {число: ул (число)}
    ответ = defaultdict(набор)
    для left_parts в наборе мощности (числа):
        right_parts = tuple(x вместо x в цифрах, если x не в left_parts)
        for (left_num, left_strings), (right_num, right_strings) в продукте(
                вычислить(левые_части). элементы(),
                вычислить(right_parts).items()):
            для op_str, op_func в операциях:
                заказы = [список]
                если op_str не в '+*':
                    заказы += [обратный]
                для заказа в заказах:
                    пытаться:
                        result_num = op_func (* порядок ([left_num, right_num]))
                    кроме (ZeroDivisionError, OverflowError):
                        продолжать
                    если isinstance(result_num, комплекс) или abs(result_num) > 1000:
                        продолжать
                    для left_string, right_string в продукте (образец (left_strings),
                                                             образец (правые_строки)):
                        result_string = '{1} {0} {2}'.format (op_str,
                                                             * порядок ([скобка (левая_строка),
                                                                     скобка (правая_строка)]))
                        утверждать eval(result_string) == result_num
                        ответ[номер_результата]. ')
              .заменить('*', '×'))
основной()
 

Он использует сложение, вычитание, умножение, деление, возведение в степень (x в степени y) и круглые скобки. Он дает до 5 решений для каждого числа от 1 до 177. Он может дать решения для многих других чисел, но вы начнете замечать пробелы, поскольку, очевидно, вы не можете составить 178. К сожалению, он недостаточно умен, чтобы сказать, когда два решения, по сути, одинаковы, поэтому часто бывает много очень похожих решений для определенного числа, хотя я пытался их перепутать. Вы также можете получить больше решений на число, но когда я попытался с 7, я достиг предела количества символов в своем ответе. 92)) + 1

Что такое 100% от 12345?

Простой способ вычисления процентов от X

Что такое  %

от  ?

100% of 12345 is: 12345

Percentage of — Table for 12345

Percentage of	Difference
1% of 12345 is 123. 45	12221.55
2% от 12345 составляет 246,9	12098,1
3% от 12345 составляет 370,35	11974.65
4% of 12345 is 493.8	11851.2
5% of 12345 is 617.25	11727.75
6% of 12345 is 740.7	11604.3
7% of 12345 is 864.15	11480.85
8% of 12345 is 987.6	11357.4
9% of 12345 is 1111.05	11233.95
10% of 12345 is 1234.5	11110.5
11% of 12345 is 1357.95	10987.05
12% of 12345 is 1481.4	10863.6
13% of 12345 is 1604.85	10740.15
14% of 12345 is 1728.3	10616.7
15% of 12345 is 1851.75	10493.25
16% of 12345 is 1975. 2	10369.8
17% of 12345 is 2098.65	10246.35
18% of 12345 is 2222.1	10122.9
19% of 12345 is 2345.55	9999.45
20% of 12345 is 2469	9876
21% of 12345 is 2592.45	9752,55
22% из 12345 IS 2715.9	9629.1
23% из 12345 — 2839,35	9505.65
9505,65
9505.65
9505,65
9505,65
9005.65
.0027	25% of 12345 is 3086.25	9258.75
26% of 12345 is 3209.7	9135.3
27% of 12345 is 3333.15	9011.85
28% of 12345 is 3456.6	8888.4
29% of 12345 is 3580. 05	8764.95
30% of 12345 is 3703.5	8641.5
31% of 12345 is 3826.95	8518.05
32% of 12345 is 3950.4	8394.6
33% of 12345 is 4073.85	8271.15
34% of 12345 is 4197.3	8147.7
35% of 12345 is 4320.75	8024.25
36% из 12345 IS 4444.2	7900,8
37% из 12345 IS 4567,65	7777,35
38% 7777,35
38% 12777,35
38% 123455,35
38%.% of 12345 is 4814.55	7530.45
40% of 12345 is 4938	7407
41% of 12345 is 5061.45	7283.55
42% of 12345 is 5184.9	7160.1
43% of 12345 is 5308.35	7036.65
44% of 12345 is 5431. 8	6913.2
45% of 12345 is 5555.25	6789.75
46% of 12345 is 5678.7	6666.3
47% of 12345 is 5802.15	6542.85
48% of 12345 is 5925.6	6419.4
49% of 12345 is 6049.05	6295.95
50% of 12345 is 6172.5	6172.5
51% of 12345 is 6295.95	6049.05
52% of 12345 is 6419.4	5925.6
53% of 12345 is 6542.85	5802.15
54% of 12345 is 6666.3	5678.7
55% of 12345 is 6789.75	5555.25
56% of 12345 is 6913.2	5431.8
57% of 12345 is 7036.65	5308.35
58% of 12345 is 7160.1	5184.9
59% of 12345 is 7283. 55	5061.45
60% of 12345 is 7407	4938
61% of 12345 is 7530.45	4814.55
62% of 12345 is 7653.9	4691.1
63% of 12345 is 7777.35	4567.65
64% of 12345 is 7900.8	4444.2
65% of 12345 is 8024.25	4320.75
66% of 12345 is 8147.7	4197.3
67% of 12345 is 8271.15	4073.85
68% of 12345 is 8394.6	3950.4
69% of 12345 is 8518.05	3826.95
70% of 12345 is 8641.5	3703.5
71% of 12345 is 8764.95	3580.05
72% of 12345 is 8888.4	3456.6
73% of 12345 is 9011.85	3333.15
74% of 12345 is 9135. 3	3209.7
75% of 12345 is 9258.75	3086.25
76% of 12345 is 9382.2	2962.8
77% of 12345 is 9505.65	2839.35
78% of 12345 is 9629.1	2715.9
79% из 12345 IS 9752,55	2592.45
80% из 12345 9876	2469
81%	2469
81%	2469
81%	2469
81%	2469
81%	2469
81%
	82% of 12345 is 10122.9	2222.1
83% of 12345 is 10246.35	2098.65
84% of 12345 is 10369.8	1975.2
85% of 12345 is 10493.25	1851.75
86% of 12345 is 10616.7	1728. 3
87% of 12345 is 10740.15	1604.85
88% of 12345 is 10863.6	1481.4
89% of 12345 is 10987.05	1357.95
90% of 12345 is 11110.5	1234.5
91% of 12345 is 11233.95	1111.05
92% of 12345 is 11357.4	987.6
93% из 12345 IS 11480,85	864,15
94% из 12345 — 11604,3	740,7
	740,7
	. 740,7
	. 740,7
	.0027	96% of 12345 is 11851.2	493.8
97% of 12345 is 11974.65	370.35
98% of 12345 is 12098.1	246.9
99% of 12345 is 12221.55	123.45
100% от 12345 это 12345	0

Как рассчитать 100% от 12345

В магазине вы хотите понять сколько стоит товар вам дали а0, 12345$ сохранен.