# Функциональные учебные проблемы -- algorithm поле с участием haskell поле с участием coding-style пол Связанный проблема

## Functional learning woes

3 ### проблема

русский

Я начинающий к функциональным языкам, и я пытаюсь зацепить все это в Haskell. Вот быстроразъемная функция, которая находит все факторы номера:

` <код> factors :: (Integral a) => a -> [a] factors x = filter (z -> x `mod` z == 0) [2..x `div` 2]   `

работает нормально, но я обнаружил, что это невыносимо медленно для больших чисел. Так что я сделал себя лучше:

` <код> factorcalc :: (Integral a) => a -> a -> [a] -> [a] factorcalc x y z     | y `elem` z      = sort z     | x `mod` y == 0  = factorcalc x (y+1) (z ++ [y] ++ [(x `div` y)])     | otherwise       = factorcalc x (y+1) z   `

Но вот моя проблема: хотя код работает, и может вырезать буквально часов от времени выполнения моих программ, это em> отвратитель!

Он пахнет уродливым императивным мышлением: он постоянно обновляет счетчик и структуру данных в петле, пока она не закончится. Поскольку вы не можете изменить состояние в чисто функциональном программировании, я изменял, удерживая данные в параметрах, которые функция просто передается к себе снова и снова.

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

Английский оригинал

I'm a beginner to functional languages, and I'm trying to get the whole thing down in Haskell. Here's a quick-and-dirty function that finds all the factors of a number:

``factors :: (Integral a) => a -> [a] factors x = filter (z -> x `mod` z == 0) [2..x `div` 2] ``

Works fine, but I found it to be unbearably slow for large numbers. So I made myself a better one:

``factorcalc :: (Integral a) => a -> a -> [a] -> [a] factorcalc x y z     | y `elem` z      = sort z     | x `mod` y == 0  = factorcalc x (y+1) (z ++ [y] ++ [(x `div` y)])     | otherwise       = factorcalc x (y+1) z ``

But here's my problem: Even though the code works, and can cut literally hours off the execution time of my programs, it's hideous!

It reeks of ugly imperative thinking: It constantly updates a counter and a data structure in a loop until it finishes. Since you can't change state in purely functional programming, I cheated by holding the data in the parameters, which the function simply passes to itself over and over again.

I may be wrong, but there simply must be a better way of doing the same thing...

</div

## Список ответов

5 Обратите внимание, что оригинальный вопрос задан для всех факторов, а не только для факторов Prime . Существует множество основных факторов, они, вероятно, могут быть найдены быстрее. Возможно, это то, что хотел OQ. Возможно нет. Но давайте решим оригинальную проблему и поставить «весело» обратно в «Функциональную»!

Некоторые наблюдения:

.
• Две функции не дают один и тот же выход --- если X - идеальный квадрат, вторая функция включает в себя квадратный корень дважды.

• Первая функция перечисляет проверку ряда потенциальных факторов, пропорциональных размеру x; Вторая функция проверяет только пропорционально квадратному корню <код> x , затем останавливается (с ошибкой, отмеченной выше).

• Первая функция (<код> factors ) выделяет список всех целых чисел от 2 до <код> n div 2 , где вторая функция никогда не выделяет список, но вместо этого посещает Меньше целых чисел один за раз в параметре. Я провел оптимизатор с помощью <код> -O и посмотрел на вывод с <код> -ddump-simpl , и ghc просто не достаточно умно, чтобы оптимизировать эти распределения.

• <Код> factorcalc - рекурсивный хвост, что означает, что он компилирует в тесную петлю машины; <Код> filter нет и нет.

Некоторые эксперименты показывают, что квадратный корень - убийца :

Вот образец функции, которая производит факторы X из Z до 2:

` <код> factors_from x 1 = [] factors_from x z    | x `mod` z == 0 = z : factors_from x (z-1)   | otherwise      =     factors_from x (z-1)  factors'' x = factors_from x (x `div` 2)   `

Это немного быстрее, потому что он не выделяет, но это все еще не рекурсивно.

Вот рекурсивная версия для хвоста, которая более верна оригиналу:

` <код> factors_from' x 1 l = l factors_from' x z l   | x `mod` z == 0 = factors_from' x (z-1) (z:l)   | otherwise      = factors_from' x (z-1) l  factors''' x = factors_from x (x `div` 2)   `

Это все еще медленнее, чем <код> x0 , потому что он перечисляет все целые числа от 2 до <код> x1 , тогда как <код> x2 останавливается на квадратном корне. < / P >.

Вооруженные этими знаниями, теперь мы можем создать более функциональную версию <код> x3 , которые копируют как его скорость, так и его ошибку:

` <код> x4  `

У меня не было времени, но дано 100 миллионов в качестве ввода, как IT, так и <код> x5 расторгнуть мгновенно, где другие все занимают несколько секунд.

Как и почему работает работает работает как упражнение для читателя: -)

addendum : ok, чтобы смягчить кровотечение глазного яблока, вот слегка церемонная версия (и без ошибки):

` <код> x6  `

Note that the original question asked for all the factors, not for only the prime factors. There being many fewer prime factors, they can probably be found more quickly. Perhaps that's what the OQ wanted. Perhaps not. But let's solve the original problem and put the "fun" back in "functional"!

Some observations:

• The two functions don't produce the same output---if x is a perfect square, the second function includes the square root twice.

• The first function enumerates checks a number of potential factors proportional to the size of x; the second function checks only proportional to the square root of `x`, then stops (with the bug noted above).

• The first function (`factors`) allocates a list of all integers from 2 to `n div 2`, where the second function never allocates a list but instead visits fewer integers one at a time in a parameter. I ran the optimizer with `-O` and looked at the output with `-ddump-simpl`, and GHC just isn't smart enough to optimize away those allocations.

• `factorcalc` is tail-recursive, which means it compiles into a tight machine-code loop; `filter` is not and does not.

Some experiments show that the square root is the killer:

Here's a sample function that produces the factors of x from z down to 2:

``factors_from x 1 = [] factors_from x z    | x `mod` z == 0 = z : factors_from x (z-1)   | otherwise      =     factors_from x (z-1)  factors'' x = factors_from x (x `div` 2) ``

It's a bit faster because it doesn't allocate, but it's still not tail-recursive.

Here's a tail-recursive version that is more faithful to the original:

``factors_from' x 1 l = l factors_from' x z l   | x `mod` z == 0 = factors_from' x (z-1) (z:l)   | otherwise      = factors_from' x (z-1) l  factors''' x = factors_from x (x `div` 2) ``

This is still slower than `factorcalc` because it enumerates all the integers from 2 to `x div 2`, whereas `factorcalc` stops at the square root.

Armed with this knowledge, we can now create a more functional version of `factorcalc` which replicates both its speed and its bug:

``factors'''' x = sort \$ uncurry (++) \$ unzip \$ takeWhile (uncurry (<=)) \$                  [ (z, x `div` z) | z <- [2..x], x `mod` z == 0 ] ``

I didn't time it exactly, but given 100 million as an input, both it and `factorcalc` terminate instantaneously, where the others all take a number of seconds.

How and why the function works is left as an exercise for the reader :-)

ADDENDUM: OK, to mitigate the eyeball bleeding, here's a slightly saner version (and without the bug):

``saneFactors x = sort \$ concat \$ takeWhile small \$                 [ pair z | z <- [2..], x `mod` z == 0 ]     where pair z = if z * z == x then [z] else [z, x `div` z]           small [z, z'] = z < z'           small [z]     = True ``
</div

4 Хорошо, сделайте глубокий вдох. Это все будет хорошо.

Прежде всего, Почему ваша первая попытка медленно? Как это проводит свое время?

Можете ли вы подумать о рекурсивном определении для главной факторизации, у которого нет этого свойства?

( Подсказка .)

Okay, take a deep breath. It'll be all right.

First of all, why is your first attempt slow? How is it spending its time?

Can you think of a recursive definition for the prime factorization that doesn't have that property?

(Hint.)

</div

1 Во-первых, хотя <код> factorcalc - это «уродливый», вы можете добавить функцию обертки <код> factors' x = factorscalc x 2 [] , добавить комментарий и переместить дальше.

Если вы хотите сделать «красивый» <код> factors быстро, вам нужно выяснить, почему он медленно. Глядя на две две функции, <Код> factors проводит список о N / 2 элементов длиной, но <код> factorcalc останавливается после того, как вокруг <код> sqrt n > Итерации.

Вот еще один <код> factors , который также останавливается после того, как <код> sqrt n iTerations, но использует складку вместо явной итерации. Это также нарушает проблему на три части: нахождение факторов (<Код> factor ); Остановка на квадратный корень из x (<код> small ), а затем вычислительные пары факторов (<код> factors' x = factorscalc x 2 []0 ):

`. Факторы :: (Integral A) = & gt; A - & GT; [а] ФАКТОРЫ x = Сортировка (FoldL Factize [] (Thingile Mall Mall (Filter Factor [2 ..]))))   куда     Фактор z = x `mod` z == 0     маленький z = z & lt; = (x `div` z)     Факторизировать ACC Z = Z: (если z == y, а затем в соотношении царапания Y: ACC)       где y = x `div` z `

Это незначительно быстрее, чем <код> factors' x = factorscalc x 2 []1 на моей машине. Вы можете предопределить <код> factors' x = factorscalc x 2 []2 и <код> factors' x = factorscalc x 2 []3 и это примерно вдвое больше, чем <код> factors' x = factorscalc x 2 []4 .

Профилирование и оптимизация Глава реального мира Haskell Хорошее руководство по инструментам производительности HHC Suite для решения более жестких проблем с производительностью.

Кстати, у меня есть второстепенный стиль Nitpick с <Код> factors' x = factorscalc x 2 []5 : гораздо более эффективно настроить один элементы перед передней частью списка O (1), чем присоединение к концу списка длины n o (n). Списки факторов обычно маленькие, поэтому не такая большая сделка, но <Код> factors' x = factorscalc x 2 []6 , вероятно, должно быть чем-то вроде:

`. FactorCalc :: (Integral A) = & gt; A - & GT; A - & GT; [A] - & GT; [а] FactorCalc X Y Z     |. Y `Elem` Z = сортировка z     |. x `mod` y == 0 = factorcalc x (y + 1) (y: (x` div`y y): z)     |. в противном случае = factorcalc x (y + 1) z `

Firstly, although `factorcalc` is "ugly", you could add a wrapper function `factors' x = factorscalc x 2 []`, add a comment, and move on.

If you want to make a 'beautiful' `factors` fast, you need to find out why it is slow. Looking at your two functions, `factors` walks the list about n/2 elements long, but `factorcalc` stops after around `sqrt n` iterations.

Here is another `factors` that also stops after about `sqrt n` iterations, but uses a fold instead of explicit iteration. It also breaks the problem into three parts: finding the factors (`factor`); stopping at the square root of x (`small`) and then computing pairs of factors (`factorize`):

` factors' :: (Integral a) => a -> [a] factors' x = sort (foldl factorize [] (takeWhile small (filter factor [2..])))   where     factor z = x `mod` z == 0     small z = z <= (x `div` z)     factorize acc z = z : (if z == y then acc else y : acc)       where y = x `div` z `

This is marginally faster than `factorscalc` on my machine. You can fuse `factor` and `factorize` and it is about twice as fast as `factorscalc`.

The Profiling and Optimization chapter of Real World Haskell is a good guide to the GHC suite's performance tools for tackling tougher performance problems.

By the way, I have a minor style nitpick with `factorscalc`: it is much more efficient to prepend single elements to the front of a list O(1) than it is to append to the end of a list of length n O(n). The lists of factors are typically small, so it is not such a big deal, but `factorcalc` should probably be something like:

` factorcalc :: (Integral a) => a -> a -> [a] -> [a] factorcalc x y z     | y `elem` z      = sort z     | x `mod` y == 0  = factorcalc x (y+1) (y : (x `div` y) : z)     | otherwise       = factorcalc x (y+1) z `
</div

1 Так как вы не можете изменить состояние чисто Функциональное программирование, я обманул Удерживая данные в параметрах, к которому функция просто проходит сам снова и снова.

На самом деле, это не изменяет; Это A-NO, сделайте, что The The The The Adstrawndard Technique! Этот тип параметра обычно известен как «аккумулятор», и он, как правило, скрыт в функции помощника, которая выполняет фактическую рекурсию после настройки функции, которую вы вызываете.

Общий случай - это когда вы выполняете перечень операций, которые зависят от предыдущих данных в списке. Две проблемы, которые вам необходимо решить, где вы получаете данные о предыдущих итерациях, и как вы справляетесь с тем, что ваша «рабочая область интереса» для любой конкретной итерации на самом деле на хвосте списка результатов вас здание. Ибо оба из них аккумулятор приходит к спасению. Например, для генерации списка, где каждый элемент является суммой всех элементов входного списка до этого значения:

` <код> sums :: Num a => [a] -> [a] sums inp = helper inp []     where         helper []     acc       = reverse acc         helper (x:xs) []        = helper xs [x]         helper (x:xs) acc@(h:_) = helper xs (x+h : acc)   `

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

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

Since you can't change state in purely functional programming, I cheated by holding the data in the parameters, which the function simply passes to itself over and over again.

Actually, this is not cheating; this is a—no, make that the—standard technique! That sort of parameter is usually known as an "accumulator," and it's generally hidden within a helper function that does the actual recursion after being set up by the function you're calling.

A common case is when you're doing list operations that depend on the previous data in the list. The two problems you need to solve are, where do you get the data about previous iterations, and how do you deal with the fact that your "working area of interest" for any particular iteration is actually at the tail of the result list you're building. For both of these, the accumulator comes to the rescue. For example, to generate a list where each element is the sum of all of the elements of the input list up to that point:

``sums :: Num a => [a] -> [a] sums inp = helper inp []     where         helper []     acc       = reverse acc         helper (x:xs) []        = helper xs [x]         helper (x:xs) acc@(h:_) = helper xs (x+h : acc) ``

Note that we flip the direction of the accumulator, so we can operate on the head of that, which is much more efficient (as Dominic mentions), and then we just reverse the final output.

By the way, I found reading The Little Schemer to be a useful introduction and offer good practice in thinking recursively.

</div

1 Это казалось интересной проблемой, и я некоторое время не закодировал какого-либо настоящего хэска, поэтому я дал ему трещину. Я запускаю как IT, так и Norman's ` factors'''' ` против тех же значений, и он чувствует себя , как шахты быстрее, хотя они оба так близко, что это трудно сказать.

.
` <код> factors :: Int -> [Int] factors n = firstFactors ++ reverse [ n `div` i | i <- firstFactors ]     where     firstFactors = filter (i -> n `mod` i == 0) (takeWhile ( i -> i * i <= n ) [2..n])   `

Факторы могут быть соединены в те, которые больше, чем <код> sqrt n , а те, которые меньше или равны (для простоты, точного квадратного корня, если <код> n Это идеальный квадрат, попадает в эту категорию. Так что, если мы просто возьмем те, которые меньше или равны, мы можем рассчитать других позже, делая <код> div n i . Они будут в обратном порядке Таким образом, мы можем либо обратить вспять <код> firstFactors сначала или отменить результат позже. Это не имеет значения.

This seemed like an interesting problem, and I hadn't coded any real Haskell in a while, so I gave it a crack. I've run both it and Norman's `factors''''` against the same values, and it feels like mine's faster, though they're both so close that it's hard to tell.

``factors :: Int -> [Int] factors n = firstFactors ++ reverse [ n `div` i | i <- firstFactors ]     where     firstFactors = filter (i -> n `mod` i == 0) (takeWhile ( i -> i * i <= n ) [2..n]) ``

Factors can be paired up into those that are greater than `sqrt n`, and those that are less than or equal to (for simplicity's sake, the exact square root, if `n` is a perfect square, falls into this category. So if we just take the ones that are less than or equal to, we can calculate the others later by doing `div n i`. They'll be in reverse order, so we can either reverse `firstFactors` first or reverse the result later. It doesn't really matter.

</div

0 Это мой «функциональный» подход к проблеме. («Функциональ» в кавычках, потому что я бы поддержал эту проблему таким же образом даже на нефункциональных языках, но, возможно, это потому, что я был испорчен Haskell.)

` <код> {-# LANGUAGE PatternGuards #-} factors :: (Integral a) => a -> [a] factors = multiplyFactors . primeFactors primes 0 [] . abs where     multiplyFactors [] =      multiplyFactors ((p, n) : factors) =         [ pn * x         | pn <- take (succ n) \$ iterate (* p) 1         , x <- multiplyFactors factors ]     primeFactors _ _ _ 0 = error "Can't factor 0"     primeFactors (p:primes) n list x         | (x', 0) <- x `divMod` p         = primeFactors (p:primes) (succ n) list x'     primeFactors _ 0 list 1 = list     primeFactors (_:primes) 0 list x = primeFactors primes 0 list x     primeFactors (p:primes) n list x         = primeFactors primes 0 ((p, n) : list) x     primes = sieve [2..]     sieve (p:xs) = p : sieve [x | x <- xs, x `mod` p /= 0]   `

<Код> primes - наивное сито эратотененов. Там лучше, но это самый короткий метод.

` <код>    sieve [2..] => 2 : sieve [x | x <- [3..], x `mod` 2 /= 0] => 2 : 3 : sieve [x | x <- [4..], x `mod` 2 /= 0, x `mod` 3 /= 0] => 2 : 3 : sieve [x | x <- [5..], x `mod` 2 /= 0, x `mod` 3 /= 0] => 2 : 3 : 5 : ...   `

<Код> factors''''0 - это простое повторяющееся алгоритм пробного деления: он проходит через список простых чисел, и пытается разделить данный номер каждой, запись факторов, как это происходит.

` <код> factors''''1  `

<Код> factors''''2 принимает список простых чисел и полномочий и взрывается его обратно в полный список факторов.

` <код> factors''''3  `

<Код> factors''''4 Просто строки эти две функции вместе с <код> factors''''5 для предотвращения бесконечной рекурсии в случае негативной рекурсии.

This is my "functional" approach to the problem. ("Functional" in quotes, because I'd approach this problem the same way even in non-functional languages, but maybe that's because I've been tainted by Haskell.)

``{-# LANGUAGE PatternGuards #-} factors :: (Integral a) => a -> [a] factors = multiplyFactors . primeFactors primes 0 [] . abs where     multiplyFactors [] =      multiplyFactors ((p, n) : factors) =         [ pn * x         | pn <- take (succ n) \$ iterate (* p) 1         , x <- multiplyFactors factors ]     primeFactors _ _ _ 0 = error "Can't factor 0"     primeFactors (p:primes) n list x         | (x', 0) <- x `divMod` p         = primeFactors (p:primes) (succ n) list x'     primeFactors _ 0 list 1 = list     primeFactors (_:primes) 0 list x = primeFactors primes 0 list x     primeFactors (p:primes) n list x         = primeFactors primes 0 ((p, n) : list) x     primes = sieve [2..]     sieve (p:xs) = p : sieve [x | x <- xs, x `mod` p /= 0] ``

`primes` is the naive Sieve of Eratothenes. There's better, but this is the shortest method.

``   sieve [2..] => 2 : sieve [x | x <- [3..], x `mod` 2 /= 0] => 2 : 3 : sieve [x | x <- [4..], x `mod` 2 /= 0, x `mod` 3 /= 0] => 2 : 3 : sieve [x | x <- [5..], x `mod` 2 /= 0, x `mod` 3 /= 0] => 2 : 3 : 5 : ... ``

`primeFactors` is the simple repeated trial-division algorithm: it walks through the list of primes, and tries dividing the given number by each, recording the factors as it goes.

``   primeFactors (2:_) 0 [] 50 => primeFactors (2:_) 1 [] 25 => primeFactors (3:_) 0 [(2, 1)] 25 => primeFactors (5:_) 0 [(2, 1)] 25 => primeFactors (5:_) 1 [(2, 1)] 5 => primeFactors (5:_) 2 [(2, 1)] 1 => primeFactors _ 0 [(5, 2), (2, 1)] 1 => [(5, 2), (2, 1)] ``

`multiplyPrimes` takes a list of primes and powers, and explodes it back out to a full list of factors.

``   multiplyPrimes [(5, 2), (2, 1)] => [ pn * x    | pn <- take (succ 2) \$ iterate (* 5) 1    , x <- multiplyPrimes [(2, 1)] ] => [ pn * x | pn <- [1, 5, 25], x <- [1, 2] ] => [1, 2, 5, 10, 25, 50] ``

`factors` just strings these two functions together, along with an `abs` to prevent infinite recursion in case the input is negative.

</div

0 Я не знаю много о haskell, но как-то я думаю, что эта ссылка подходит:

Редактировать: Я не совсем уверен, почему люди настолько агрессивны по поводу снижения этого. Оригинальная реальная проблема плаката заключалась в том, что код был уродливым; Хотя это забавно, точка связанного статьи в некоторой степени, что расширенный код Haskell, на самом деле, уродливый; Чем больше вы учитесь, уродливый ваш код получает в некоторой степени. Точка этого ответа заключалась в том, чтобы указать на ОП, который, по-видимому, уродство кода, которое он лежал, не редкость.

Edit: I'm not entirely sure why people are so aggressive about the downvoting on this. The original poster's real problem was that the code was ugly; while it's funny, the point of the linked article is, to some extent, that advanced Haskell code is, in fact, ugly; the more you learn, the uglier your code gets, to some extent. The point of this answer was to point out to the OP that apparently, the ugliness of the code that he was lamenting is not uncommon.

</div

## Связанный проблема

0  FFT фундаментальный расчет частоты от Lomontfft  ( Fft fundamental frequency calculation from lomontfft )
Я использую lomontfft с http://www.lomont.org/ Программное обеспечение / MISC / FFT / LOMONTFFT.HTML Чтобы получить фундаментальную частоту от выборных знач...

3  Алгоритм быстрее чем BMH (Boyer-Moore-Harspool)  ( Algorithm faster than bmh boyer moore horspool search )
Какой алгоритм вы бы использовали для поиска коротких подстроек в коротких текстах? К метку я имею в виду 5-10 символов для подстроки и 255 для строки. Я дума...

10  Сумма продуктов для нескольких списков в Python  ( Sum of products for multiple lists in python )
Попытка имитировать функцию Sumproduct Excel: <код> SUMPRODUCT(v1, v2, ..., vN) = v1*v2*...*vN + v1*v2*...*vN + ... + v1[n]*v2[n]*...*...

1  В Scala, какой правильный способ сортировки списка на композитный ключ  ( In scala what is the right way to sort a list on a composite key )
Я пытаюсь получить лучшие элементы N-1 из списка. Я прошел через подобные посты в так, как здесь . Я понял мотивы за решениями, предложенными на этих постах....

0  Самый дешевый способ классификации http post объекты  ( Cheapest way to classify http post objects )
Я могу использовать Scipy, чтобы классифицировать текст на моей машине, но мне нужно классифицировать строковые объекты из http Post Post at, или в ближайшее ...

1  OpenCV: алгоритм для простого вращения и уменьшения изображения  ( Opencv algorithm for simple image rotation and reduction )
Я пробовал вращение и уменьшение изображения (JPEG) с <Код> getRotationMatrix2D(center, angle, scale); и <код> warpAffine(image1, image3, rotation, image3.si...

0  Нужна помощь со страницей ходьба алгоритма  ( Need some help with page walking algorithm )
Я пишу свою собственную операционную систему, и я хочу подтвердить, устанавливаются ли грязные биты или нет. Поэтому я хочу пройти через определенный виртуаль...

8  Быстрый текст поиск по журналам  ( Fast text search over logs )
Вот проблема у меня есть, у меня есть набор журналов, которые могут быстро быстро расти. Они разделяются в отдельные файлы каждый день, и файлы могут легко ра...

5  Найти максимальные бийкики  ( Finding maximal bicliques )
У меня есть проблема, которую я смог моделировать как нахождение максимальных бийкликов (полные двусторонние графики) в бипарттовом графике. Я знаю, что алгор...

1  Обнаружение спама в (объективном-) C  ( Spam detection in objective c )
Я в настоящее время пишу приложение для iPhone, которое получает некоторые данные от пользователя и загружает его на сервер. Загруженные данные будут отобража...

0  Как я могу получить родитель в бинарном дереве  ( How can i get the parent in binary tree )
Как я могу получить родителя в двоичном дереве в этом коде? Я написал это: <код> public class Node { public string state; public Node Left; pu...

1  Изменить отсортированный массив или сортировать массив каждый раз?  ( Modify sorted array or sort the array everytime )
Проблема: учитывая массив размера n, распечатайте отсортированные подборки размеров k с последовательными элементами. <код> N = 10, K = 4 8 4 7 5 1 10 3 9 ...

255  Самый эффективный способ реализации целочисленной функции питания POW (INT, INT)  ( The most efficient way to implement an integer based power function powint int )
Что является наиболее эффективным способом поднять целое число к силе другое целое число в C? <код> // 2^3 pow(2,3) == 8 // 5^5 pow(5,5) == 3125 ...

5  Максимальная щедрость от двух путей через прямоугольную сетку  ( Maximum bounty from two paths through a rectangular grid )
Я пытаюсь решить проблему, похожую на это Проблема в GeeksForGeeks , но другой: Учитывая прямоугольную 2-D сетку с некотором значением монеты, присутствующе...

6  Теоретически, находит_енди параллельно?  ( In theory is find end parallelizable )
В настоящее время я работаю над open -Под предложению Для достижения параллельной функциональности проекту я работаю, но я столкнулся с дорожным блоком с f...