Einführung

Ich bin neulich beim Fernsehen über dieses (nutzlose) Muster gestolpert. Ich habe es "das 9-Muster" genannt, weil die erste Zahl, die es verwendet hat, 9 war. Der Kern davon ist, dass Sie eine Zahl eingeben (sagen wir x ) und dann zurückkommen:

• x
• x + ( x / 3) [nennen wir das y ]
• zwei Drittel von y [nennen wir das z ]
• z + 1

Wenn ich also die Zahl 9 als x in dieses Muster einfügen würde, würde Folgendes herauskommen:

• 9 ( 9 )
• 12 ( 9 + 9/3 ) [9 über 3 ist 3 und 9 + 3 ist 12]
• 8 ( 12 mal zwei Drittel) [ein Drittel von 12 ist 4 und 4 * 2 ist 8]
• 9 ( 8 + 1 ist 9)

Herausforderung

Schreiben Sie mir eine Funktion (in einer beliebigen Programmiersprache), die eine Zahl aufnimmt und anhand des Musters ein ganzzahliges Array ausgibt.
Etwas wie dieser Pseudo-Code:

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

Klarstellungen

In den Kommentaren zu den Spezifikationen der Frage wurden Diskussionen ausgelöst. Dieser Abschnitt soll einige davon verdeutlichen.

"Besser in Bytes als in Zeichen zählen"

Ich habe Charaktere ausgewählt, weil es (zumindest für mich) einfacher wäre, sie zu beurteilen. Natürlich kann ich das jetzt nicht ändern. (viele Antworten sind bereits veröffentlicht)

"Runden"

Die Rundung folgt diesem Reim:

Wenn es 5 oder mehr ist, erhöhen Sie die Punktzahl.
Wenn es 4 oder weniger ist, lassen Sie es ruhen

Einfach ausgedrückt, wenn es sich um 4,7 oder 3,85 handelt, runden Sie sie auf 5 bzw. 4 ab.

Beispiele

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]

Wenn die Zahlen jedoch etwa 2,3 oder 10,435446 betragen, runden Sie sie auf 2 bzw. 10.

"Sprachunterstützung"

Es steht Ihnen frei, Funktionen und / oder Arrays NICHT zu verwenden, WENN UND NUR WENN die Sprache Ihrer Wahl sie nicht unterstützt. Wenn dies der Fall ist (auch wenn dadurch die Anzahl Ihrer Zeichen erhöht wird), müssen Sie sie verwenden .

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

Rundung ist ziemlich teuer: /

Probieren Sie es online aus

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

Nun, das hat mehr Spaß gemacht als erwartet, das ist wahrscheinlich nicht optimal, aber ich denke, ich komme dorthin.

Erklärungszeit:

(für die 352- Byte-Version)

Zuerst bekommen wir das Argument und drucken es aus:

;
:

einfach genug

Wir gehen dann zum Hauptteil des Programms über: der Divisionseingabe / 3

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

Das ist eine leicht modifizierte Umwandlung der Brainfuck-Division

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

die für die Eingabe nehmen

n 0 d 0 0 

und gib dir zurück

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

Sobald wir die Division erhalten haben, verwenden wir sie, um die Summe von n und n / d zu erhalten und sie zu drucken

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

wir müssen dann eine andere Division machen: (2 * (n + n / d)) / 3

so erhalten wir (2 * (n + n / d)

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

und setzen Sie es mit 3 zurück in die Division

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

An diesem Punkt explodiert alles, Mario steckt in einer Endlosschleife und teilt sich für immer in immer größere Zahlen.

und um zu beheben, dass wir einen Weg brauchen, um zwischen der ersten und der zweiten Division zu unterscheiden, endet es damit, dass wir, oh Freude, einen Weg haben

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

Grundsätzlich schauen wir, ob das x in

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

ist 0, wenn es bedeutet, dass wir in der ersten Liga sind

Andernfalls befinden wir uns in der zweiten Division und drucken nur das Ergebnis der Division aus. Fügen Sie 1 hinzu und drucken Sie es dann erneut aus

und voilà einfach wie Torte.

Emotinomicon 99 Bytes, 33 Zeichen

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

Erläuterung:

😷                                 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

Probieren Sie es online aus

Ziemlich einfach, vverkettet den Stapel zu einem Array. Xokonvertiert in einen ganzzahligen Datentyp, und alle Operationen danach sind ganzzahlige Operationen.

Cheddar , 27 Bytes

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

$0ist variabel mit Eingabe. Cheddar ist einfach keine Golfsprache ¯ \ _ (ツ) _ / ¯, auch dies ist nicht konkurrierend, da Cheddars Eingabefunktionalität nach dieser Herausforderung erstellt wurde.

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 Zeichen

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

Der Buchstabe ddirekt nach einer Ganzzahl macht die Ganzzahl 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};
    }
}

Ohne die Klasse ( class c{}8 Zeichen lang) wird sie auf 76 Zeichen verkleinert:

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

Genauere Version in 110 Zeichen (118 mit der Aufzählung) - es wird floats verwendet, weil niemand Platz zum Casting hat 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

Wie einige Benutzer betonten, rundet diese Lösung (wie andere in Java) Daten nicht richtig. Jetzt präsentiere ich eine etwas längere Lösung, die das richtige Ergebnis liefern sollte

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

oder 60 Bytes Lamda-Version

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

Golfversion

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

und ungolfed

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

oder 36 Bytes als Lambda definiert

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

Anmerkungen

• Dies hat die erforderliche Rundung eingebaut, nicht sicher, ob Sie es kürzer machen können, wenn Sie es mit der Lösung von @ user902383 mischen.

Ungolfed

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

Ausgabe mit i = 9

[9, 12, 8, 9]

Scratch, 33 Bytes

Fragt nach Eingabe, setzt aauf gerundete Eingabe, setzt bund cauf ihre jeweiligen Änderungen, sagt dann alle vier durch Kommas getrennten Zahlen.

Java 8 Lambda, 109 81 79 75 Zeichen

Weil ... Sie wissen ... sogar Java Golf spielen kann ...

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

Lambda ungolfed in die Klasse:

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

Ich gehe davon aus, dass ich Longs verwenden darf, da diese ebenfalls vom Typ Integer sind. Leider muss man ganze Zahlen richtig runden und daher funktioniert eine "kurze" Besetzung nicht. Durch die Verwendung von Longs müssen wir die Rundungsergebnisse nicht auf Ints zurücksetzen.

Aktualisieren

Mit dem netten kleinen + 0,5 und dem anschließenden Casting-Trick behalten wir die richtige Rundung bei und sparen 2 Zeichen!

Auch dieser Trick erfordert nicht länger die Verwendung von Long, so dass wir wieder auf Ints-Rasur von 4 weiteren Zeichen umschalten können.

Mathematica - 21 Bytes

Ich habe gerade Mathematica von meinem Bruder RPi bekommen, also probiere es zum Spaß aus und was gibt es Schöneres als eine PPCG-Herausforderung.

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

Definiert eine anonyme Funktion. Probieren Sie es aus wie:

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

Sehen Sie diesen Code auf ideone.com

Lua, 52 Bytes

Dieses Programm nimmt eine Zahl per Befehlszeilenargument und gibt das entsprechende Array zurück. Programme in lua sind technisch gesehen Funktionen, da der Interpreter sie immer in eine Funktion einkapselt. Dies ist auch diese Mechanik, die verwendet wird, wenn Sie Codes in anderen Dateien "aufrufen" (sie verwendet grundsätzlich loadfile/ dofile).

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

Eigentlich 21 Bytes

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

Dieses Programm deklariert eine Funktion, die die erforderlichen Operationen für den obersten Stapelwert ausführt.

Probieren Sie es online aus! (Das Extra .am Ende wertet die Funktion aus und druckt das Ergebnis aus.)

Erläuterung:

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

Die Mathcad-Codegolf-Byte-Äquivalenz muss noch ermittelt werden. Bei einer Tastaturanzahl als grobes Äquivalent beträgt die Lösung ca. 40 Byte.

05AB1E , 15 Bytes

Code:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online aus! .

Pyke, 11 Bytes

D}[}3/bD)[h

Probieren Sie es hier aus!

            - 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

Ich konvertiere meine Java-Lösung in JavaScript und überfliege sie ein wenig.

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 Zeichen

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

• Dies erfordert, dass der cmath- Header funktioniert.

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

Speichern Sie zum Ausführen als f.erl , kompilieren Sie die Funktion und rufen Sie sie auf. Es wird eine Liste von Ints zurückgegeben:

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>

Beachten Sie, dass Erlang int s automatisch in ASCII-Zeichen konvertiert , wenn Sie sich im ASCII-Wertebereich befinden, da Erlang keinen Zeichentyp hat . Wenn Sie die Funktion mit 100 aufrufen, erhalten Sie die bessere Lesbarkeit [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

Antwort inspiriert von @ fxk8y (Ich konnte keinen Kommentar zu seiner Antwort posten)

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

Sie können die Ergebnisse auch sehen mit:

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

Pyth, 20 Bytes

m.RdZ[Jc*4Q3Kc*2J3hK

Erläuterung:

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

Hier testen

Jolf, 17 Bytes

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

Definiert eine Funktion Ώ. Es nimmt implizit Eingaben entgegen und dient somit auch als vollständiges Programm. Probieren Sie es hier aus!

Mathematica, 51 Bytes

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

Anonyme Funktion, die der aktuellen (zum Zeitpunkt der Veröffentlichung) Version der Veröffentlichung entspricht und eine Rundung bei jedem Schritt impliziert.

FoldListist eine typische Operation in der Programmierung. Es wird als aufgerufen FoldList[f, list]und wendet die Funktion mit zwei Argumenten fwiederholt auf das Ergebnis (oder das erste Element der Liste in der ersten Iteration) an, wobei das nächste Element der Liste als zweites Argument verwendet wird.

Ungolfed: #2 @ # &ist eine anonyme Funktion, die ihr zweites Argument auf das erste anwendet. Daher besteht das Listenargument von FoldListaus den aufeinanderfolgenden Funktionen, die auf die Eingabe angewendet werden sollen.

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

Da die Eingabe eine Ganzzahl ist und die Teilungen durch 3 sind, wird es niemals ein Ergebnis wie 4,5 geben. Daher müssen Sie sich keine Gedanken über Rundungsregeln machen, wenn die letzte Ziffer a ist 5: Sie liegt immer deutlich näher an der einen oder anderen Ganzzahl.

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

Probieren Sie es online aus
Yay für unkonventionelle Sprachen!

CJam, 21 Bytes

qi__3d/+mo_2d3/*i_)]`

Feedback ist willkommen

Erläuterung

• qi__ - Lesen Sie die Eingabe als Ganzzahl und duplizieren Sie sie zweimal
• 3D/+mo - Teilen Sie eine Instanz der Eingabe durch 3 und fügen Sie sie dann der zweiten Instanz hinzu, um y zu erstellen
• _2d3/*i - Dupliziere y und multipliziere es mit .6
• _)] `- Duplizieren, inkrementieren, in Array einschließen, als Array drucken (wegen des Operators` nicht im Code :()

Bearbeiten: Ich habe vergessen, die ersten drei zu einem Double zu machen, daher war das Programm kaputt. Fest.

Axiom, 59 Bytes

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

Prüfung

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

Probieren Sie es online aus!

PHP, 67 Bytes

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