За всі роки, з якими я робив цей виклик, 2017 рік - це перший рік, який став головним числом. Тож питання стосуватиметься простих чисел та їх властивостей.

Ваше завдання полягає в тому, щоб створити програму або функцію, яка буде приймати довільно велике додатне ціле число як вхід, і виводити чи повертати, незалежно від того, чи є число 2 077-розсипним , тобто чи найбільший простий коефіцієнт у цьому числі становить 2 077 або менше.

Деякі приклади входів та їх виходів:

1 (has no prime factors)
true

2 (= 2)
true

80 (= 2 x 2 x 2 x 2 x 5)
true

2017 (= 2017)
true

2019 (= 3 x 673)
true

2027 (= 2027)
false

11111 (= 41 x 271)
true

45183 (= 3 x 15061)
false

102349 (= 13 x 7873)
false

999999 (= 3 x 3 x 3 x 7 x 11 x 13 x 37)
true

1234567 (= 127 x 9721)
false

4068289 (= 2017 x 2017)
true

Вашій програмі не потрібно буквально виводити trueі false- будь-які неправдиві або хибні значення, а насправді будь-які два різні результати, які відповідають істинним та помилковим випадкам, є нормальними.

Однак ви не можете використовувати будь-які праймери у вихідному коді. Прайми бувають двох видів:

• Символи або послідовності символів, які представляють букварі простого числа.

  • Символи 2, 3, 5і 7є незаконними в мовах , де числа є допустимими лексеми.

  • Цей номер 141є незаконним, оскільки він містить 41, хоча він 1і 4в іншому випадку дійсний.

  • Символи Bта D(або bі d) є незаконними в мовах, де вони зазвичай використовуються як 11 та 13, наприклад CJam або Befunge.

• Символи, які мають найцінніші значення Unicode або містять байтові значення у кодуваннях.

  • Символи %)+/5;=CGIOSYaegkmqнезаконні в ASCII, а також символ повернення каретки.

  • Символ óнезаконний в UTF-8, оскільки його кодування є 0xb3в ньому. Однак в ISO-8859-1 його кодування є простим 0xf3, що є складовим і тому добре.

Виграє найкоротший код, який можна виконати на будь-якій мові.

Желе , 8 байт

44‘²!*ḍ@

Спробуйте в Інтернеті! Зауважте, що тестові випадки 11111 і вище трохи більше для TIO.

Перевірка

$ source="34,34,fc,82,21,2a,d5,40"
$ xxd -ps -r > 2017.jelly <<< $source
$ xxd -g 1 2017.jelly
0000000: 34 34 fc 82 21 2a d5 40                          44..!*.@
$ eval printf '"%d "' 0x{$source}; echo # Code points in decimal
52 52 252 130 33 42 213 64
$ test_cases="1 2 80 2017 2019 2027 11111 45183 102349 999999 1234567 4068289"
$ for n in $test_cases; do printf "%11d: %d\n" $n $(jelly f 2017.jelly $n); done
      1: 1
      2: 1
     80: 1
   2017: 1
   2019: 1
   2027: 0
  11111: 1
  45183: 0
 102349: 0

Тестовий випадок 999999 працює вже 13 годин. Я песимістично ставлюсь до обчислень 2025 року! ^4068289 ...

Як це працює

44‘²!*ḍ@  Main link. Argument: n

44        Yield 44.
  ‘       Increment to yield 45.
   ²      Square to yield 2025.
          Note that no integers in [2018, ..., 2025] are prime numbers.
    !     Take the factorial of 2025.
     *    Raise it to the n-th power.
          This repeats all prime factors in 2025! at least n times, so the result
          will be divisible by n if (and only if) all of its prime factors fall
          in the range [1, ..., 2025].
      ḍ@  Test the result for divisibility by n.

Желе , 8 символів, 14 байт UTF-8

Æf½ṀḤ<90

Спробуйте в Інтернеті!

Jelly зазвичай використовує власну кодову сторінку для програм. Однак більшість його споріднених вбудованих елементів починаються з Æкодової точки 13; не дуже корисно. На щастя, інтерпретатор також підтримує UTF-8, який має дружніше кодування.

Перевірка

Ця програма, в UTF-8, має шістнадцяткове розвантаження:

00000000: c386 66c2 bde1 b980 e1b8 a43c 3930  ..f........<90

Перевірка, що всі байти складені:

$ for x in c3 86 66 c2 bd e1 b9 80 e1 b8 a4 3c 39 30; do factor $((0x$x)); done
195: 3 5 13
134: 2 67
102: 2 3 17
194: 2 97
189: 3 3 3 7
225: 3 3 5 5
185: 5 37
128: 2 2 2 2 2 2 2
225: 3 3 5 5
184: 2 2 2 23
164: 2 2 41
60: 2 2 3 5
57: 3 19
48: 2 2 2 2 3

Перевірте, чи всі точки коду Unicode складені:

$ perl -Mutf8 -E '$a = ord, print `factor $a` for split //, "Æf½ṀḤ<90"'
198: 2 3 3 11
102: 2 3 17
189: 3 3 3 7
7744: 2 2 2 2 2 2 11 11
7716: 2 2 3 643
60: 2 2 3 5
57: 3 19
48: 2 2 2 2 3

Єдиний маркер, проаналізований як число, є 90. Ніхто з 9, 0і не 90є простим.

Пояснення

Основне математичне розуміння тут полягає в тому, що 45 ² - це 2025 рік, який акуратно припадає на період 2017 (поточний рік) і 2027 (наступний розквіт). Таким чином, ми можемо взяти квадратний корінь кожного просте множника числа і побачити, чи не перевищує його 45. На жаль, ми не можемо записати 45через буквальне 5, тому нам доведеться подвоїти його і порівняти з 90.

Æf½ṀḤ<90
Æf        In the list of prime factors,
  ½       taking the square root of each element
   Ṁ      then taking the largest element
    Ḥ     and doubling it
     <90  produces a result less than 90.

Математика, 62 58 55 байт

Останні три збережені байти повністю завдяки Мартіну Ендеру!

#4<4||#<44*46&&#6[#^-1#4]&[Divisors[#][[6-4]],,,#,,#0]&

Безіменна функція, приймаючи позитивний цілий аргумент і повертаючи Trueабо False.

Рекурсивний алгоритм, #4<4який є справжньою базовою справою (він потрібен лише для повернення Trueна імпульс 1, але додаткові базові випадки є нормальними). В іншому випадку ми обчислюємо другий найменший дільник (який обов'язково є простим) входу з Divisors[#][[6-4]]; якщо він більший за 2024 ( 44*46), тоді ми виходимо з False, інакше називаємо функцію рекурсивно (використовуючи #6встановлене значення #0) на вході, розділеному на цей малий простий коефіцієнт #(який ми маємо виразити як #^-1введення разів #4, оскільки /це заборонено).

Конструктивно, перша половина #4<4||#<44*46&&#6[#^-1#4]&є анонімна функція з шести аргументів, викликається з аргументами Divisors[#][[6-4]], Null, Null, #, Null, і #0; це обійти заборону на персонажах 2, 3і 5.

Попередня версія, яка зберегла чотири байти, замінивши 8018-6000на 44*46, натхненна відповіддю Jelly Ais523 (Мартін Ендер, здавалося, надихнувся коментарем ais523):

#<4||Divisors[#][[6-4]]<44*46&&#0[Divisors[#][[6-4]]^-1#]&

Це було досить неприємно: я досі не знаю, як реально встановити змінну в Mathematica при цих обмеженнях! Як =і eв Setвідкинуті. Уникнення +і )також було проблемою, але не надто важко обійтися за рахунок більшої кількості байтів.

Haskell, 48 47 байт

\n->[snd$[product[1..44*46]^n]!!0`divMod`n]<[1]

В основному це переклад відповіді Дженніса «Желе» . xnor врятував байт.

Використовується […]!!0як круглі дужки, тому що )заборонено, а snd+ divModтому, що mв modі remзаборонено.

Пайк, 10 8 7 9 байт

P_Z|hwMX<

Спробуйте тут!

Збережено 1 байт, використовуючи спосіб генерації Денніса 2025 року

P         -     factors(input)
 _        -    reversed(^)
  Z|      -   ^ or 0
    h     -  ^[0] or 1
        < - ^ < V
     wM   -  ⁴45 (ord("M")-32)
       X  -  ^**2

Брахілог , 9 10 байт

*$ph$r*<90

Спробуйте в Інтернеті!

В основному, використовуючи той же алгоритм, що і моя інша відповідь. $phзнаходить перший ( h) простий фактор ( $p); це найбільший простий фактор, оскільки списки простих факторів Брахілога переходять від найбільшого до найменшого. Потім я беру квадратний корінь ( $r), подвійний ( *) і перевіряю, чи не менше 90 ( <90).

Я повинен був подвоїти вхід спочатку, тому що у 1 немає простих факторів (і, отже, немає першого основного фактора). Це додає додатковий простий коефіцієнт 2, який не може вплинути на те, чи є число 2017-м роздрібним, але запобігає збою при роботі 1.

Власне , 9 байт

τyM:44u²≥

Дякуємо Деннісу за багато байтів!

Спробуйте в Інтернеті!

Пояснення:

τyM:44u²≥
τyM        largest prime factor of 2*input (doubled to deal with edge case of n = 1)
   :44u²   2025 (2027 is the next prime after 2017, so any number in [2017, 2026] can be used here - 2025 is very convenient)
        ≥  is 2025 greater than or equal to largest prime factor?

Математика, 66 74 байти

Дякуємо Деннісу за те, що U+F4A1він зазначив, що це заборонено.

Fold[Function[{x,d},And[x,Tr[Divisors@d^0]>6-4||d<44*46]],0<1,Divisors@#]&

Пояснення:

Divisors@#: Список цілих дільників першого аргументу #.

0<1: Гольф для True(також уникає використання букви e).

Divisors@d^0: Список форми, {1, 1, ..., 1}довжина якої дорівнює кількості дільників d.

Tr: Для плоского списку Trповертає суму цього списку. Таким чином Tr[Divisors@d^0]повертається кількість дільників d.

Function[{x,d},And[x,Tr[Divisors@d^0]>6-4||d<44*46]]: Анонімна функція з двома аргументами xта d. Ідея полягає в тому, що dце дільник, #і ми перевіряємо, чи він складений чи менший або рівний 2017(включно). 2017-напруженість рівносильна всім дільникам, що задовольняють цій умові. Як було виявлено ais523 , бути простим рівнем, меншим або рівним 2017, еквівалентно тому, що є простим меншим ніж 2025. Як зазначив Грег Мартін , достатньо перевірити, чи менший він 2024=44*46. Аргумент xвиступає акумулятором того, чи задовольняють усі властивості, що дійшли до цього часу. Потім ми залишили Foldцю функцію через усі дільники #з початковим значеннямTrue, оскільки ми не маємо доступу ні до Mapні /@.

05AB1E , 10 байт

fθ46n99-›È

Повертає 1, якщо вірно, 0 в іншому випадку.

Спробуйте в Інтернеті!

Пояснення

f          # Push the list of prime factors (ordered)
 θ         # Get the last element
  46n99-   # Push 2017 (46² - 99)
        >  # Push 1 if the last prime factor is greater than 2017, 0 otherwise
         È # Is the resulting number even ? Transforms 1 to 0 and 0 to 1.
           # Implicit display

MATL , 15 байт

t:\~ftZp*44QU<A

Виходи 0для сипких, що не є 2017 року, або 1для 2017 року.

Спробуйте в Інтернеті! Або перевірити всі тестові випадки .

Ця програма перевіряє, чи всі байти складені.

Пояснення

t       % Implicit input n. Duplicate
:       % Range [1 2 ... n]
\       % Modulo. Gives 0 for divisors of n
~f      % Indices of zero values
t       % Duplicate
Zp      % Is-prime. Gives 1 for primes, 0 for composites
*       % Multiply
44QU    % 44, add 1, square: 2025
<       % Less than, element-wise
A       % True (1) if all entries are nonzero

Баш, 144 байти

Кодування ASCII:

{
printf '[ '
`tr D-Z _-z <<<KFH`tor $1|tr -d :|`tr B-Z _-z <<<JUH`p -o '[0-9]*$'
printf ' -lt $[24*86-46] ]'
}|tr \\n \ |`tr B-Z _-z <<<EDVK`

Як зазвичай для оболонки, вихідний код вказує на успіх (0) або провал (не-0).

Це фактично інше написання

[ factor $1|tr -d :|grep -o '[0-9]*$' -lt 2018 ]

Ми отримуємо найбільший фактор за допомогою factor $1|grep -o '[0-9]*$'; tr -d :є спеціальним випадком для введення = 1.

Вираз $[6*6*69-466]оцінюється до 2018 року.

Бути складно використовувати trдля імен команд і досі використовувати підстановку команд - я не міг використовувати форму вставки $( ), тому я в кінцевому підсумку перейшов до іншого Bash, щоб оцінити результат.

Результати тесту:

$ for i in 1 2 80 2017 2019 2027 11111 45183 102349 999999 1234567 4068289; do printf '%d %s\n' $i `./105241.sh $i  && echo true || echo false`; done
1 true
2 true
80 true
2017 true
2019 true
2027 false
11111 true
45183 false
102349 false
999999 true
1234567 false
4068289 true

Підтвердження кодів символів:

$ grep -v '^#' ./105241.sh | perl -n -Mutf8 -E '$a = ord, print `factor $a` for split //, $_' | grep -v ': .* ' | wc -l
0

Pyth, 11 байт

!s>R^h44h1P

Спробуйте в Інтернеті. Тестовий набір.

Використовуйте фокус Денніса, щоб отримати 2025 рік, а потім перевіряє, чи немає основних факторів введення більше.

Джулія 0,4 , 84 38 37 байт

n->1^n:44*46|>prod|>t->t^n-t^n÷n*n<1

Очікує аргумент BigInt .

Спробуйте в Інтернеті! або переконайтеся, що жоден байт не є простим .

Japt , 14 байт

k æ¨44*46 ?0:1

Повертає 1, якщо вірно, 0, якщо неправдиво.

Спробуйте тут .

Braingolf , 11 байт [дуже неконкуренто]

VRp#ߢ-?0:1

Спробуйте в Інтернеті!

Не зчитується через те, ߢщо гвинти з цифрами, проте все ще працює в перекладачі.

Я навіть не помічав обмежень щодо символів, коли писав це, але все, що мені потрібно було зробити, - це змінити дивного символу Unicode з 2017 на 2018 рік.

Враховуючи, що 2018 рік не є прем'єр-міністром, будь-який прем'єр <= 2018також є<= 2017

Пояснення

VRp#ߢ-?0:1  Implicit input from command-line args
VR            Create stack2, return to stack1
  p           Split last item into prime factors, push each one to stack in asc order
   #ߢ         Push 2018
     -      Subtract last 2 items (highest prime factor - 2017)
      ?     If last item > 0..
       0    ..push 1
        :   Else..
         1  ..Push 1
            Implicit output of last item on stack