Giới thiệu

Tôi tình cờ thấy mô hình (vô dụng) này vào một ngày khác khi tôi đang xem TV. Tôi đặt tên cho nó là "mẫu 9" bởi vì số đầu tiên sử dụng nó là 9. Ý chính của nó là, bạn nhập một số (giả sử x ), và sau đó bạn quay lại:

• x
• x + ( x / 3) [hãy gọi đây là y ]
• hai phần ba của y [hãy gọi đây là z ]
• z + 1

Vì vậy, nếu tôi đặt bên trong mẫu này số 9 là x , thì đây là thứ sẽ xuất hiện:

• 9 ( 9 )
• 12 ( 9 + 9/3 ) [9 trên 3 là 3 và 9 + 3 là 12]
• 8 ( 12 lần hai phần ba) [một phần ba của 12 là 4 và 4 * 2 là 8]
• 9 ( 8 + 1 là 9)

Thử thách

Viết cho tôi một hàm (trong bất kỳ ngôn ngữ lập trình nào) lấy một số và xuất ra một mảng số nguyên bằng cách sử dụng mẫu.
Hơi giống mã psuedo này:

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

Làm rõ

Các cuộc thảo luận đã được khơi dậy trong các ý kiến ​​liên quan đến các thông số kỹ thuật của câu hỏi. Phần này có nghĩa là để làm rõ một số trong những người.

"tốt hơn để tính bằng byte hơn ký tự"

Tôi chọn nhân vật bởi vì (đối với tôi, ít nhất) sẽ dễ phán đoán hơn. Tất nhiên, tôi không thể thay đổi điều đó ngay bây giờ. (rất nhiều câu trả lời đã được đăng)

"làm tròn"

Làm tròn theo vần này:

Nếu là 5 hoặc nhiều hơn, hãy nâng điểm
Nếu là 4 hoặc ít hơn, hãy để nó nghỉ ngơi

Đơn giản, đặt, nếu nó là một cái gì đó như 4,7 hoặc 3,85, làm tròn chúng thành 5 và 4 tương ứng.

Ví dụ

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]

Tuy nhiên, nếu các số có dạng như 2,3 hoặc 10,435446, làm tròn chúng thành 2 và 10 tương ứng.

"hỗ trợ ngôn ngữ"

Bạn được tự do không sử dụng các hàm và / hoặc mảng NẾU VÀ CHỈ NẾU ngôn ngữ bạn chọn không hỗ trợ chúng. Nếu có (ngay cả khi nó sẽ tăng số lượng ký tự của bạn), bạn phải sử dụng chúng .

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

làm tròn khá tốn kém: /

Dùng thử trực tuyến

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

Chà, điều này vui hơn cả mong đợi, điều này có lẽ không tối ưu nhưng tôi đoán tôi đang đến đó.

Thời gian giải thích:

(đối với phiên bản 352 byte)

đầu tiên chúng ta nhận được đối số và in nó:

;
:

đủ đơn giản

sau đó chúng tôi chuyển sang phần lớn của chương trình: đầu vào phân chia / 3

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

đó là một chuyển đổi được sửa đổi một chút của bộ phận brainfuck

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

mà mất cho đầu vào

n 0 d 0 0 

và trả lại cho bạn

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

một khi chúng ta có được phép chia, chúng ta sử dụng nó để lấy tổng n và n / d và in nó

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

sau đó chúng ta cần thực hiện một phép chia khác: (2 * (n + n / d)) / 3

vì vậy chúng tôi nhận được (2 * (n + n / d)

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

và đặt nó với 3 trở lại vào bộ phận

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

tại thời điểm đó mọi thứ được tiết lộ, mario bị mắc kẹt trong một vòng lặp vô hạn thực hiện phân chia trên số lượng lớn hơn và lớn hơn, mãi mãi.

và để khắc phục rằng chúng ta cần một cách để phân biệt giữa phân chia thứ nhất và phân chia thứ hai, cuối cùng, đó là niềm vui, chúng ta có một cách

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

về cơ bản chúng ta nhìn nếu x trong

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

là 0, nếu nó có nghĩa là chúng ta đang ở phân chia đầu tiên

khác chúng tôi ở phân chia thứ hai, và chúng tôi chỉ in kết quả của phân chia, thêm 1 sau đó in lại

và voilà dễ như bánh.

Emotinomicon 99 byte, 33 ký tự

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

Giải trình:

😷                                 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

Dùng thử trực tuyến

Khá đơn giản, vghép các ngăn xếp thành một mảng. Xochuyển đổi thành một kiểu dữ liệu số nguyên và tất cả các hoạt động sau đó là các hoạt động số nguyên.

Cheddar , 27 byte

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

$0là biến với đầu vào. Cheddar không phải là một ngôn ngữ golf \ _ () _ / ¯, đây cũng là một ngôn ngữ không cạnh tranh vì chức năng nhập liệu của Cheddar đã được thực hiện sau thử thách này.

Ung dung:

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 ký tự

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

Chữ dđược đặt ngay sau một số nguyên làm cho số nguyên a double.

Ung dung:

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

Không có lớp ( class c{}dài 8 ký tự), nó giảm xuống còn 76 ký tự:

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

Phiên bản chính xác hơn trong 110 ký tự (118 với enum) - nó sử dụng floats vì không ai có không gian để truyền 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 byte

Như một số người dùng đã chỉ ra, giải pháp này (như một số người khác trong java) không làm tròn dữ liệu đúng cách. Vì vậy, bây giờ tôi đang trình bày giải pháp dài hơn một chút sẽ trả về kết quả chính xác

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

hoặc phiên bản 60 byte lamda

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

Phiên bản chơi gôn

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

và vô lương tâm

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

hoặc 36 byte được định nghĩa là 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};}

Ghi chú

• Điều này có xây dựng làm tròn yêu cầu, không chắc bạn có thể làm ngắn hơn nếu trộn với giải pháp của @ user902383.

Ung dung

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

Đầu ra với i = 9

[9, 12, 8, 9]

Cào, 33 byte

Yêu cầu đầu vào, đặt athành đầu vào làm tròn, đặt bvà cthay đổi tương ứng, sau đó nói tất cả bốn số, được phân tách bằng dấu phẩy.

Java 8 lambda, 109 81 79 75 ký tự

Bởi vì ... bạn biết ... ngay cả Java cũng có thể bị đánh gôn ...

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

Lambda vô dụng vào lớp:

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

Tôi giả sử tôi được phép sử dụng lâu dài vì chúng cũng là một kiểu số nguyên. Đáng buồn thay, người ta cần làm tròn số nguyên một cách chính xác và do đó, một diễn viên "ngắn" không hoạt động. Bằng cách sử dụng lâu dài, chúng ta không cần phải đưa kết quả làm tròn trở lại số nguyên.

Cập nhật

Sử dụng mẹo nhỏ + 0,5 và đúc sau đó, chúng tôi giữ tròn đúng và lưu 2 ký tự!

Ngoài ra thủ thuật này không yêu cầu sử dụng lâu hơn nữa vì vậy chúng tôi có thể chuyển trở lại để cạo thêm 4 ký tự.

Toán học - 21 byte

Chỉ cần có Mathicala từ anh em RPi của tôi, vì vậy hãy thử nó cho vui, và cách nào tốt hơn là một thử thách PPCG.

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

Xác định một hàm ẩn danh. Hãy thử nó như:

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

Xem mã này đang chạy trên ideone.com

Lua, 52 byte

Chương trình này lấy một số theo đối số dòng lệnh và trả về mảng tương ứng. Các chương trình trong lua là các chức năng kỹ thuật, vì trình thông dịch sẽ luôn gói chúng trong một chức năng. Đây cũng là cơ chế này được sử dụng khi bạn "gọi" mã trong các tệp khác (về cơ bản nó sử dụng loadfile/ dofile).

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

Trên thực tế, 21 byte

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

Chương trình này khai báo một hàm thực hiện các hoạt động cần thiết trên giá trị ngăn xếp trên cùng.

Hãy thử trực tuyến! (phần bổ sung .ở cuối đánh giá chức năng và in kết quả)

Giải trình:

`;;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 tương đương byte codegolf vẫn chưa được xác định. Lấy số lượng bàn phím là tương đương thô, giải pháp xấp xỉ 40 byte.

05AB1E , 15 byte

Mã số:

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

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! .

Pyke, 11 byte

D}[}3/bD)[h

Hãy thử nó ở đây!

            - 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

Tôi chuyển đổi giải pháp java của mình sang JavaScript và đọc lướt nó xuống một chút.

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 ký tự

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

• Điều này đòi hỏi tiêu đề cmath để làm việc.

Bị khử

#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].

Để chạy, lưu dưới dạng f.erl , biên dịch và gọi hàm. Nó sẽ trả về một danh sách các số nguyên:

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>

Lưu ý rằng Erlang tự động chuyển đổi ký tự int thành ký tự ASCII nếu bạn ở trong phạm vi giá trị ASCII vì Erlang không có loại char . Gọi hàm bằng 100 cho bạn dễ đọc hơn [100,133,88,89] .

Ung dung:

-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

Câu trả lời lấy cảm hứng từ @ fxk8y (Tôi không thể đăng bình luận cho câu trả lời của anh ấy)

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

Ngoài ra, bạn có thể xem kết quả với:

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

Bình thường, 20 byte

m.RdZ[Jc*4Q3Kc*2J3hK

Giải trình:

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

Kiểm tra tại đây

Jolf, 17 byte

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

Xác định một hàm Ώ. Nó nhận đầu vào ngầm, vì vậy nó cũng tăng gấp đôi như một chương trình đầy đủ. Hãy thử nó ở đây!

Toán học, 51 byte

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

Chức năng ẩn danh phù hợp với phiên bản hiện tại (tại thời điểm đăng) của bài đăng, ngụ ý làm tròn ở mỗi bước.

FoldListlà một hoạt động điển hình trong lập trình. Nó được gọi như FoldList[f, list]và áp dụng hàm hai đối sốf nhiều lần cho kết quả (hoặc phần tử đầu tiên của danh sách trong lần lặp đầu tiên), lấy phần tử tiếp theo của danh sách làm đối số thứ hai.

Ungolfed: #2 @ # &là một hàm ẩn danh áp dụng đối số thứ hai của nó cho đối số thứ nhất. Do đó, đối số danh sách FoldListbao gồm các hàm liên tiếp được áp dụng cho đầu vào.

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

Bởi vì đầu vào là số nguyên và các phân chia là 3, nên sẽ không bao giờ có kết quả như 4,5, do đó, không cần phải lo lắng về quy tắc làm tròn khi chữ số cuối cùng là 5: nó sẽ luôn luôn gần hơn với một số nguyên hoặc khác.

APL Dyalog , 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

Hãy thử trực tuyến
Yay cho các ngôn ngữ độc đáo!

CJam, 21 byte

qi__3d/+mo_2d3/*i_)]`

Phản hồi được chào đón

Giải trình

• qi__ - Đọc đầu vào dưới dạng số nguyên và nhân đôi hai lần
• 3D/+mo - Chia một thể hiện của đầu vào cho 3, sau đó thêm nó vào thể hiện thứ hai để tạo y
• _2d3/*i - Nhân đôi y, sau đó nhân nó với .6
• _)] `- Dupe, tăng, bọc trong mảng, in dưới dạng mảng (không phải trong mã vì toán tử` :()

Chỉnh sửa: Quên làm cho ba người đầu tiên tăng gấp đôi, vì vậy chương trình đã bị hỏng. Đã sửa.

Tiên đề, 59 byte

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

kiểm tra

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

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

Hãy thử trực tuyến!

PHP, 67 byte

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