Введение

Я наткнулся на эту (бесполезную) схему на днях, когда смотрел телевизор. Я назвал его «паттерном 9», потому что первое число, которое использовало его, было 9. Суть его в том, что вы вводите число (скажем, х ), а затем вы возвращаетесь:

• Икс
• х + ( х / 3) [назовем это у ]
• две трети у [назовем это г ]
• 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 

как только мы получили деление, мы используем его, чтобы получить сумму п и н / д и распечатать его

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

тогда нам нужно сделать еще одно деление: (2 * (n + n / d)) / 3

таким образом, мы получаем (2 * (н + н / д)

;>>[![              [( [( [<    !+(((-<
:"==#======================"===)#====="
)   -[!)>>[![        [<((((!    >))) [!(((
)   )"#="==#=========="====#   ="=====#==:
+(  +>) )  +>(+)[!)+))! 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переменная с вводом. Чеддер просто не является языком игры в гольф ¯ \ _ (ツ) _ / ¯, и это не является конкуренцией, потому что входная функциональность Чеддера была сделана после этого испытания.

Ungolfed:

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.

Ungolfed:

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 байтов версия lamda

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.

Ungolfed

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 символов

Потому что ... ты знаешь ... даже на Яве можно играть в гольф ...

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, нам не нужно приводить результаты округления к целым.

Обновить

Используя симпатичный маленький +0,5 и трюк после чтения, мы сохраняем правильное округление и сохраняем 2 символа!

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

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 байта

Эта программа принимает число аргументом командной строки и возвращает соответствующий массив. Программы на языке lua технически являются функциями, поскольку интерпретатор всегда заключает их в функцию. Это также тот механизм, который используется, когда вы «вызываете» коды в других файлах (в основном он использует 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 codegolf еще не определена. Принимая подсчет клавиатуры в качестве грубого эквивалента, решение составляет около 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 , скомпилируйте и вызовите функцию. Он вернет список целых:

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 в символы ASCII, если вы находитесь в диапазоне значений ASCII, потому что Erlang не имеет тип char . Вызов функции с 100 дает вам лучшую читаемость [100,133,88,89] .

Ungolfed:

-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Β’

Определяет функцию Ώ. Он принимает ввод неявно, поэтому он также удваивается как полная программа. Попробуй это здесь!

Mathematica, 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: она всегда будет явно ближе к одному целому числу или другому.

Dyalog APL , 33 байта

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

Desmos, 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 - Дублируйте у, затем умножьте его на 0,6
• _)] `- дублирование, приращение, перенос в массив, печать в виде массива (не в коде из-за оператора` :()

Изменить: Забыл сделать первые три двойной, поэтому программа была сломана. Исправлена.

Аксиома, 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];}