소개

내가 TV를 보면서 다른 날이 쓸모없는 패턴을 우연히 발견했습니다. 사용하는 첫 번째 숫자는 9이기 때문에 "9 패턴"이라고 명명했습니다. 그 요점은 숫자를 입력하고 ( x 라고합시다 ) 다시 돌아옵니다.

• 엑스
• x + ( x / 3) [이것을 y 라고합시다 ]
• 2/3 Y [하자이 통화 Z를 ]
• z + 1

따라서이 패턴 안에 숫자 9 를 x 로 넣으면 이것이 나옵니다.

• 9 ( 9 )
• 12 ( 9 + 9 / 3) [3 이상 9는 3, 9 + 3은 12]
• 8 ( 12 x 2/3) [12의 3 분의 1은 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
:"==#======================"======
)   -[!)>>[![        [<((((!   
)   )"#="==#=========="====#
+(  +>) )  +>(+)[!)+))!
+(  )-+ )  -"====#====#
+   >!>)!  >! -  <
    "#"=#  "#===="
 !
=#

이것은 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을 더한 다음 다시 인쇄합니다.

그리고 짜잔 파이로 쉽게.

이모 노미 콘 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)는 골프 언어가 아닌 ¯ \ _ (ツ) _ / ¯이기도합니다. 또한 체다의 입력 기능은이 도전 이후에 만들어 졌기 때문에 경쟁이 아닙니다.

언 골프 드 :

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

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 개)- float캐스팅 할 공간이 없기 때문에 s를 사용합니다 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;}

그리고 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}

자바, 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, 각각의 변경 사항을 적용한 다음 쉼표로 구분 된 4 개의 숫자를 말합니다.

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

정수 유형이므로 long을 사용할 수 있다고 가정합니다. 슬프게도 정수를 올바르게 반올림해야하므로 "짧은"캐스트가 작동하지 않습니다. long을 사용하면 반올림 결과를 int로 다시 캐스팅 할 필요가 없습니다.

최신 정보

좋은 작은 + 0.5를 사용하고 나중에 마술을 사용하면 올바른 반올림을 유지하고 2 문자를 절약 할 수 있습니다!

또한이 트릭은 더 이상 long을 사용할 필요가 없으므로 4 문자를 더 면도 한 정수로 다시 전환 할 수 있습니다.

Mathematica-21 바이트

내 형제 RPi에서 Mathematica를 얻었으므로 재미로 시험 해보고 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}

파이썬 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 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

자바 스크립트, 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의 작업에 헤더를.

탈고

#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에는 문자 유형 이 없기 때문에 ASCII 값 범위에 있으면 Erlang은 자동으로 int 를 ASCII 문자 로 변환 합니다. 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)

여기서 테스트

Jolf, 17 바이트

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

함수를 정의합니다 Ώ. 암시 적으로 입력이 필요하므로 전체 프로그램으로도 두 배가됩니다. 여기 사용해보십시오!

수학, 51 바이트

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

현재 (게시 시점) 버전의 게시물을 따르는 익명 함수로, 모든 단계에서 반올림을 의미합니다.

FoldListA는 일반적인 작업 프로그래밍은. 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와 같은 결과는 결코 없으므로 마지막 숫자가 a 일 때 반올림 규칙에 대해 걱정할 필요가 없습니다. 5 . 항상 한 정수 또는 다른 정수에 더 가깝습니다.

Dyalog 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를 복제 한 다음 0.6을 곱하십시오.
• _)]`-Dupe, Increment, Wrapping in array, array로 인쇄 (`연산자 때문에 코드가 아님 :()

편집 : 처음 3을 더블로 만드는 것을 잊었으므로 프로그램이 중단되었습니다. 결정된.

공리, 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];}