introduzione

Mi sono imbattuto in questo schema (inutile) l'altro giorno mentre guardavo la TV. L'ho chiamato "il modello 9" perché il primo numero per usarlo era 9. La sostanza è che inserisci un numero (diciamo x ) e poi torni indietro:

• X
• x + ( x / 3) [chiamiamolo y ]
• due terzi di y [chiamiamolo z ]
• z + 1

Quindi, se inserissi in questo modello il numero 9 come x , questo sarebbe ciò che verrebbe fuori:

• 9 ( 9 )
• 12 ( 9 + 9/3 ) [9 su 3 è 3 e 9 + 3 è 12]
• 8 ( 12 volte due terzi) [un terzo di 12 è 4 e 4 * 2 è 8]
• 9 ( 8 + 1 è 9)

Sfida

Scrivimi una funzione (in qualsiasi linguaggio di programmazione) che accetta un numero e genera un array intero usando il modello.
Un po 'come questo psuedo-codice:

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

chiarimenti

Discussioni hanno suscitato commenti in merito alle specifiche della domanda. Questa sezione ha lo scopo di chiarire alcuni di questi.

"meglio contare in byte che in caratteri"

Ho scelto personaggi perché (almeno per me) sarebbe stato più facile giudicare. Certo, non posso cambiarlo adesso. (molte risposte sono già state pubblicate)

"arrotondamento"

L'arrotondamento segue questa rima:

Se è 5 o più, aumenta il punteggio
Se è 4 o meno, lascialo riposare

In poche parole, se è qualcosa come 4.7 o 3.85, arrotondali rispettivamente a 5 e 4.

Esempi

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, tuttavia, i numeri sono qualcosa come 2.3 o 10.435446, arrotondali rispettivamente a 2 e 10.

"supporto linguistico"

Sei libero di non usare le funzioni e / o le matrici SE E SOLO SE la lingua che preferisci non le supporta. Se lo fa (anche se aumenterà il numero dei tuoi personaggi), devi usarli .

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

l'arrotondamento è piuttosto costoso: /

Provalo online

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

Beh, questo è stato più divertente del previsto, probabilmente non è ottimale ma credo che ci sto arrivando.

Tempo di spiegazione:

(per la versione 352 byte)

prima otteniamo l'argomento e lo stampiamo:

;
:

abbastanza semplice

passiamo quindi alla maggior parte del programma: la divisione input / 3

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

che è una conversione leggermente modificata della divisione brainfuck

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

quale prendere per input

n 0 d 0 0 

e restituirti

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

una volta ottenuta la divisione, la usiamo per ottenere la somma di n e n / d e stamparla

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

dobbiamo quindi fare un'altra divisione: (2 * (n + n / d)) / 3

quindi otteniamo (2 * (n + n / d)

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

e rimettilo con 3 nella divisione

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

a quel punto tutto esplode, mario è bloccato in un ciclo infinito facendo divisione su un numero sempre più grande, per sempre.

e per risolvere il fatto che abbiamo bisogno di un modo per differenziare tra la prima e la seconda divisione, si finisce per dire che, oh gioia, abbiamo un modo

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

fondamentalmente guardiamo se la x in

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

è 0, se significa che siamo nella prima divisione

altrimenti siamo nella seconda divisione e stampiamo solo il risultato della divisione, aggiungiamo 1 e poi lo stampiamo di nuovo

e voilà facile come una torta.

Emotinomicon 99 byte, 33 caratteri

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

Spiegazione:

😷                                 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

Provalo online

Abbastanza semplice, vconcatena lo stack in un array. Xoconverte in un tipo di dati intero e tutte le operazioni successive sono operazioni intere.

Cheddar , 27 byte

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

$0è variabile con input. Cheddar non è un linguaggio da golf ¯ \ _ (ツ) _ / ¯, anche questo non è competitivo perché la funzionalità di input di Cheddar è stata creata dopo questa sfida.

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 caratteri

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 lettera dposta subito dopo un numero intero rende l'intero adouble .

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

Senza la classe ( class c{}è lunga 8 caratteri), si riduce a 76 caratteri:

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

Versione più accurata in 110 caratteri (118 con l'enum) - usa floats perché non c'è nessuno spazio per il casting 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

Come alcuni utenti hanno sottolineato, questa soluzione (come alcuni altri in Java) non arrotonda correttamente i dati. Quindi ora sto presentando una soluzione leggermente più lunga che dovrebbe restituire il risultato corretto

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

o 60 byte versione lamda

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

Versione golfizzata

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

o 36 byte definiti come 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};}

Appunti

• Questo ha l'arrotondamento richiesto integrato, non sono sicuro se puoi farlo più breve se mescolato con la soluzione di @ user902383.

Ungolfed

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

Uscita con i = 9

[9, 12, 8, 9]

Scratch, 33 byte

Chiede input, set aper input arrotondati, set be crelative modifiche, quindi dice tutti e quattro i numeri, separati da virgole.

Java 8 lambda, 109 81 79 75 caratteri

Perché ... sai ... anche Java può essere giocato a golf ...

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

Lambda non classificato in 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};
    }
}

Presumo che mi permetta di usare i long in quanto sono anche un tipo intero. Purtroppo è necessario arrotondare correttamente gli interi e quindi un cast "breve" non funziona. Usando i long non abbiamo bisogno di riportare i risultati dell'arrotondamento in ints.

Aggiornare

Usando il simpatico piccolo + 0,5 e poi lanciando il trucco, manteniamo il corretto arrotondamento e risparmiamo 2 caratteri!

Inoltre, questo trucco non richiede più l'uso di long, quindi possiamo tornare alla rasatura ints di altri 4 caratteri.

Mathematica - 21 byte

Ho appena ricevuto Mathematica dal mio RPi dei miei fratelli, quindi provalo per divertimento e quale modo migliore di una sfida PPCG.

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

Definisce una funzione anonima. Provalo come:

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

Vedi questo codice in esecuzione su ideone.com

Lua, 52 byte

Questo programma accetta un numero per argomento della riga di comando e restituisce l'array corrispondente. I programmi in lua sono tecnicamente funzioni, poiché l'interprete li incapsulerà sempre in una funzione. Questo è anche questo meccanico che viene usato quando "chiamate" codici in altri file (fondamentalmente usa loadfile/ dofile).

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

In realtà, 21 byte

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

Questo programma dichiara una funzione che esegue le operazioni richieste sul valore dello stack superiore.

Provalo online! (il extra. alla fine valuta la funzione e stampa il risultato)

Spiegazione:

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

L'equivalenza del byte codegolf di Mathcad deve ancora essere determinata. Prendendo un conteggio della tastiera come equivalente approssimativo, la soluzione è di circa 40 byte.

05AB1E , 15 byte

Codice:

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

Utilizza la codifica CP-1252 . Provalo online! .

Pyke, 11 byte

D}[}3/bD)[h

Provalo qui!

            - 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

Ho convertito la mia soluzione Java in JavaScript e l'ho scremata un po '.

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 caratteri

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

• Ciò richiede che l' intestazione cmath funzioni.

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 byte

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

Per eseguire, salva come f.erl , compila e chiama la funzione. Restituirà un elenco di 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>

Si noti che Erlang converte automaticamente int s in caratteri ASCII se ci si trova nell'intervallo di valori ASCII perché Erlang non ha un carattere tipo di . Chiamare la funzione con 100 ti dà la migliore lettura [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 byte

Risposta ispirata da @ fxk8y (non sono riuscito a pubblicare un commento alla sua risposta)

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

Inoltre puoi vedere i risultati con:

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

Pyth, 20 byte

m.RdZ[Jc*4Q3Kc*2J3hK

Spiegazione:

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

Prova qui

Jolf, 17 byte

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

Definisce una funzione Ώ. Prende implicitamente input, quindi funge anche da programma completo. Provalo qui!

Mathematica, 51 byte

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

Funzione anonima conforme alla versione corrente (al momento della pubblicazione) del post, che implica arrotondamenti ad ogni passaggio.

FoldListè un'operazione tipica in programmazione. Viene invocato come FoldList[f, list]e applica la funzione a due argomentif ripetutamente la al risultato (o al primo elemento dell'elenco nella prima iterazione), prendendo l'elemento successivo dell'elenco come secondo argomento.

Ungolfed: #2 @ # &è una funzione anonima che applica il suo secondo argomento al primo. Pertanto, l'argomento elenco di FoldListconsiste delle funzioni successive da applicare all'input.

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

Poiché l'input è un numero intero e le divisioni sono per 3, non ci sarà mai un risultato come 4.5, quindi non è necessario preoccuparsi delle regole di arrotondamento quando l'ultima cifra è a 5: sarà sempre chiaramente più vicina a un intero o a un altro.

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

Provalo online
Yay per lingue non convenzionali!

CJam, 21 byte

qi__3d/+mo_2d3/*i_)]`

Il feedback è il benvenuto

Spiegazione

• qi__ - Leggi l'input come numero intero e duplicalo due volte
• 3D/+mo - Dividi un'istanza dell'input per 3, quindi aggiungila alla seconda istanza per creare y
• _2d3/*i - Duplica y, quindi moltiplicalo per .6
• _)] `- Duplica, incrementa, avvolgi in array, stampa come array (non nel codice a causa dell'operatore` :()

Modifica: ho dimenticato di trasformare i primi tre in doppio, quindi il programma è stato interrotto. Fisso.

Assioma, 59 byte

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

test

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

Provalo online!

PHP, 67 byte

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