Вступ

Я наткнувся на цю (марну) картину днями, поки дивився телевізор. Я назвав його "9 візерунком", тому що перший номер, який використовував його, був 9. Суть його полягає в тому, що ви вводите число (скажімо, x ), а потім повертаєтесь назад:

• х
• x + ( x / 3) [назвемо це y ]
• дві третини y [назвемо це z ]
• z + 1

Отже, якби я помістив всередині цього шаблону число 9 як х , це вийшло б:

• 9 ( 9 )
• 12 ( 9 + 9/3 ) [9 понад 3 - це 3, а 9 + 3 - 12]
• 8 ( 12 разів дві третини) [третина з 12 - 4, а 4 * 2 - 8]
• 9 ( 8 + 1 - 9)

Виклик

Напишіть мені функцію (будь-якою мовою програмування), яка приймає число, і виводить цілий масив, використовуючи шаблон.
Приблизно такий псуедо-код:

function ninePattern(int myInt) returns IntegerArray {  
    int iterationA = myInt + (myInt / 3);  
    int iterationB = iterationA * (2 / 3); 
    int iterationC = iterationB + 1;  
    IntegerArray x = [myInt, iterationA, iterationB, iterationC];  
    return x;  
}

Роз'яснення

Обговорення викликали коментарі щодо специфікацій питання. Цей розділ призначений для уточнення деяких із них.

"краще рахувати в байтах, ніж символів"

Я вибирав персонажів, бо (як мінімум, мені було б простіше судити. Звичайно, я не можу це змінити зараз. (багато відповідей уже розміщено)

"округлення"

Закруглення слідує за цією римою:

Якщо 5 або більше, піднесіть бал
Якщо це 4 або менше, нехай відпочиває

Простіше кажучи, якщо це щось на зразок 4,7 або 3,85, округляйте їх до 5 і 4 відповідно.

Приклади

Input => Result
9 => [9, 12, 8, 9]
8 => [8, 11, 7, 8]
6 => [6, 8, 5, 6]
23 => [23, 31, 21, 22]
159 => [159, 212, 141, 142]

Якщо, однак, цифри на зразок 2.3 або 10.435446, округляйте їх до 2 та 10 відповідно.

"підтримка мови"

Ви не можете використовувати функції та / або масиви ЯКЩО ТА ТІЛЬКИ, ЯКЩО обрана вами мова не підтримує їх. Якщо це станеться (навіть якщо це збільшить кількість ваших персонажів), ви повинні їх використовувати .

MarioLANG, 659 621 591 582 556 543 516 458 418 401 352 308 369 байт

округлення досить дороге: /

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

;>>[![( [( [( [( [( [<(([!)))!+(((-<>( >((+
:"==#================"===#== #=====""[ "==
)(  -[!)>>[![)  [)[<(!>)[<)) >))) [!!-[!((
 (  )"#="==#======="=#==="=<="=====##==#==<
 +  +>) )-+<>+)[!)+! +))![-[)>[ [([-[![<<:
 +  )-+ )(=""===#==#  ==#===)"=======#=====
 +  >!>)!>  !(- < !:+:))<  ))!((++)))< 
 )  "#"=#===#===" ======" ===#======="
 !
=#========================

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

Час пояснення:

(для версії 352 байти)

спочатку дістаємо аргумент і друкуємо його:

;
:

досить простий

Потім ми переходимо до основної частини програми: введення поділу / 3

;>>[![              [( [( [<result
:"==#======================"======
)   -[!)>>[![        [<((((!   
)   )"#="==#=========="====#
+(  +>) )  +>(+)[!)+))!
+(  )-+ )  -"====#====#
+   >!>)!  >! -  <
    "#"=#  "#===="
 !
=#

що є дещо зміненою конверсією відділу головного мозку

[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]

які беруть для введення

n 0 d 0 0 

і поверне тобі

0 n d-n%d n%d n/d 

Як тільки ми ділимо поділ, ми використовуємо його, щоб отримати суму n і n / d та роздрукувати її

;>>[![              [( [( [<    !+(((-<
:"==#======================"===)#====="
)   -[!)>>[![        [<((((!    >))) [!(((
)   )"#="==#=========="====#   ="=====#==:
+(  +>) )  +>(+)[!)+))!
+(  )-+ )  -"====#====#
+   >!>)!  >! -  <
    "#"=#  "#===="
 !
=#

Потім нам потрібно зробити ще один поділ: (2 * (n + n / d)) / 3

тому ми отримуємо (2 * (n + n / d)

;>>[![              [( [( [<    !+(((-<
:"==#======================"===)#====="
)   -[!)>>[![        [<((((!    >))) [!(((
)   )"#="==#=========="====#   ="=====#==:
+(  +>) )  +>(+)[!)+))! 2*2n/d>[   -[![  <
+(  )-+ )  -"====#====# ======"======#====
+   >!>)!  >! -  <            !((++))<
    "#"=#  "#===="            #======"
 !
=#

і поставити його з 3 назад у відділ

;>>[![              [( [( [<    !+(((-<
:"==#======================"===)#====="
)   -[!)>>[![        [<((((!    >))) [!(((
)   )"#="==#=========="====#   ="=====#==:
+(  +>) )  +>(+)[!)+))!      )>[   -[![  <
+(  )-+ )  -"====#====#      )"======#====
+   >!>)!  >! -  <       +++))!((++))<
    "#"=#  "#====" ===========#======"
 !
=#=================

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

і щоб встановити, що нам потрібен спосіб розмежувати перший і другий поділ, це врешті-решт, о, радість, у нас є спосіб

;>>[![              [( [( [<([!)!+(((-<
:"==#======================"==#)#====="
)   -[!)>>[![        [<((((!))< >))) [!(((
)   )"#="==#=========="====#)="="=====#==:
+(  +>) )  +>(+)[!)+))!!:+:)))>[   -[![  <
+(  )-+ )  -"====#====#======)"======#====
+   >!>)!  >! -  <       +++))!((++))<
    "#"=#  "#====" ===========#======"
 !
=#=================

в основному ми дивимось, якщо х в

x 0 n d-n%d n%d n/d 

дорівнює 0, якщо це означає, що ми перебуваємо на першому поділі

інакше ми перебуваємо на другому поділі, і ми просто роздруковуємо результат ділення, додаємо 1, а потім знову друкуємо

і вуаля легко як пиріг.

Emotinomicon 99 байт, 33 символи

😷😭,😲🆙🆙😼🆙😨😎⏬😎🆙😍➗➕🆙😨😎⏬😎😉✖😍➗🆙😨😎⏬😎😅➕😨

Пояснення:

😷                                 clear output
 😭                                begin quote string
  ,                               
   😲                              end quote string
    🆙                             duplicate top of stack
     🆙                            duplicate top of stack
      😼                           take numeric input
       🆙                          duplicate top of stack
        😨                         pop N and output as a number
         😎                        reverse stack
          ⏬                       pops and outputs top of stack as character
           😎                      reverse stack
            🆙                     duplicate top of stack
             😍                    push 3 to the stack
              ➗                   divide top two elements on stack
               ➕                  add top two elements on stack
                🆙                 duplicate top of stack
                 😨                pop N and output as a number
                  😎               reverse stack
                   ⏬              pops and outputs top of stack as character
                    😎             reverse stack
                     😉            push 2 to the stack
                      ✖           multiply top two elements on stack
                       😍          push 3 to the stack
                        ➗         divide top two elements on stack
                         🆙        duplicate top of stack
                          😨       pop N and output as a number
                           😎      reverse stack
                            ⏬     pops and outputs top of stack as character
                             😎    reverse stack
                              😅   push 1 to the stack
                               ➕  add top two elements on stack
                                😨 pop N and output as a number

MATL, 14 байт

Xot4*3/tE3/tQv

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

Досить простий, vоб'єднує стек у масив. Xoперетворюється на цілий тип даних, і всі операції після цього є цілими операціями.

Чеддар , 27 байт

b=8/9*$0
[$0,$0+$0/3,b,b+1]

$0є змінною з введенням. Cheddar просто не є зграбною мовою ¯ \ _ (ツ) _ / ¯, також це є неконкурентоспроможним, оскільки функція введення Cheddar була створена після цього виклику.

Безголівки:

IterationB := 8 / 9 * $0  // 8/9ths of the Input
[ $0,                     // The input
  $0 + $0 / 3,            // Input + (Input/3)
  IterationB,             // (see above)
  IterationB + 1          // above + 1
]

Ява, 86 82 84 85 символів

class c{int[]i(int I){int a=I+(I/3),b=(int)(a*(2d/3d));return new int[]{I,a,b,b+1};}}

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

Безголівки:

class c{
    int[] i(int I) {
        int a = I + (I / 3),
            b = (int)(a * (2d / 3d));
        return new int[]{I, a, b, b + 1};
    }
}

Без класу ( class c{}становить 8 символів), він зменшується до 76 символів:

int[]i(int I){int a=I+(I/3),b=(int)(a*(2d/3d));return new int[]{I,a,b,b+1};}

Більш точна версія в 110 символів (118 з перерахунком) - вона використовує floats, тому що для кастингу ніхто не має місця Math#round(double):

int[]i(int I){float a=I+(I/3f),b=(a*(2f/3f));return new int[]{I,Math.round(a),Math.round(b),Math.round(b+1)};}

Ява, 56 80 байт

Як зазначали деякі користувачі, це рішення (як і деякі інші у Java) не округляє дані належним чином. Тому зараз я пропоную трохи довше рішення, яке має повернути правильний результат

int[]h(int a){int[]b={a,Math.round(a+a/3f),a=Math.round(a*8f/9),++a};return b;}

або 60 байт версії ламда

a->new int[]{a,Math.round(a+a/3f),a=Math.round(a*8f/9),++a}

Гольф-версія

int[]g(int a){int[]b={a,a+a/3,a*8/9,a*8/9+1};return b;}

і невольф

int[] g(int a) {
        int[] b = { a, a + a / 3, a * 8 / 9, a * 8 / 9 + 1 };
        return b;
    }

або 36 байт, визначених як лямбда

a->new int[]{a,a+a/3,a*8/9,a*8/9+1}

Java, 64 байти

int[]f(int i){return new int[]{i,i+=i/3+0.5,i-=i/3-0.5,i+=1.5};}

Примітки

• Це необхідне вбудовування округлення, не впевнений, чи можна робити це коротше, якщо його змішують із рішенням @ user902383.

Безумовно

int[] f(int i) {
    return new int[]{
            i, 
            i += i / 3 + 0.5, 
            i -= i / 3 - 0.5, 
            i += 1.5};
}

Вихід з i = 9

[9, 12, 8, 9]

Скретч, 33 байти

Запрошує введення, встановлює aвведення округленим, встановлює bта cїх відповідні зміни, потім говорить всі чотири числа, відокремлені комами.

Java 8 лямбда, 109 81 79 75 символів

Тому що ... ти знаєш ... навіть Java може бути в гольфі ...

a->{int b=(int)(.5+a*4./3),c=(int)(.5+b*2./3);return new int[]{a,b,c,++c};}

Лямбда невольф на клас:

class C {  
   static int[] a(int a) {
        int b = (int) (.5 + a * 4. / 3),
            c = (int) (.5 + b * 2. / 3);
        return new int[]{a, b, c, ++c};
    }
}

Я припускаю, що мені дозволяється використовувати longs, оскільки вони також є цілим числом. На жаль, потрібно правильно округлити цілі числа, і, таким чином, "короткий" склад не працює. Використовуючи longs, нам не потрібно повертати результати округлення до ints.

Оновлення

Використовуючи приємний маленький + 0,5 і після цього трюк, ми зберігаємо правильне округлення і зберігаємо 2 символи!

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

Mathematica - 21 байт

Щойно отримав Mathematica від моїх братів RPi, тож спробував це для розваги, і що краще, ніж виклик PPCG.

{#,4#/3,8#/9,8#/9+1}&

Визначає анонімну функцію. Спробуйте так:

In[26]:= x:={#,4#/3,8#/9,8#/9+1}&                                             

In[27]:= x[9]                                                                 

Out[27]= {9, 12, 8, 9}

Python 3, 45 байт

f=lambda i:map(round,[i,i*4/3,i*8/9,i*8/9+1])

Дивіться цей код, який працює на ideone.com

Луа, 52 байти

Ця програма приймає число за аргументом командного рядка і повертає відповідний масив. Програми в луа технічно є функціями, оскільки перекладач завжди інкапсулює їх у функції. Це також цей механізм, який використовується, коли ви "викликаєте" коди в інших файлах (в основному він використовує loadfile/ dofile).

m=math.floor x=...z=m(x*8/9)return{x,m(x*4/3),z,z+1}

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

`;;3@/+;32/*;uk1½+♂≈`

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

Спробуйте в Інтернеті! (додатковий .в кінці оцінює функцію і друкує результат)

Пояснення:

`;;3@/+;32/*;uk1½+♂≈`
 ;;                    make two copies of x
   3@/+                divide by 3, add that to x to get y
       ;32/*           make a copy of y and multiply by 2/3 to get z
            ;u         make a copy of z and add one
              k        push stack as a list
               1½+     add 0.5 to each element
                  ♂≈   apply int() to each element (make integers from floats by flooring; this is equivalent to rounding half-up because of adding 0.5)

Mathcad, [tbd] байт

Еквівалентність байт кодового гольфу Mathcad ще не встановлена. Якщо вважати число клавіатури приблизним еквівалентом, рішення становить приблизно 40 байт.

05AB1E , 15 байт

Код:

Ð3/+D·3/D>)1;+ï

Використовує кодування CP-1252 . Спробуйте в Інтернеті! .

Пайк, 11 байт

D}[}3/bD)[h

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

            - implicit input()
D           - a,b = ^
 }          - b*=2
  [}3/bD)   - macro:
   }        -   tos*=2
    3/      -   tos/=3
      b     -   tos = round(tos)
       D    -   old_tos = tos = tos
            - macro
         [  - macro
          h - d +=1

Javascript, 50 байт

Я конвертую своє Java-рішення в JavaScript і трохи його знежирив.

var r=Math.round,g=a=>[a,r(a+a/3),a=r(a*8/9),++a]

C ++ 0x - 95 102 185 189 109 129 символів

int * n(int p){static int a[3];a[0]=p;a[1]=round(p+(p/3));a[2]=round((a[1]/3)*2);a[3]=a[2]+1;return a;}

• Для цього потрібен заголовок cmath для роботи.

Degolfed

#include <cmath>
int * ninePattern(int p) {
        static int a[3]; // pattern array
        a[0] = p; // sets first iteration
        a[1] = round(p + (p / 3)); // sets second iteration
        a[2] = round((a[1] / 3) * 2); // sets third iteration
        a[3] = a[2] + 1; // sets fourth iteration
        return a; // returns array
}

Ерланг, 80 байт

-module(f).
-export([f/1]).
f(X)->Y=X+(X/3),Z=trunc(Y*(2/3)),[X,trunc(Y),Z,Z+1].

Для запуску збережіть як f.erl , компілюйте та викликайте функцію. Він поверне список ints:

fxk8y@fxk8y:/home/fxk8y/Dokumente/erlang/pcg# erl
Erlang/OTP 18 [erts-7.0] [source] [64-bit] [smp:4:4] [async-    threads:10] [kernel-poll:false]

Eshell V7.0  (abort with ^G)
1> c(f).
{ok,f}
2> f:f(9).
"\t\f\b\t"
3>

Зауважте, що Erlang автоматично перетворює int s в ASCII символи, якщо ви перебуваєте в діапазоні значень ASCII, оскільки Erlang не має типу char . Виклик функції 100 забезпечує кращу читаність [100,133,88,89] .

Безголівки:

-module(f).
-export([f/1]).

f(X) ->
  Y = X+(X/3),
  Z = trunc(Y*(2/3)),
  [X, trunc(Y), Z, Z+1].

Ерланг, 46 байт

Відповідь, натхненна @ fxk8y (я не зміг розмістити коментар до його відповіді)

F=fun(X)->Z=round(X*4/9),[X,Z*3,Z*2,Z*2+1]end.

Також ви можете побачити результати за допомогою:

2> io:fwrite("~w~n", [F(9)]).                         
[9,12,8,9]
ok

Pyth, 20 байт

m.RdZ[Jc*4Q3Kc*2J3hK

Пояснення:

            (Implicit print)
m           For each d in array, d =
.RdZ        Round d to zero decimal places
[           The array of
  J         The result of setting J to
    c       The float division of
      *4Q   Input * 4
      3     and 3
            ,
  K         The result of setting K to
    c       The float division of
      *2J   J * 2
      3     and 3
            , and
  hK        K + 1.
            (Implicit end array)

Тест тут

Джольф, 17 байт

Ώ‘Hγ+H/H3Βώ/γ3hΒ’

Визначає функцію Ώ. Він приймає вкладення неявно, тому він також є повноцінною програмою. Спробуйте тут!

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

FoldList[#2@#&,{#,Round[4#/3]&,Round[2#/3]&,#+1&}]&

Анонімна функція, яка відповідає поточній (на момент публікації) версії повідомлення, яка передбачає округлення на кожному кроці.

FoldList- типова операція в програмуванні. Він викликається як FoldList[f, list]і два рази аргументує функцію fнеодноразово до результату (або першого елемента списку в першій ітерації), приймаючи наступний елемент списку як свій другий аргумент.

Ungolfed: #2 @ # &це анонімні функції, які застосовують свій другий аргумент до першого. Тому аргумент списку FoldListскладається з послідовних функцій, які слід застосувати до вводу.

FoldList[#2 @ # &,
  {#, (* note the absence of '&' here, 
         this '#' stands for the argument
         of the complete function and is 
         covered by the & at the end      *)
   Round[4 # / 3] &, (* anonymous function that rounds 4/3 of its input *)
   Round[2 # / 3] &, (* ditto, 2/3 *)
   # + 1 &           (* add one function *)
  }] &               (* and the '&' makes the entire 
                        thing an anonymous function,
                        whose argument is the '#' up
                        at the top.                  *)

Оскільки введення є цілим числом, а поділки - на 3, результат ніколи не буде, як 4.5, тому не потрібно турбуватися про правила округлення, коли остання цифра дорівнює 5: вона завжди буде чітко наближена до одного цілого чи іншого.

Діалог APL , 33 байти

(⌽,{1+⊃⍵})∘{⍵,⍨3÷⍨2×⊃⍵}(3÷⍨4∘×),⊢

Десмос, 37 байт

a=9
b=a+\frac{a}{3}
c=\frac{2}{3}b
d=c+1

Спробуйте в Інтернеті
Yay для нетрадиційних мов!

CJam, 21 байт

qi__3d/+mo_2d3/*i_)]`

Відгуки вітаються

Пояснення

• qi__ - Прочитайте вхід як ціле число і повторіть його двічі
• 3D/+mo - Розділіть один екземпляр введення на 3, а потім додайте його до другого примірника, щоб зробити y
• _2d3/*i - Скопіюйте y, потім помножте на .6
• _)] `- Dupe, приріст, загортання в масив, друк як масив (не в коді через оператора`::)

Редагувати: забули зробити перші три вдвічі, тому програму було порушено. Виправлено.

Аксіома, 59 байт

g(x)==round(x)::INT;f(x)==[x,a:=g(x+x/3.),b:=g(a*2./3),b+1]

тест

(3) -> [[i,f(i)] for i in [9,8,6,23,159]]
   (3)
   [[9,[9,12,8,9]], [8,[8,11,7,8]], [6,[6,8,5,6]], [23,[23,31,21,22]],
    [159,[159,212,141,142]]]
                                                      Type: List List Any

PHP, 60 байт

print_r([$a=$argn,$b=round($a+$a/3),$c=round($b*2/3),$c+1]);

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

PHP, 67 байт

function f($x){return [$x,$y=round($x*4/3),$z=round($y*2/3),$z+1];}