introduction

Je suis tombé sur ce modèle (inutile) l'autre jour alors que je regardais la télévision. Je l'ai appelé "le motif 9" parce que le premier nombre à l'utiliser était 9. L'essentiel est que vous entrez un nombre (disons x ), puis vous revenez:

• X
• x + ( x / 3) [appelons cela y ]
• les deux tiers de y [appelons cela z ]
• z + 1

Donc, si je mets à l'intérieur de ce motif le nombre 9 en tant que x , voici ce qui sortirait:

• 9 ( 9 )
• 12 ( 9 + 9/3 ) [9 sur 3 est 3 et 9 + 3 est 12]
• 8 ( 12 fois les deux tiers) [un tiers de 12 est 4 et 4 * 2 est 8]
• 9 ( 8 + 1 est 9)

Défi

Écrivez-moi une fonction (dans n'importe quel langage de programmation) qui prend un nombre et génère un tableau entier en utilisant le modèle.
Un peu comme ce 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;  
}

Clarifications

Les discussions ont suscité des commentaires concernant les spécifications de la question. Cette section vise à clarifier certains d'entre eux.

"mieux vaut compter en octets que en caractères"

J'ai choisi des personnages parce que (pour moi, au moins), il serait plus facile de juger. Bien sûr, je ne peux pas changer ça maintenant. (de nombreuses réponses sont déjà publiées)

"arrondi"

L'arrondi suit cette rime:

Si c'est 5 ou plus, augmentez le score
Si c'est 4 ou moins, laissez reposer

Autrement dit, si c'est quelque chose comme 4,7 ou 3,85, arrondissez-les respectivement à 5 et 4.

Exemples

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]

Si, cependant, les nombres sont quelque chose comme 2,3 ou 10,435446, arrondissez-les respectivement à 2 et 10.

"support linguistique"

Vous êtes libre de ne pas utiliser les fonctions et / ou les tableaux SI ET UNIQUEMENT SI la langue de votre choix ne les prend pas en charge. Si c'est le cas (même si cela augmentera le nombre de vos personnages), vous devez les utiliser .

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

l'arrondi est assez cher: /

Essayez-le en ligne

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

Eh bien, c'était plus amusant que prévu, ce n'est probablement pas optimal mais je suppose que j'y arrive.

Temps d'explication:

(pour la version 352 octets)

nous obtenons d'abord l'argument et l'imprimons:

;
:

assez simple

on passe ensuite à l'essentiel du programme: la division input / 3

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

qui est une conversion légèrement modifiée de la division brainfuck

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

qui prennent pour entrée

n 0 d 0 0 

et te rendre

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

une fois que nous avons obtenu la division, nous l'utilisons pour obtenir la somme de n et n / d et l'imprimer

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

nous devons ensuite faire une autre division: (2 * (n + n / d)) / 3

nous obtenons donc (2 * (n + n / d)

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

et le remettre avec 3 dans la division

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

à ce moment-là, tout explose, mario est coincé dans une boucle infinie faisant la division sur un nombre de plus en plus grand, pour toujours.

et pour corriger cela, nous avons besoin d'un moyen de faire la différence entre la première et la deuxième division, il en résulte que, oh joie, nous avons un moyen

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

fondamentalement, nous regardons si le x

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

est 0, si cela signifie que nous sommes sur la première division

sinon nous sommes sur la deuxième division, et nous imprimons simplement le résultat de la division, ajoutons 1, puis imprimons-le à nouveau

et voilà facile comme tarte.

Emotinomicon 99 octets, 33 caractères

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

Explication:

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

Xot4*3/tE3/tQv

Essayez-le en ligne

Assez simple, vconcatène la pile dans un tableau. Xoconvertit en un type de données entier, et toutes les opérations par la suite sont des opérations entières.

Cheddar , 27 octets

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

$0est variable avec entrée. Cheddar n'est tout simplement pas un langage golfique ¯ \ _ (ツ) _ / ¯, ce n'est pas non plus concurrentiel car la fonctionnalité d'entrée de Cheddar a été créée après ce défi.

Non 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 caractères

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 lettre dplacée juste après un entier fait l'entier a double.

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

Sans la classe ( class c{}8 caractères), elle passe à 76 caractères:

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

Version plus précise en 110 caractères (118 avec l'énumération) - il utilise floats car personne n'a de place pour le 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 octets

Comme certains utilisateurs l'ont souligné, cette solution (comme certaines autres en java) n'arrondit pas correctement les données. Alors maintenant, je présente une solution légèrement plus longue qui devrait retourner un résultat correct

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

ou version lamda 60 octets

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

Version golfée

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

et non golfé

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

ou 36 octets définis comme lambda

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

Java, 64 octets

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

Remarques

• Cela a la construction d'arrondi requise, je ne sais pas si vous pouvez le faire plus court s'il est mélangé avec la solution de @ user902383.

Non golfé

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

Sortie avec i = 9

[9, 12, 8, 9]

Scratch, 33 octets

Demande l'entrée, les ensembles aà entrer arrondis, les ensembles bet cleurs modifications respectives, puis dit les quatre nombres, séparés par des virgules.

Java 8 lambda, 109 81 79 75 caractères

Parce que ... vous savez ... même Java peut être joué au golf ...

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

Lambda non golfée en 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};
    }
}

Je suppose que je suis autorisé à utiliser les longs car ils sont également de type entier. Malheureusement, il faut arrondir correctement les entiers et donc une distribution "courte" ne fonctionne pas. En utilisant des longs, nous n'avons pas besoin de remettre les résultats d'arrondi en pouces.

Mise à jour

En utilisant le joli petit + 0,5 et le casting après, nous gardons l'arrondi correct et économisons 2 caractères!

De plus, cette astuce ne nécessite plus l'utilisation de long, nous pouvons donc revenir au rasage de 4 caractères supplémentaires.

Mathematica - 21 octets

Je viens de recevoir Mathematica de mes frères RPi, alors essayez-le pour le plaisir, et quoi de mieux qu'un défi PPCG.

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

Définit une fonction anonyme. Essayez-le comme:

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

In[27]:= x[9]                                                                 

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

Python 3, 45 octets

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

Voir ce code en cours d'exécution sur ideone.com

Lua, 52 octets

Ce programme prend un nombre par argument de ligne de commande et retourne le tableau correspondant. Les programmes dans lua sont techniquement des fonctions, car l'interpréteur les encapsulera toujours dans une fonction. C'est également ce mécanisme qui est utilisé lorsque vous "appelez" des codes dans d'autres fichiers (il utilise essentiellement loadfile/ dofile).

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

En fait, 21 octets

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

Ce programme déclare une fonction qui effectue les opérations requises sur la valeur de pile supérieure.

Essayez-le en ligne! (le supplément .à la fin évalue la fonction et imprime le résultat)

Explication:

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

L'équivalence d'octets Mathcad codegolf reste à déterminer. En considérant un clavier comme un équivalent approximatif, la solution est d'environ 40 octets.

05AB1E , 15 octets

Code:

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

Utilise l' encodage CP-1252 . Essayez-le en ligne! .

Pyke, 11 octets

D}[}3/bD)[h

Essayez-le ici!

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

Je convertis ma solution java en JavaScript et je l'ai survolé un peu.

var r=Math.round,g=a=>[a,r(a+a/3),a=r(a*8/9),++a]

C ++ 0x - 95 102 185 185 189 109 129 caractères

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

• Cela nécessite que l'en - tête cmath fonctionne.

Dégolfé

#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 octets

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

Pour exécuter, enregistrez sous f.erl , compilez et appelez la fonction. Il renverra une liste d'entiers:

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>

Notez que Erlang automatiquement convertis int s de caractères ASCII si vous êtes dans la plage de valeurs ASCII car Erlang ne dispose pas d' un omble chevalier de type. Appeler la fonction avec 100 vous donne la meilleure lisibilité [100,133,88,89] .

Non 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 octets

Réponse inspirée de @ fxk8y (je n'ai pas pu poster de commentaire sur sa réponse)

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

Vous pouvez également voir les résultats avec:

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

Pyth, 20 octets

m.RdZ[Jc*4Q3Kc*2J3hK

Explication:

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

Testez ici

Jolf, 17 octets

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

Définit une fonction Ώ. Il prend implicitement une entrée, il fait donc également office de programme complet. Essayez-le ici!

Mathematica, 51 octets

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

Fonction anonyme conforme à la version actuelle (au moment de la publication) de la publication, ce qui implique un arrondi à chaque étape.

FoldListest une opération typique de programmation. Elle est invoquée en tant que FoldList[f, list]et applique la fonction à deux arguments à fplusieurs reprises au résultat (ou au premier élément de la liste dans la première itération), en prenant l'élément suivant de la liste comme deuxième argument.

Ungolfed: #2 @ # &est une fonction anonyme qui applique son deuxième argument au premier. Par conséquent, l'argument de liste de se FoldListcompose des fonctions successives à appliquer à l'entrée.

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

Parce que l'entrée est un entier et que les divisions sont par 3, il n'y aura jamais de résultat comme 4,5, donc il n'y a pas besoin de se soucier des règles d'arrondi lorsque le dernier chiffre est un 5: il sera toujours clairement plus proche d'un entier ou d'un autre.

Dyalog APL , 33 octets

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

Desmos, 37 octets

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

Essayez-le en ligne
Yay pour les langues non conventionnelles!

CJam, 21 octets

qi__3d/+mo_2d3/*i_)]`

Vos commentaires sont les bienvenus

Explication

• qi__ - Lisez l'entrée sous forme d'entier et dupliquez-la deux fois
• 3D/+mo - Divisez une instance de l'entrée par 3, puis ajoutez-la à la deuxième instance pour faire y
• _2d3/*i - Dupliquez y, puis multipliez-le par 0,6
• _)] `- Dupe, incrémenter, envelopper dans un tableau, imprimer en tant que tableau (pas dans le code à cause de l'opérateur` :()

Edit: J'ai oublié de faire les trois premiers un double, donc le programme a été interrompu. Fixé.

Axiome, 59 octets

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

tester

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

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

Essayez-le en ligne!

PHP, 67 octets

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