Introdução

Eu tropecei nesse padrão (inútil) outro dia enquanto estava assistindo TV. Eu o chamei de "o padrão 9" porque o primeiro número a usá-lo foi 9. A essência é que você digita um número (digamos x ) e depois volta:

• x
• x + ( x / 3) [vamos chamar isso de y ]
• dois terços de y [vamos chamar isso de z ]
• z + 1

Então, se eu colocar dentro desse padrão o número 9 como x , é isso que sairia:

• 9 ( 9 )
• 12 ( 9 + 9/3 ) [9 acima de 3 é 3 e 9 + 3 é 12]
• 8 ( 12 vezes dois terços) [um terço de 12 é 4 e 4 * 2 é 8]
• 9 ( 8 + 1 é 9)

Desafio

Escreva-me uma função (em qualquer linguagem de programação) que capte um número e produza uma matriz inteira usando o padrão.
Um pouco como este código 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;  
}

Esclarecimentos

Discussões têm despertado comentários sobre as especificações da questão. Esta seção pretende esclarecer alguns deles.

"melhor contar em bytes do que caracteres"

Escolhi personagens porque (pelo menos para mim) seria mais fácil julgar. Claro, não posso mudar isso agora. (muitas respostas já foram postadas)

"arredondamento"

O arredondamento segue esta rima:

Se for 5 ou mais, aumente a pontuação
Se for 4 ou menos, deixe descansar

Simplificando, se for algo como 4.7 ou 3.85, arredonde-os para 5 e 4, respectivamente.

Exemplos

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]

Se, no entanto, os números forem algo como 2.3 ou 10.435446, arredonde-os para 2 e 10, respectivamente.

"suporte de linguas"

Você é livre para não usar funções e / ou matrizes SE E SOMENTE SE O idioma de sua escolha não os suportar. Se isso acontecer (mesmo que isso aumente a contagem de caracteres), você deve usá-los .

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

o arredondamento é bastante caro: /

Experimente online

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

Bem, isso foi mais divertido do que o esperado, provavelmente não é o ideal, mas acho que estou chegando lá.

Tempo de explicação:

(para a versão de 352 bytes)

primeiro obtemos o argumento e o imprimimos:

;
:

simples o suficiente

passamos para a maior parte do programa: a entrada de divisão / 3

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

que é uma conversão ligeiramente modificada da divisão brainfuck

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

que levam para entrada

n 0 d 0 0 

e te devolver

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

uma vez que temos a divisão podemos usá-lo para obter a soma de n e n / d e imprimi-lo

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

então precisamos fazer outra divisão: (2 * (n + n / d)) / 3

então obtemos (2 * (n + n / d)

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

e colocá-lo com 3 de volta na divisão

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

nesse ponto, tudo explode, mario fica preso em um loop infinito, fazendo divisão em um número cada vez maior, para sempre.

e para consertar que precisamos de uma maneira de diferenciar entre a primeira e a segunda divisão, acaba que, oh alegria, temos uma maneira

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

basicamente, olhamos se o x em

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

é 0, se é que estamos na primeira divisão

caso contrário, estamos na segunda divisão e apenas imprimimos o resultado da divisão, adicione 1 e imprima novamente

e voilà fácil como torta.

Emotinomicon 99 bytes, 33 caracteres

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

Explicação:

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

Xot4*3/tE3/tQv

Experimente Online

Muito simples, vconcatena a pilha em uma matriz. Xoconverte em um tipo de dados inteiro e todas as operações subsequentes são operações inteiras.

Queijo Cheddar , 27 bytes

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

$0é variável com entrada. O Cheddar simplesmente não é um idioma de golfe ¯ \ _ (ツ) _ / ¯, também não é competitivo porque a funcionalidade de entrada do Cheddar foi criada após esse desafio.

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 caracteres

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

A letra dcolocada logo após um número inteiro torna o número inteiro 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};
    }
}

Sem a classe ( class c{}tem 8 caracteres), ela é reduzida para 76 caracteres:

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

Versão mais precisa em 110 caracteres (118 com o enum) - usa floats porque ninguém tem espaço para a transmissão 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

Como alguns usuários apontaram, essa solução (como outras em java) não arredonda os dados corretamente. Então agora estou apresentando uma solução um pouco mais longa que deve retornar o resultado correto

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

versão lamda de 60 ou 60 bytes

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

Versão Golfed

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

e ungolfed

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

ou 36 bytes definidos como lambda

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

Java, 64 bytes

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

Notas

• Isso tem o arredondamento necessário, não há certeza se você pode fazê-lo mais curto se misturado à solução do @ user902383.

Ungolfed

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

Saída com i = 9

[9, 12, 8, 9]

Zero, 33 bytes

Solicita entrada, conjuntos apara entrada arredondados, conjuntos be csuas respectivas alterações e, em seguida, diz todos os quatro números, separados por vírgulas.

Java 8 lambda, 109 81 79 75 caracteres

Porque ... você sabe ... até Java pode jogar golfe ...

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

Lambda ungolfed na classe:

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

Suponho que tenho permissão para usar longs, pois eles também são do tipo inteiro. Infelizmente, é necessário arredondar números inteiros corretamente e, portanto, uma conversão "curta" não funciona. Usando longs, não precisamos converter os resultados de arredondamento de volta para ints.

Atualizar

Usando o pequeno truque + 0.5 e lançando depois, mantemos o arredondamento correto e economizamos 2 caracteres!

Além disso, esse truque não requer mais o uso de long, portanto, podemos voltar para o corte de ints de mais 4 caracteres.

Mathematica - 21 bytes

Acabei de adquirir o Mathematica dos meus irmãos RPi, então tente por diversão, e que melhor maneira do que um desafio PPCG.

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

Define uma função anônima. Experimente como:

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

In[27]:= x[9]                                                                 

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

Python 3, 45 bytes

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

Veja este código em execução no ideone.com

Lua, 52 bytes

Este programa pega um número pelo argumento da linha de comando e retorna a matriz correspondente. Programas em lua são tecnicamente funções, pois o intérprete sempre os encapsulará em uma função. Este também é esse mecanismo usado quando você "chama" códigos em outros arquivos (basicamente usa loadfile/ dofile).

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

Na verdade, 21 bytes

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

Este programa declara uma função que executa as operações necessárias no valor da pilha superior.

Experimente online! (o Extra. no final avalia a função e imprime o resultado)

Explicação:

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

A equivalência de bytes do codegolf do Mathcad ainda não foi determinada. Tomando uma contagem de teclado como um equivalente aproximado, a solução tem aproximadamente 40 bytes.

05AB1E , 15 bytes

Código:

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

Usa a codificação CP-1252 . Experimente online! .

Pyke, 11 bytes

D}[}3/bD)[h

Experimente aqui!

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

Eu converti minha solução java para JavaScript e a reduzi um pouco.

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 caracteres

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

• Isso requer que o cabeçalho cmath funcione.

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 bytes

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

Para executar, salve como f.erl , compile e chame a função Ele retornará uma lista de 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>

Observe que o Erlang converte automaticamente int s em caracteres ASCII se você estiver no intervalo de valores ASCII, porque o Erlang não possui um tipo de caractere . Chamar a função com 100 fornece a melhor legibilidade [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 bytes

Resposta inspirada em @ fxk8y (não consegui postar um comentário na resposta dele)

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

Além disso, você pode ver os resultados com:

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

Pitão, 20 bytes

m.RdZ[Jc*4Q3Kc*2J3hK

Explicação:

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

Teste aqui

Jolf, 17 bytes

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

Define uma função Ώ. Ele recebe entrada implicitamente, portanto também funciona como um programa completo. Experimente aqui!

Mathematica, 51 bytes

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

Função anônima em conformidade com a versão atual (no momento da postagem) da postagem, que implica arredondamentos a cada etapa.

FoldListé uma operação típica em programação. Ele é chamado FoldList[f, list]e aplica a função de dois argumentos frepetidamente ao resultado (ou o primeiro elemento da lista na primeira iteração), tomando o próximo elemento da lista como seu segundo argumento.

Ungolfed: #2 @ # &é uma função anônima que aplica seu segundo argumento ao primeiro. Portanto, o argumento da lista FoldListconsiste nas funções sucessivas a serem aplicadas à entrada.

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

Como a entrada é um número inteiro e as divisões são 3, nunca haverá um resultado como 4,5; portanto, não há necessidade de se preocupar com regras de arredondamento quando o último dígito é um 5: sempre estará claramente mais próximo de um número inteiro ou outro.

Dyalog APL , 33 bytes

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

Desmos, 37 bytes

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

Experimente on-line
Yay para idiomas não convencionais!

CJam, 21 bytes

qi__3d/+mo_2d3/*i_)]`

Comentários são bem-vindos

Explicação

• qi__ - Leia a entrada como um número inteiro e duplique-a duas vezes
• 3D/+mo - Divida uma instância da entrada por 3 e adicione-a à segunda instância para criar y
• _2d3/*i - Duplique y e multiplique por 0,6
• _)] `- Dupe, incremente, envolva na matriz, imprima como matriz (não no código por causa do operador` :()

Edit: Esqueci de fazer os três primeiros um duplo, então o programa foi quebrado. Fixo.

Axioma, 59 bytes

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

teste

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

Experimente online!

PHP, 67 bytes

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