บทนำ

ฉันสะดุดรูปแบบนี้ (ไร้ประโยชน์) เมื่อวันก่อนขณะดูทีวี ฉันตั้งชื่อมันว่า "รูปแบบ 9" เพราะหมายเลขแรกที่ใช้คือ 9 ส่วนสำคัญของมันคือคุณป้อนตัวเลข (สมมุติว่าx ) แล้วคุณจะได้รับกลับมา:

• x
• x + ( x / 3) [ลองเรียกนี่ว่าy ]
• สองในสามของy [เรียกมันว่าz ]
• z + 1

ดังนั้นถ้าผมใส่ในรูปแบบนี้จำนวน9เป็นxนี้เป็นสิ่งที่จะออกมา:

• 9 ( 9 )
• 12 ( 9 + 9/3 ) [9 ส่วน 3 คือ 3 และ 9 + 3 คือ 12]
• 8 ( 12ครั้งสองในสาม) [หนึ่งในสามของ 12 คือ 4 และ 4 * 2 คือ 8]
• 9 ( 8 + 1 คือ 9)

ท้าทาย

เขียนฟังก์ชั่น (ในภาษาการเขียนโปรแกรมใด ๆ ) ที่ใช้เป็นตัวเลขและส่งออกอาร์เรย์จำนวนเต็มโดยใช้รูปแบบ
ค่อนข้างเหมือนรหัส psuedo นี้:

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
:"==#======================"======
)   -[!)>>[![        [<((((!   
)   )"#="==#=========="====#
+(  +>) )  +>(+)[!)+))!
+(  )-+ )  -"====#====#
+   >!>)!  >! -  <
    "#"=#  "#===="
 !
=#

ซึ่งเป็นการเปลี่ยนแปลงเล็กน้อยของการแบ่ง brainfuck

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

ซึ่งใช้สำหรับการป้อนข้อมูล

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 ใน

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

เป็น 0 ถ้ามันหมายความว่าเราอยู่ในส่วนแรก

มิฉะนั้นเราจะอยู่ในส่วนที่สองและเราเพิ่งพิมพ์ผลลัพธ์ของการหารเพิ่ม 1 จากนั้นพิมพ์อีกครั้ง

และvoilàง่ายเหมือนพาย

อิโมติโนมิก 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แปลงเป็นชนิดข้อมูลจำนวนเต็มและการดำเนินการทั้งหมดหลังจากนั้นเป็นการดำเนินการจำนวนเต็ม

Cheddar , 27 ไบต์

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

$0เป็นตัวแปรที่มีอินพุต Cheddar ไม่ใช่แค่ภาษากอล์ฟ¯ \ _ (ツ) _ / ¯ แต่นี่ไม่ใช่การแข่งขันเพราะฟังก์ชั่นการป้อนข้อมูลของ Cheddar เกิดขึ้นหลังจากความท้าทายนี้

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
]

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

ตัวอักษรวางขวาหลังจากจำนวนเต็มทำให้จำนวนเต็มที่ddouble

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 พร้อม enum) - มันใช้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)};}

Java, 56 80 Bytes

ตามที่ผู้ใช้บางคนชี้ให้เห็นวิธีแก้ปัญหานี้ (ในขณะที่บางคนในจาวา) ไม่รอบข้อมูลอย่างถูกต้อง ดังนั้นตอนนี้ฉันกำลังนำเสนอทางออกที่ยาวขึ้นเล็กน้อยซึ่งควรให้ผลลัพธ์ที่ถูกต้อง

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

หรือรุ่น 60 bytes lamda

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

รุ่น Golfed

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

และ ungolfed

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 lambda, 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 ตัว

นอกจากนี้เคล็ดลับนี้ไม่ต้องการการใช้งานที่ยาวนานอีกต่อไปดังนั้นเราสามารถเปลี่ยนกลับไปเป็น ints ที่โกนหนวดได้อีก 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

Lua 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] ไบต์

การคำนวณความเท่าเทียมกันของไบต์คาเด็คทางคณิตศาสตร์ การนับแป้นพิมพ์จะเทียบเท่าคร่าวๆวิธีแก้ปัญหาคือประมาณ 40 ไบต์

05AB1E , 15 ไบต์

รหัส:

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

ใช้การเข้ารหัสCP-1252 ลองออนไลน์! .

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

Erlang, 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 chars โดยอัตโนมัติหากคุณอยู่ในช่วงค่า ASCII เนื่องจาก Erlang ไม่มีชนิดอักขระถ่าน ฟังก์ชั่นการโทรด้วย 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].

Erlang, 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)

ทดสอบที่นี่

Jolf, 17 ไบต์

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

Ώกำหนดฟังก์ชั่น ใช้อินพุตโดยปริยายดังนั้นจึงเป็นสองเท่าของโปรแกรมเต็มรูปแบบ ลองที่นี่!

Mathematica, 51 ไบต์

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

ฟังก์ชั่นไม่ระบุชื่อที่สอดคล้องกับรุ่นโพสต์ปัจจุบัน (ณ เวลาที่ทำการโพสต์) ซึ่งหมายถึงการปัดเศษในทุกขั้นตอน

FoldListเป็นการดำเนินงานทั่วไปในการเขียนโปรแกรม มันถูกเรียกใช้เป็นFoldList[f, list]และใช้ฟังก์ชันสองอาร์กิวเมนต์fซ้ำ ๆ กับผลลัพธ์ (หรือองค์ประกอบแรกของรายการในการคำนวณซ้ำครั้งแรก) โดยใช้องค์ประกอบถัดไปของรายการเป็นอาร์กิวเมนต์ที่สอง

Ungolfed: #2 @ # &เป็นฟังก์ชั่นนิรนามที่ใช้อาร์กิวเมนต์ที่สองกับอันแรก ดังนั้นอาร์กิวเมนต์ list ของ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 ดังนั้นจึงไม่จำเป็นต้องกังวลเกี่ยวกับกฎการปัดเศษเมื่อตัวเลขสุดท้ายคือ a 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

ลอง
ยาออนไลน์สำหรับภาษาที่ไม่เป็นทางการ!

CJam, 21 ไบต์

qi__3d/+mo_2d3/*i_)]`

ข้อเสนอแนะยินดีต้อนรับ

คำอธิบาย

• qi__ - อ่านอินพุตเป็นจำนวนเต็มและทำซ้ำสองครั้ง
• 3D/+mo - แบ่งอินสแตนซ์หนึ่งของอินพุทด้วย 3 จากนั้นเพิ่มอินสแตนซ์ที่สองเพื่อสร้าง y
• _2d3/*i - ทำซ้ำ y แล้วคูณด้วย 0.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];}