pengantar

Saya menemukan pola (tidak berguna) ini tempo hari ketika saya sedang menonton TV. Saya menamainya "pola 9" karena angka pertama yang menggunakannya adalah 9. Intinya adalah, Anda memasukkan nomor (katakanlah x ), dan kemudian Anda kembali:

• x
• x + ( x / 3) [sebut saja ini y ]
• dua pertiga dari y [sebut saja ini z ]
• z +1

Jadi, jika saya masukkan ke dalam pola ini angka 9 sebagai x , inilah yang akan keluar:

• 9 ( 9 )
• 12 ( 9 + 9/3 ) [9 lebih dari 3 adalah 3, dan 9 + 3 adalah 12]
• 8 ( 12 kali dua pertiga) [sepertiga dari 12 adalah 4, dan 4 * 2 adalah 8]
• 9 ( 8 + 1 adalah 9)

Tantangan

Tuliskan saya fungsi (dalam bahasa pemrograman apa pun) yang menggunakan angka, dan mengeluarkan array integer menggunakan pola.
Agak menyukai kode-psuedo ini:

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;  
}

Klarifikasi

Diskusi telah menimbulkan komentar mengenai spesifikasi pertanyaan. Bagian ini dimaksudkan untuk mengklarifikasi beberapa di antaranya.

"lebih baik untuk menghitung dalam byte daripada karakter"

Saya memilih karakter karena (bagi saya, setidaknya) akan lebih mudah untuk menilai. Tentu saja, saya tidak bisa mengubahnya sekarang. (banyak jawaban sudah diposting)

"pembulatan"

Pembulatan mengikuti sajak ini:

Jika 5 atau lebih, naikkan skor
Jika 4 atau kurang, biarkan saja

Sederhananya, jika itu adalah sekitar 4,7 atau 3,85, bulatkan masing-masing menjadi 5 dan 4.

Contohnya

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]

Namun, jika angkanya sekitar 2,3 atau 10,435446, bulatkan masing-masing menjadi 2 dan 10.

"dukungan bahasa"

Anda bebas untuk tidak menggunakan fungsi dan / atau array JIKA DAN HANYA JIKA bahasa pilihan Anda tidak mendukungnya. Jika ya (bahkan jika itu akan meningkatkan jumlah karakter Anda), Anda harus menggunakannya .

MarioLANG, 659 621 591 582 556 543 516 458 418 401 352 308 369 byte

pembulatan cukup mahal: /

Cobalah online

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

Yah ini lebih menyenangkan dari yang diharapkan, ini mungkin tidak optimal tapi saya rasa saya sudah sampai di sana.

Waktu penjelasan:

(untuk versi 352 byte)

pertama kita mendapatkan argumen dan mencetaknya:

;
:

cukup sederhana

kami kemudian pindah ke sebagian besar program: input divisi / 3

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

yang merupakan konversi yang sedikit dimodifikasi dari divisi brainfuck

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

yang mengambil input

n 0 d 0 0 

dan mengembalikanmu

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

setelah kami mendapat divisi kami menggunakannya untuk mendapatkan jumlah n dan n / d dan mencetaknya

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

kita kemudian perlu melakukan divisi lain: (2 * (n + n / d)) / 3

jadi kita dapatkan (2 * (n + n / d)

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

dan memasukkannya dengan 3 kembali ke divisi

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

pada saat itu semuanya terbuka, mario terjebak dalam loop tak terbatas melakukan pembagian pada jumlah yang lebih besar dan lebih besar, selamanya.

dan untuk memperbaikinya kita perlu cara untuk membedakan antara divisi pertama dan kedua, itu berakhir bahwa, oh sukacita, kita memang punya cara

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

pada dasarnya kita melihat apakah x in

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

adalah 0, jika itu berarti kita berada di divisi pertama

kalau tidak kita ada di divisi kedua, dan kita hanya mencetak hasil divisi itu, tambahkan 1 lalu cetak lagi

dan voila semudah pie.

Emotinomicon 99 byte, 33 karakter

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

Penjelasan:

😷                                 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 byte

Xot4*3/tE3/tQv

Cobalah secara Online

Cukup sederhana, vmenggabungkan tumpukan ke dalam array. Xomengkonversi ke tipe data integer, dan semua operasi sesudahnya adalah operasi integer.

Cheddar , 27 byte

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

$0variabel dengan input. Cheddar bukan bahasa golf ¯ \ _ (ツ) _ / ¯, juga ini tidak bersaing karena fungsi input Cheddar dibuat setelah tantangan ini.

Tidak Disatukan:

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
]

Java, 86 82 84 85 karakter

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

Huruf yang dditempatkan tepat setelah bilangan bulat membuat bilangan bulat a double.

Tidak Disatukan:

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

Tanpa kelas ( class c{}panjangnya 8 karakter), ukurannya menjadi 76 karakter:

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

Versi yang lebih akurat dalam 110 karakter (118 dengan enum) - ia menggunakan floats karena tidak ada yang punya ruang untuk casting 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)};}

Java, 56 80 Bytes

Seperti yang ditunjukkan beberapa pengguna, solusi ini (seperti yang lainnya di java) tidak membulatkan data dengan benar. Jadi sekarang saya menghadirkan solusi yang sedikit lebih lama yang harus mengembalikan hasil yang benar

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

atau versi 60 byte lamda

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

Versi golf

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

dan ungolfed

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

atau 36 byte didefinisikan sebagai lambda

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

Java, 64 byte

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

Catatan

• Ini memiliki building pembulatan yang diperlukan, tidak yakin apakah Anda bisa melakukannya lebih pendek jika dicampur dengan solusi @ user902383.

Tidak disatukan

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

Output dengan i = 9

[9, 12, 8, 9]

Gores, 33 byte

Minta input, set auntuk input bulat, set bdan cuntuk perubahan masing-masing, lalu ucapkan keempat angka, dipisahkan dengan koma.

Java 8 lambda, 109 81 79 75 karakter

Karena ... Anda tahu ... bahkan Jawa bisa bermain golf ...

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

Lambda tidak masuk kelas:

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};
    }
}

Saya berasumsi saya diizinkan menggunakan long karena mereka juga merupakan tipe integer. Sedihnya, seseorang perlu membulatkan bilangan bulat dengan benar dan dengan demikian pemeran "pendek" tidak berfungsi. Dengan menggunakan long, kita tidak perlu mengembalikan hasil pembulatan ke int.

Memperbarui

Menggunakan + 0,5 kecil yang bagus dan melakukan trik setelahnya, kami menjaga pembulatan yang benar dan menghemat 2 karakter!

Trik ini juga tidak memerlukan penggunaan yang lama lagi sehingga kita dapat kembali ke pencukuran 4 karakter lagi.

Mathematica - 21 byte

Baru saja mendapat Mathematica dari RPi saudara saya, jadi cobalah untuk bersenang-senang, dan cara apa yang lebih baik daripada tantangan PPCG.

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

Menentukan fungsi anonim. Cobalah seperti:

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

In[27]:= x[9]                                                                 

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

Python 3, 45 byte

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

Lihat kode ini berjalan di ideone.com

Lua, 52 Bytes

Program ini mengambil angka dengan argumen baris perintah dan mengembalikan array yang sesuai. Program dalam lua secara teknis berfungsi, karena penerjemah akan selalu merangkumnya dalam suatu fungsi. Ini juga mekanik ini yang digunakan ketika Anda "memanggil" kode dalam file lain (pada dasarnya menggunakan loadfile/ dofile).

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

Sebenarnya, 21 byte

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

Program ini mendeklarasikan fungsi yang melakukan operasi yang diperlukan pada nilai tumpukan teratas.

Cobalah online! (ekstra .di akhir mengevaluasi fungsi dan mencetak hasilnya)

Penjelasan:

`;;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] byte

Mathcad codegolf byte equivalance belum ditentukan. Mengambil hitungan keyboard sebagai setara kasar, solusinya adalah sekitar 40 byte.

05AB1E , 15 byte

Kode:

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

Menggunakan pengodean CP-1252 . Cobalah online! .

Pyke, 11 byte

D}[}3/bD)[h

Coba di sini!

            - 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 byte

Saya mengonversi solusi java saya ke JavaScript dan membukanya sedikit.

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 karakter

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;}

• Ini membutuhkan header cmath agar berfungsi.

Merosot

#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
}

Erlang, 80 byte

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

Untuk menjalankan, simpan sebagai f.erl , kompilasi dan panggil fungsi. Ini akan mengembalikan daftar int:

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>

Perhatikan bahwa Erlang secara otomatis mengkonversi int ke ASCII chars jika Anda berada dalam kisaran nilai ASCII karena Erlang tidak memiliki tipe char . Memanggil fungsi dengan 100 memberi Anda hasil yang lebih baik [100,133,88,89] .

Tidak Disatukan:

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

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

Erlang, 46 byte

Jawaban terinspirasi oleh @ fxk8y (Saya tidak dapat mengirim komentar ke jawabannya)

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

Anda juga dapat melihat hasilnya dengan:

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

Pyth, 20 byte

m.RdZ[Jc*4Q3Kc*2J3hK

Penjelasan:

            (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)

Tes di sini

Jolf, 17 byte

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

Menentukan fungsi Ώ. Dibutuhkan input secara implisit, sehingga juga berfungsi sebagai program lengkap. Coba di sini!

Mathematica, 51 byte

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

Fungsi anonim yang sesuai dengan versi posting saat ini (pada saat posting), yang menyiratkan pembulatan pada setiap langkah.

FoldListadalah operasi khas dalam pemrograman. Itu dipanggil sebagaiFoldList[f, list] dan menerapkan fungsi dua argumen fberulang kali untuk hasilnya (atau elemen pertama dari daftar di iterasi pertama), mengambil elemen berikutnya dari daftar sebagai argumen kedua.

Ungolfed: #2 @ # &adalah fungsi anonim yang menerapkan argumen kedua untuk yang pertama. Oleh karena itu, argumen daftar FoldListterdiri dari fungsi berturut-turut untuk diterapkan pada input.

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.                  *)

Karena input bilangan bulat dan pembagiannya adalah 3, maka tidak akan pernah ada hasil seperti 4,5, oleh karena itu tidak perlu khawatir tentang aturan pembulatan ketika angka terakhir adalah 5: itu akan selalu jelas lebih dekat ke satu bilangan bulat, atau yang lain.

Dyalog APL , 33 byte

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

Desmos, 37 byte

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

Cobalah secara online
Yay untuk bahasa yang tidak konvensional!

CJam, 21 byte

qi__3d/+mo_2d3/*i_)]`

Umpan balik diterima

Penjelasan

• qi__ - Baca input sebagai integer dan duplikat dua kali
• 3D/+mo - Bagi satu instance dari input dengan 3, lalu tambahkan ke instance kedua untuk membuat y
• _2d3/*i - Gandakan y, lalu kalikan dengan .6
• _)] `- Dupe, increment, wrap in array, cetak sebagai array (bukan kode karena` operator :()

Sunting: Lupa membuat tiga ganda pertama, sehingga program rusak. Tetap.

Aksioma, 59 byte

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

uji

(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 Bytes

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

Cobalah online!

PHP, 67 byte

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