Wprowadzenie

Pewnego dnia natknąłem się na ten (bezużyteczny) wzór podczas oglądania telewizji. Nazwałem go „wzorem 9”, ponieważ pierwszą cyfrą, która go użyła, było 9. Istotą tego jest to, że wpisujesz liczbę (powiedzmy x ), a następnie wracasz:

• x
• x + ( x / 3) [nazwijmy to y ]
• dwie trzecie y [nazwijmy to z ]
• z + 1

Tak więc, jeśli wstawię do tego wzoru cyfrę 9 jako x , oto co wyjdzie:

• 9 ( 9 )
• 12 ( 9 + 9/3 ) [9 powyżej 3 to 3, a 9 + 3 to 12]
• 8 ( 12 razy dwie trzecie) [jedna trzecia z 12 to 4, a 4 * 2 to 8]
• 9 ( 8 + 1 to 9)

Wyzwanie

Napisz mi funkcję (w dowolnym języku programowania), która przyjmuje liczbę i generuje tablicę liczb całkowitych za pomocą wzorca.
Trochę jak ten kod 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;  
}

Wyjaśnienia

W komentarzach dotyczących specyfikacji pytania pojawiły się dyskusje. Ta sekcja ma na celu wyjaśnienie niektórych z nich.

„lepiej liczyć w bajtach niż w znakach”

Wybrałem postacie, ponieważ (przynajmniej dla mnie) łatwiej byłoby ocenić. Oczywiście nie mogę tego teraz zmienić. (wiele odpowiedzi jest już opublikowanych)

„zaokrąglenie”

Zaokrąglanie następuje według tego wiersza:

Jeśli jest to 5 lub więcej, podnieś wynik
Jeśli jest to 4 lub mniej, pozwól mu odpocząć

Mówiąc prosto, jeśli jest to coś takiego jak 4.7 lub 3.85, zaokrąglij je odpowiednio do 5 i 4.

Przykłady

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]

Jeśli jednak liczby są podobne do 2,3 lub 10,435446, zaokrąglij je odpowiednio do 2 i 10.

„obsługa języków”

Możesz swobodnie korzystać z funkcji i / lub tablic JEŻELI I TYLKO JEŻELI wybrany język ich nie obsługuje. Jeśli tak (nawet jeśli zwiększy liczbę twoich postaci), musisz ich użyć .

MarioLANG, 659 621 591 582 556 543 516 458 418 401 352 308 369 bajtów

zaokrąglanie jest dość drogie: /

Wypróbuj online

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

Cóż, było więcej zabawy niż się spodziewano, prawdopodobnie nie jest to optymalne, ale chyba się tam dostaję.

Czas wyjaśnienia:

(dla wersji 352 bajtów)

najpierw otrzymujemy argument i wypisujemy go:

;
:

wystarczająco proste

następnie przechodzimy do głównej części programu: podział wejścia / 3

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

co jest nieco zmodyfikowaną konwersją podziału na pieprzenie mózgu

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

które wymagają wkładu

n 0 d 0 0 

i oddam ci

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

po uzyskaniu podziału używamy go, aby uzyskać sumę n i n / d i wydrukować ją

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

następnie musimy wykonać inny podział: (2 * (n + n / d)) / 3

więc otrzymujemy (2 * (n + n / d)

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

i wróć z 3 do dywizji

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

w tym momencie wszystko się ujawnia, Mario utknął w nieskończonej pętli i na zawsze dzielił coraz większą liczbę.

i aby ustalić, że potrzebujemy sposobu, aby odróżnić pierwszą i drugą dywizję, to w końcu, och, radości, mamy sposób

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

w zasadzie sprawdzamy, czy x w

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

wynosi 0, jeśli to znaczy, że jesteśmy w pierwszej lidze

w przeciwnym razie jesteśmy w drugim dziale i po prostu drukujemy wynik podziału, dodajemy 1, a następnie drukujemy go ponownie

i voila łatwe jak ciasto.

Emotinomicon 99 bajtów, 33 znaków

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

Wyjaśnienie:

😷                                 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 bajtów

Xot4*3/tE3/tQv

Wypróbuj online

Całkiem proste, vłączy stos w macierz. Xokonwertuje na typ danych liczb całkowitych, a wszystkie późniejsze operacje są operacjami liczb całkowitych.

Cheddar , 27 bajtów

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

$0jest zmienna z wejściem. Cheddar po prostu nie jest golfowym językiem ¯ \ _ (ツ) _ / ¯, również nie jest konkurencyjny, ponieważ funkcjonalność wprowadzania Cheddara została stworzona po tym wyzwaniu.

Nie golfowany:

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 znaków

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

Litera dumieszczona zaraz po liczbie całkowitej powoduje, że liczba całkowita a double.

Nie golfowany:

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

Bez klasy ( class c{}ma 8 znaków) zmniejsza rozmiar do 76 znaków:

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

Dokładniejsza wersja w 110 znakach (118 z enumem) - używa floats, ponieważ nikt nie ma miejsca na rzucanie 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 bajtów

Jak zauważyli niektórzy użytkownicy, to rozwiązanie (jak inni w Javie) nie zaokrągla danych poprawnie. Więc teraz przedstawiam nieco dłuższe rozwiązanie, które powinno zwrócić poprawny wynik

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

lub 60 bajtów wersja Lamda

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

Wersja golfowa

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

i nie golfił

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

lub 36 bajtów zdefiniowanych jako lambda

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

Java, 64 bajty

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

Notatki

• Ma to wbudowane wymagane zaokrąglanie, nie jestem pewien, czy możesz to zrobić krócej, jeśli zmieszane z rozwiązaniem @ user902383.

Nie golfił

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

Wyjście z i = 9

[9, 12, 8, 9]

Scratch, 33 bajty

Pyta o dane wejściowe, zestawy ado wprowadzania zaokrąglone, zbiory bi cich odpowiednie zmiany, a następnie podaje wszystkie cztery liczby, oddzielone przecinkami.

Java 8 lambda, 109 81 79 75 znaków

Ponieważ ... no wiesz ... nawet Java może być golfa ...

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

Lambda nie zakwalifikował się do klasy:

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

Zakładam, że wolno mi używać długich, ponieważ są one również liczbami całkowitymi. Niestety trzeba poprawnie zaokrąglić liczby całkowite i dlatego rzutowanie „krótkie” nie działa. Używając longów, nie musimy rzutować wyników zaokrąglania z powrotem na ints.

Aktualizacja

Używając ładnego małego + 0,5, a następnie sztuczki rzucania, zachowujemy prawidłowe zaokrąglenie i oszczędzamy 2 znaki!

Również ta sztuczka nie wymaga już dłuższego używania, dzięki czemu możemy wrócić do golenia ints 4 kolejnych znaków.

Mathematica - 21 bajtów

Właśnie dostałem Mathematica od moich braci RPi, więc wypróbowałem to dla zabawy i na lepszy sposób niż wyzwanie PPCG.

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

Definiuje anonimową funkcję. Wypróbuj jak:

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

In[27]:= x[9]                                                                 

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

Python 3, 45 bajtów

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

Zobacz ten kod działający na ideone.com

Lua, 52 bajty

Ten program pobiera liczbę według argumentu wiersza poleceń i zwraca odpowiednią tablicę. Programy w lua są technicznie funkcjami, ponieważ interpreter zawsze będzie je zawierał w funkcję. Jest to również ta mechanika używana podczas „wywoływania” kodów w innych plikach (w zasadzie używa loadfile/ dofile).

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

Właściwie 21 bajtów

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

Ten program deklaruje funkcję, która wykonuje wymagane operacje na wartości najwyższego stosu.

Wypróbuj online! (dodatkowy .na końcu ocenia funkcję i drukuje wynik)

Wyjaśnienie:

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

Ekwiwalent bajtów Mathcad codegolf nie został jeszcze ustalony. Biorąc pod uwagę klawiaturę jako przybliżony odpowiednik, rozwiązanie ma około 40 bajtów.

05AB1E , 15 bajtów

Kod:

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

Wykorzystuje kodowanie CP-1252 . Wypróbuj online! .

Pyke, 11 bajtów

D}[}3/bD)[h

Wypróbuj tutaj!

            - 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 bajtów

Konwertuję moje rozwiązanie Java na JavaScript i trochę go odrzuciłem.

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 znaków

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

• Wymaga to nagłówka cmath do działania.

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 bajtów

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

Aby uruchomić, zapisz jako f.erl , skompiluj i wywołaj funkcję. Zwróci listę 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>

Zauważ, że Erlang automatycznie konwertuje int na znaki ASCII, jeśli jesteś w zakresie wartości ASCII, ponieważ Erlang nie ma typu char . Wywołanie funkcji za pomocą 100 daje lepszą czytelność [100,133,88,89] .

Nie golfowany:

-module(f).
-export([f/1]).

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

Erlang, 46 bajtów

Odpowiedź inspirowana przez @ fxk8y (nie mogłem dodać komentarza do jego odpowiedzi)

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

Możesz również zobaczyć wyniki za pomocą:

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

Pyth, 20 bajtów

m.RdZ[Jc*4Q3Kc*2J3hK

Wyjaśnienie:

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

Przetestuj tutaj

Jolf, 17 bajtów

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

Definiuje funkcję Ώ. Przyjmuje dane niejawnie, więc podwaja się również jako pełny program. Wypróbuj tutaj!

Mathematica, 51 bajtów

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

Anonimowa funkcja, która jest zgodna z bieżącą (w momencie publikacji) wersją postu, co oznacza zaokrąglanie na każdym kroku.

FoldListjest typową operacją w programowaniu. Jest wywoływany jako FoldList[f, list]i stosuje funkcję dwóch argumentówf wielokrotnie do wyniku (lub pierwszego elementu listy w pierwszej iteracji), przyjmując następny element listy za swój drugi argument.

Ungolfed: #2 @ # &to anonimowe funkcje, które stosują swój drugi argument do pierwszego. Dlatego argument listy FoldListskłada się z kolejnych funkcji, które należy zastosować do danych wejściowych.

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

Ponieważ dane wejściowe są liczbami całkowitymi, a podziałki są równe 3, wynik nigdy nie będzie taki jak 4,5, dlatego nie trzeba się martwić o zasady zaokrąglania, gdy ostatnia cyfra to 5: zawsze będzie wyraźnie bliżej jednej lub drugiej liczby całkowitej.

Dyalog APL , 33 bajty

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

Desmos, 37 bajtów

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

Wypróbuj online
Yay dla niekonwencjonalnych języków!

CJam, 21 bajtów

qi__3d/+mo_2d3/*i_)]`

Informacje zwrotne są mile widziane

Wyjaśnienie

• qi__ - Przeczytaj dane wejściowe jako liczbę całkowitą i zduplikuj je dwukrotnie
• 3D/+mo - Podziel jedno wystąpienie danych wejściowych przez 3, a następnie dodaj je do drugiego wystąpienia, aby uzyskać y
• _2d3/*i - Zduplikuj y, a następnie pomnóż go przez .6
• _)] `- Kopiuj, inkrementuj, zawijaj w tablicę, drukuj jako tablicę (nie w kodzie ze względu na operator :()

Edycja: Zapomniałem zrobić pierwsze trzy podwójne, więc program został zepsuty. Naprawiony.

Aksjomat, 59 bajtów

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 bajtów

print_r([$a=$argn,$b=round($a+$a/3),$c=round($b*2/3),$c+1]);

Wypróbuj online!

PHP, 67 bajtów

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