Привет, читатели! Это еще один эпизод из этой серии, в котором мы погружаемся в проблему информатики и анализируем ее на пяти языках программирования. Вероятно, это последняя серия в этом году, так что считайте ее моим рождественским подарком.

Проблема, которую мы собираемся решить сегодня, — это классическая проблема простоты, которую я выбрал из hackerrank, давайте посмотрим на описание проблемы:

Простым числом называется натуральное число больше 1, не имеющее положительных делителей, кроме 1 и самого себя. Для заданного целого числа p определите простоту каждого целого числа и верните Prime или Not Prime в новой строке.

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

С введением выше, я думаю, мы уже достаточно освоились, чтобы начать искать решения, выбранные для этой проблемы.

Юлия

Первое решение взято из языка, который играет главную роль в этой серии, язык Julia очень приятно удивил меня своими функциями и простотой, а также тем, насколько естественно и приятно писать код на Julia, даже если у вас нет опыта. на языке

function primality(n)
    if n <= 1
        return "Not prime"
    end
    
    for x in 2:n-1
        if n%x == 0
            return "Not prime"
        end
    end
    "Prime"
end

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

Если n больше 1, создается диапазон от 2 до n-1, и мы устанавливаем цикл для итерации по нему, и если n делится на любое значение в этом диапазоне, нам просто нужно вернуть “Not премьер”.

Вланг

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

fn primality(n int) string {
 if n <= 1 {
  return "Not prime"
 }

 arr_size := n-2

 entries := []int{len: arr_size, init: it+2}

 for i in entries {
  if n%i == 0 {
   return "Not prime"
  }
 }

 return "Prime"
}

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

Затем по записям выполняется цикл, и проверяется, делится ли он, если да, то возвращаем "Не простое", иначе нам просто нужно вернуть "Премиум".

JavaScript

Следующее решение - это решение JavaScript, для императивного языка решение было довольно коротким и лаконичным, единственное, что мне не понравилось, это то, что мне пришлось использовать цикл for, потому что я думал, что это будет более подходящим, чем цикл while, который меняет состояние рукой

const primality = (n) => {
    if(n<=1) 
        return "Not prime"
    for (let divisor = 2; divisor < n-1; divisor++) {
        if(n%divisor == 0)
            return "Not prime"
    }
    return "Prime"
}

Эликсир

Функциональные языки — это те, которые будут больше расходиться в формате решения.

defmodule Primality do 
  def primality(n) when n <= 1 do
    "Not prime"
  end
  def primality(2), do: "Prime"
  def primality(n) do 
    any_divisible = Enum.any? 2..n-1, &(rem(n, &1)==0)
    case any_divisible do 
      true -> "Not prime"
      _ -> "Prime"
    end
  end
end

Используя сопоставление с образцом в решении, мы объявляем функции несколько раз, проверяя, меньше ли оно единицы в первом объявлении, проверяя, является ли оно 2 во втором объявлении, а в последнем объявлении мы используем ». любой?» функция, которая проверяет, делится ли n на любую запись в интервале от 2 до n-1, если это так, мы возвращаем «Не простое число», а в противном случае мы просто возвращаем Prime в структуре case.

Хаскелл

Второй функциональный язык также имеет решение, отличное от всех предыдущих.

primality n 
    | n <= 1 || anyDivisible = "Not prime"
    | otherwise = "Prime"
    where
        interval = [2..n-1]
        anyDivisible = length (filter (\v -> n`rem`v==0) interval) > 0

В Haskell я решил использовать охранников для проверки условий, в области где я определил интервал от 2 до n-1 и применил фильтр, чтобы получить все возможные делители.

В первом сторожевом предложении мы проверяем, меньше ли оно 1 или были ли найдены какие-либо делители, если да, то это не простое число.

И в последнем предложении нам просто нужно вернуть "Prime".

Сначала мне показалось, что это решение достаточно хорошее, но потом я вспомнил, что в Haskell также есть функция any, поэтому я внес несколько улучшений в решение, используя функцию «any» и оценивая логическое значение, которое я использовал из композиции функций «function2 . function1'где я выполняю оставшуюся часть деления и передаю этот результат второй функции, которая сравнивает, равен ли он нулю.

primality n 
    | n <= 1 || anyDivisible = "Not prime"
    | otherwise = "Prime"
    where
        interval = [2..n-1]
        anyDivisible = any ((0 ==) . (n`rem`)) interval

Вот и все, мы сделали еще одну серию из этой серии, было очень приятно попробовать новые языки и представить новые в этой серии, и, конечно же, в следующем году будет больше серий, так что следите за обновлениями
Приятного просмотра курортного сезона и до встречи в следующем году!!
Спасибо за чтение!