Запаморочливе ціле перерахування

25

Ваша задача сьогодні - вивести заданий термін послідовності, що перераховує всі цілі числа. Послідовність така: Якщо ми маємо 0-індексовану функцію, яка генерує послідовність f(n)і ceil(x)є функцією стелі, то f(0) = 0; abs(f(n)) = ceil(n/2); sign(f(n))є позитивним, коли nіceil(n/2) чи обидва або обидва , навіть дивно.

Щоб зрозуміти цю послідовність, перші кілька термінів наступні: 0 1 -1 -2 2 3 -3 -4 4 5 -5 -6 6 7 -7...

Ваше завдання - написати програму, яка приймає ціле число nі виводитьn третій член послідовності. Введення може бути лише 0 або 1-індексованим.

Тести (0-індексовано):

0  =>  0
1  =>  1
2  => -1
3  => -2
4  =>  2
5  =>  3

Це кодовий гольф , найменше виграш байтів!

code-golf  sequence  integer 
— Павло
джерело
— sergiol
Здається, зворотна функція складання
— сергіол

Відповіді:

8

SOGL V0.12 , 8 6 байт

I».»⌡±

Спробуйте тут! або спробуйте перші пару номерів (трохи змінили, щоб це спрацювало)
0-індексованими.

Пояснення:

I       increment the input
 »      floor divide by 2
  .     push the original input
   »    floor divide by 2
    ⌡   that many times
     ±    negate

Або простіше:

(input + 1) // 2 negated input // 2 times
        I     »     ±      .     »    ⌡
— дзайма
джерело
3
НЕ ВІДПОВІСТЬ ОДИНУ ХВІЛНУ!
— NieDzejkob
6
Я ».»по телефону I».»⌡±.
— Джонатан Аллан
@JonathanAllan Я не розумію ._.
— Павло
4

C, 25 байт

f(n){return~n/2*~-(n&2);}
— orlp
джерело
Ви можете зберегти 4 байти, призначивши своє повернене значення першому параметру замість використання ключового слова return. f(n){n=~n/2*~-(n&2);}
— cleblanc
5
@cleblanc Це не так, як працює C.
— orlp
2
gcc -O0для x86-64 трапляється компілювати версію @ cleblanc до інструкцій, які залишають результат множення в eax( godbolt.org/g/dztKPV ), але тоді це буде x86-64 gcc -O0відповідь, а не відповідь на С. Я не відповідаю на відповіді C, які перериваються з увімкненою оптимізацією, особливо не з таким дурним останнім виразом, як лайно з поверненою вартістю. Навіть якщо так працює GCC, це не так, як працює C.
— Пітер Кордес
Зробіть на покажчик. Оптимізації вам не потрібні, якщо вихідні та кінцеві значення відсутні у стеці.
— mreff555
1
@ mreff555 Це був би нестандартний (хоча прийнятний) метод вводу-виводу, і не був би коротшим.
— orlp
3

Математика, 24 байти

(s=⌈#/2⌉)(-1)^(#+s)&

-14 байт від @Misha Lavrov

— J42161217
джерело
1
Використання Booleі OddQпризводить до перетворення непарних чисел у 1 і парних чисел до 0, але тут вам це не потрібно: повноваження -1 дають вам правильну відповідь на всі непарні числа. Таким чином, ви можете скоротити цей крок (-1)^Tr@{#,s}або просто (-1)^(#+s).
— Міша Лавров
3

Haskell , 25 43 42 байт

((do a<-[0..];[[-a,a],[a,-a]]!!mod a 2)!!)

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

Редагувати: попередня версія мала знаки в неправильному порядку, завдяки @ Potato44 за вказівку. Виправлено на 18 байт ...

Редагувати 2: Дякую БМО за -1 байт!

— Лайконі
джерело
Ви можете зберегти 1 байт, використовуючи do-notation, спробуйте його в Інтернеті!
— ბიმო
@BMO Дякую! ...
— Лайконі
2

Кубічно , 23 байти

(1-індексований)

FDF'$:7+8/0_0*0-8*7/0%6

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

Основна складність при написанні коду кубічно:

  • Є лише одна змінна, здатна до запису, і
  • Отримати константи важко.

Отже, це рішення підрахуйте

((((n+1)/2)%2)*2-1)*n/2

де / позначає ціле ділення. Для цього потрібна лише 1 тимчасова змінна, а константи 1 і 2.

Пояснення:

FDF'$:7+8/0_0*0-8*7/0%6
FDF'                      Set face value of face 0 to 2, and value of memory index 8 (cube is unsolved) to 1 (true = unsolved)
    $                     Read input
     :7                                 input
       +8                                + 1
         /0                        (        ) /2
           _0                     (             ) %2
             *0                  (                  ) *2
               -8                                        -1
                 *7             (                          ) *n
                   /0                                          /2
                     %6   Print
— користувач202729
джерело
2

TI-Basic (TI-84 Plus CE), 20 байт

‾int(‾Ans/2)(1-2remainder(int(Ans/2),2

Повна програма, яка називається подібною 5:prgmNAME.

TI-Basic - це токенізований ланцюг , усі використовувані тут жетони є одним байтом, за винятком remainder(якого є два. ‾являє собою негативний маркер, який набирається (-)ключем.

Приклади:

0:prgmNAME
 => 0
1:prgmNAME
 => 1
2:prgmNAME
 => -1
#etc

Пояснення:

‾int(‾Ans/2)(1-2remainder(int(Ans/2),2
‾int(‾Ans/2)                           # -int(-X) is ciel(X), so ciel(Ans/2)
                          int(Ans/2)   # int(X) is floor(X), so floor(Ans/2)
                remainder(int(Ans/2),2 # 1 if floor(Ans/2) is odd else 0
            (1-2remainder(int(Ans/2),2 # -1 if floor(Ans/2) is odd, else 1
_int(_Ans/2)(1-2remainder(int(Ans/2),2 # -ciel(Ans/2) if floor(Ans/2) is odd, else ciel(Ans/2)

Та ж формула, що і для функції Y-var:

Y1= ‾int(‾X/2)(1-2remainder(int(X/2),2
— піцарі184
джерело
2

Java 8, 15 байт

n->~n/2*~-(n&2)

EDIT: Чи справді Java найкоротша з мов, що не гольфують ?! о.Ô

Пояснення:

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

Я буду використовувати таблицю нижче як орієнтир на те, що відбувається.

  1. ~nдорівнює -n-1.
  2. Оскільки цілочисельний поділ у Java автоматично підпадає на додатні цілі числа та припиняється на негативні цілі числа, ~n/2це призведе до послідовності0,-1,-1,-2,-2,-3,-3,-4,-4,-5,-5,...
  3. n&2призведе до 0або 2в послідовності, або0,0,2,2,0,0,2,2,0,0,2,...
  4. ~-xдорівнює (x-1), тому ~-(n&2)( ((n&2)-1)) призводить до послідовності-1,-1,1,1,-1,-1,1,1,-1,-1,1,...
  5. Помноження двох послідовностей ~n/2і ~-(n&2)дає правильну послідовність, задану у виклику:0,1,-1,-2,2,3,-3,-4,4,5,-5,...

Оглядова таблиця:

n       ~n      ~n/2    n&2     ~-(n&2)     ~n/2*~-(n&2)
0       -1      0       0       -1          0
1       -2      -1      0       -1          1
2       -3      -1      2       1           -1
3       -4      -2      2       1           -2
4       -5      -2      0       -1          2
5       -6      -3      0       -1          3
6       -7      -3      2       1           -3
7       -8      -4      2       1           -4
8       -9      -4      0       -1          4
9       -10     -5      0       -1          5
10      -11     -5      2       1           -5
— Кевін Круїссен
джерело
2

Мозг-Флак , 86 74 72 70 байт

{({}[()]<({}<>([({})]{(<{}([{}]())>)}{}())<>)>)}{}<>{}{<>([{}])(<>)}<>

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

Пояснення

У цьому коді є дві частини. Перша частина

({}[()]<({}<>([({})]{(<{}([{}]())>)}{}())<>)>)}{}

робить м'язи обчислення. Він визначає, ceil(n/2)чи потрібно нівелювати вихід.

Щоб пояснити, як це працює, спершу поясню, як можна було б розрахувати ceil(n/2). Це можна зробити за допомогою наступного коду

{({}[()]<({}([{}]()))>)}{}

Це віднімається від n кожного разу, коли воно виконує не (([{}]()) ) на лічильнику і додає лічильник до результату. Оскільки лічильник дорівнює нулю в половину часу, ми збільшуємо лише кожен другий пробіг, починаючи з першого.

Тепер я хочу також обчислити ознаку наших результатів. Для цього ми запускаємо ще один лічильник. Цей лічильник змінює стан лише тоді, коли перший лічильник вимкнено. Таким чином ми отримуємо бажану схему. Ми ставимо ці два лічильники на вимкнений стек, щоб полегшити їх переміщення, коли настане час.

Тепер, коли ми закінчили це обчислення, наш стек виглядає приблизно так

          parity(n)
ceil(n/2) sign

Тому нам потрібно провести деяку роботу, щоб отримати запланований результат у цій другій частині.

<>{}{<>([{}])(<>)}<>
— Пшеничний майстер
джерело
1

QBIC , 27 26 байт

g=(:+1)'\2`~(a-g)%2|?-g\?g

Пояснення

g=          set worker var 'g' to
(:+1)           our index (plus one for the ceil() bit)
'\2`            integer divided by 2 (the int div needs a code literal: '..`
~(a-g)%2    IF index - temp result is odd (index 2 minus result 1 = 1)
|?-g        THEN PRINT g negated
\?g         ELSE PRINT g
— steenbergh
джерело
1

Clojure 122 байти

Багатослівний, навіть при гольфі. Я збираюся тут проголосувати за співчуття ... :-)

Гольф:

(defn d[n](let[x(int(Math/ceil(/ n 2)))y(cond(or(and(even? n)(even? x))(and(odd? n)(odd? x)))(Math/abs x):else(- 0 x))]y))

Безголівки:

(defn dizzy-integer [n]
  (let [x   (int (Math/ceil (/ n 2)))
        y   (cond
                (or (and (even? n) (even? x))
                    (and (odd? n)  (odd? x))) (Math/abs x)
                :else (- 0 x)) ]
    y))
— Боб Джарвіс - Відновлення Моніки
джерело
1

32-бітний Excel VBA, 39 37 байт

Анонімна функція негайного вікна VBE, яка приймає вхід з комірки A1та виводить у безпосереднє вікно VBE

?[Sign((-1)^Int(A1/2))*Int((A1+1)/2)]

Обмежено 32-бітним, оскільки A^Bнедійсне в 64-бітовому ( A ^Bнастільки ж близьке, наскільки це можливо)

— Тейлор Скотт
джерело
Чи потрібен простір між (-1)і ^[Intпотрібен?
— Павло
@Pavel принаймні для 64-розрядної версії Excel VBA, так; Але це сказало, що я клянусь, що це не для 32-розрядної версії, але, на жаль, я не можу перевірити це на будь-якому апаратному забезпеченні, яке я маю під рукою
— Тейлор Скотт,
@Pavel - Я розглянув це в 32-бітній системі (специфікація встановлення за замовчуванням), і в цій системі місця не потрібно - я обмежив рішення 32-бітним, щоб скористатися цим
— Тейлор Скотт,
1
Класно! Ви забули додати у виправлену кількість байтів.
— Павло
Ой, спасибі @Pavel - Виправлено зараз
— Тейлор Скотт
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.