Introducción

Me encontré con este patrón (inútil) el otro día mientras veía la televisión. Lo llamé "el patrón 9" porque el primer número que lo usó fue 9. La esencia de esto es que ingresas un número (digamos x ) y luego regresas:

• X
• x + ( x / 3) [llamemos a esto y ]
• dos tercios de y [llamemos a esto z ]
• z + 1

Entonces, si pongo dentro de este patrón el número 9 como x , esto es lo que saldría:

• 9 ( 9 )
• 12 ( 9 + 9/3 ) [9 sobre 3 es 3, y 9 + 3 es 12]
• 8 ( 12 veces dos tercios) [un tercio de 12 es 4 y 4 * 2 es 8]
• 9 ( 8 + 1 es 9)

Desafío

Escríbeme una función (en cualquier lenguaje de programación) que tome un número y genere una matriz entera usando el patrón.
Algo así 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;  
}

Aclaraciones

Las discusiones han suscitado comentarios sobre las especificaciones de la pregunta. Esta sección está destinada a aclarar algunos de esos.

"mejor contar en bytes que en caracteres"

Elegí personajes porque (para mí, al menos) sería más fácil de juzgar. Por supuesto, no puedo cambiar eso ahora. (muchas respuestas ya están publicadas)

"redondeo"

El redondeo sigue esta rima:

Si es 5 o más, aumente la puntuación.
Si es 4 o menos, déjelo descansar.

En pocas palabras, si es algo así como 4.7 o 3.85, redondee a 5 y 4 respectivamente.

Ejemplos

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]

Sin embargo, si los números son algo así como 2.3 o 10.435446, redondea a 2 y 10 respectivamente.

"ayuda de idioma"

Usted es libre de no usar funciones y / o matrices SI Y SOLO SI el idioma de su elección no los admite. Si lo hace (incluso si aumentará el recuento de tus personajes), debes usarlos .

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

el redondeo es bastante costoso: /

Pruébalo en línea

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

Bueno, esto fue más divertido de lo esperado, probablemente no sea óptimo, pero supongo que voy a llegar allí.

Tiempo de explicación:

(para la versión de 352 bytes)

primero obtenemos el argumento y lo imprimimos:

;
:

Suficientemente simple

luego pasamos a la mayor parte del programa: la entrada de división / 3

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

que es una conversión ligeramente modificada de la división brainfuck

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

que toman como entrada

n 0 d 0 0 

y devolverte

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

una vez que tenemos la división, la usamos para obtener la suma de n y n / d e imprimirla

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

entonces necesitamos hacer otra división: (2 * (n + n / d)) / 3

entonces obtenemos (2 * (n + n / d)

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

y ponerlo con 3 nuevamente en la división

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

en ese punto todo explotó, Mario está atrapado en un bucle infinito haciendo división en números cada vez más grandes, para siempre.

y para arreglar que necesitamos una manera de diferenciar entre la primera y la segunda división, termina siendo que, oh alegría, tenemos una manera

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

básicamente miramos si la x en

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

es 0, si es significa que estamos en la primera división

de lo contrario, estamos en la segunda división, y solo imprimimos el resultado de la división, agregamos 1 y luego lo imprimimos nuevamente

y voilà fácil como pastel.

Emotinomicon 99 bytes, 33 caracteres

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

Explicación:

😷                                 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

Pruébalo en línea

Bastante simple, vconcatena la pila en una matriz. Xose convierte a un tipo de datos entero, y todas las operaciones posteriores son operaciones enteras.

Cheddar , 27 bytes

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

$0es variable con entrada. Cheddar simplemente no es un lenguaje de golf ¯ \ _ (ツ) _ / ¯, también esto no es competitivo porque la funcionalidad de entrada de Cheddar se realizó después de este desafío.

Sin golf:

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

La letra dcolocada justo después de un entero hace que el entero a double.

Sin golf:

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

Sin la clase ( class c{}tiene 8 caracteres de longitud), se reduce a 76 caracteres:

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

Versión más precisa en 110 caracteres (118 con la enumeración): utiliza floats porque nadie tiene espacio para emitir 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 algunos usuarios señalaron, esta solución (como algunas otras en Java) no redondea los datos correctamente. Así que ahora estoy presentando una solución un poco más larga que debería devolver el resultado correcto

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

o versión de lamda de 60 bytes

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

Versión de golf

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

y sin golf

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

o 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

• Esto tiene la construcción de redondeo requerida, no estoy seguro si puede hacerlo más corto si se combina con la solución @ user902383.

Sin golf

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

Salida con i = 9

[9, 12, 8, 9]

Scratch, 33 bytes

Pide entrada, conjuntos aa entrada redondeados, conjuntos by csus respectivos cambios, luego dice los cuatro números, separados por comas.

Java 8 lambda, 109 81 79 75 caracteres

Porque ... ya sabes ... incluso Java puede jugar al golf ...

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

Lambda sin golfista en clase:

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

Supongo que se me permite usar longs, ya que también son de tipo entero. Lamentablemente, uno necesita redondear correctamente los enteros y, por lo tanto, un lanzamiento "corto" no funciona. Al usar longs, no necesitamos devolver los resultados de redondeo a ints.

Actualizar

¡Usando el pequeño truco + 0.5 y luego lanzando el truco, mantenemos el redondeo correcto y ahorramos 2 caracteres!

Además, este truco ya no requiere el uso de mucho tiempo, por lo que podemos volver a afeitarnos con 4 caracteres más.

Mathematica - 21 bytes

Acabo de recibir Mathematica de mis hermanos RPi, así que probarlo por diversión y qué mejor manera que un desafío PPCG.

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

Define una función anónima. Pruébalo 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])

Vea este código ejecutándose en ideone.com

Lua, 52 bytes

Este programa toma un número por argumento de línea de comando y devuelve la matriz correspondiente. Los programas en lua son técnicamente funciones, ya que el intérprete siempre los encapsulará en una función. Esta es también esta mecánica que se utiliza cuando "llama" a códigos en otros archivos (básicamente usa loadfile/ dofile).

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

En realidad, 21 bytes

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

Este programa declara una función que realiza las operaciones requeridas en el valor de la pila superior.

Pruébalo en línea! (el extra. al final evalúa la función e imprime el resultado)

Explicación:

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

Mathcad codegolf byte equivalance aún no se ha determinado. Tomando un recuento de teclado como un equivalente aproximado, la solución es de aproximadamente 40 bytes.

05AB1E , 15 bytes

Código:

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

Utiliza la codificación CP-1252 . Pruébalo en línea! .

Pyke, 11 bytes

D}[}3/bD)[h

Pruébalo aquí!

            - 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

Convierto mi solución java a JavaScript y la hojeé un poco.

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

• Esto requiere que el encabezado 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 ejecutar, guarde como f.erl , compile y llame a la función. Devolverá una lista de entradas:

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>

Tenga en cuenta que Erlang convierte automáticamente int s en caracteres ASCII si está en el rango de valores ASCII porque Erlang no tiene un tipo char . Llamar a la función con 100 le da la mejor lectura [100,133,88,89] .

Sin golf:

-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

Respuesta inspirada por @ fxk8y (no pude publicar un comentario a su respuesta)

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

También puedes ver los resultados con:

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

Pyth, 20 bytes

m.RdZ[Jc*4Q3Kc*2J3hK

Explicación:

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

Prueba aquí

Jolf, 17 bytes

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

Define una función Ώ. Toma entrada implícitamente, por lo que también funciona como un programa completo. Pruébalo aquí!

Mathematica, 51 bytes

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

Función anónima que se ajusta a la versión actual (en el momento de la publicación) de la publicación, lo que implica redondear en cada paso.

FoldListEs una operación típica en la programación. Se invoca como FoldList[f, list]y aplica la función de dos argumentos frepetidamente al resultado (o al primer elemento de la lista en la primera iteración), tomando el siguiente elemento de la lista como su segundo argumento.

Ungolfed: #2 @ # &es una función anónima que aplica su segundo argumento al primero. Por lo tanto, el argumento de lista FoldListconsiste en las funciones sucesivas que se aplicarán a la 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.                  *)

Debido a que la entrada es entera y las divisiones son 3, nunca habrá un resultado como 4.5, por lo tanto, no hay necesidad de preocuparse por las reglas de redondeo cuando el último dígito es un 5: siempre estará claramente más cerca de un entero u otro.

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

Pruébelo en línea ¡
Yay para idiomas no convencionales!

CJam, 21 bytes

qi__3d/+mo_2d3/*i_)]`

Comentarios son bienvenidos

Explicación

• qi__ - Lea la entrada como un entero y duplíquelo dos veces
• 3D/+mo - Divida una instancia de la entrada por 3, luego agréguela a la segunda instancia para hacer y
• _2d3/*i - Duplica y, luego multiplícalo por .6
• _)] `- Duplica, incrementa, ajusta en matriz, imprime como matriz (no en código debido al operador` :()

Editar: Olvidé hacer los primeros tres un doble, por lo que el programa se interrumpió. Fijo.

Axioma, 59 bytes

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

prueba

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

Pruébalo en línea!

PHP, 67 bytes

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