The Nine Pattern


9

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 .


1
La sortie doit-elle être un tableau ou les nombres sont-ils suffisants en eux-mêmes (comme la réponse Pyth)?
David

2
Vous êtes libre de vous limiter à des programmes complets ou à des fonctions, mais il y a une discussion sur la méta des valeurs par défaut, ce qui donne des informations utiles au cas où cela affecterait votre décision pour les défis futurs. Par défaut, les défis acceptent les deux, pour permettre à plus de langues de rivaliser.
trichoplax

1
Il existe également des valeurs par défaut pour l'entrée et la sortie . Encore une fois, vous n'avez pas à les suivre, c'est juste pour vous le faire savoir.
trichoplax

3
-1 pour les exigences de tableau et de fonction arbitraires, ce qui empêche les langues sans type de tableau / liste ou fonctions de se faire concurrence.
Mego

4
En outre, vous devez noter les candidats en octets, pas en caractères. Nous avons un bac à sable , où vous pouvez obtenir des commentaires sur votre message avant sa mise en ligne.
Loovjo

Réponses:


11

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.


Bienvenue chez PPCG!
Erik the Outgolfer

Ne correspond pas aux spécifications fournies par la question (bien sûr, je l'ai mise à jour après avoir posté votre réponse, mais vous devez au moins mettre à jour votre réponse pour l'adapter aux nouvelles spécifications)
InitializeSahib

Terminé. pendant que nous parlons de cas de test, vous devez ajouter 10 pour avoir un nombre que vous arrondissez sur la première opération.
Ether Frog

9

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

3
Ouais pour les langues non conventionnelles! : P
user48538

4

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.


3
La spécification est de renvoyer un tableau, pas seulement le résultat final.
Value Ink

3
Aussi lol à ceux qui signalent la suppression dans <2 minutes: D
David

@David D: Je ne pense pas pouvoir retirer les votes de suppression
Downgoat

@David a voté pour votre réponse comme mes condoléances :)
InitializeSahib

1
Je suis sûr que ce n'est pas une fonction non plus, corrigez-moi si je me trompe.
Maltysen

4

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
]

1
Larmes de joie! C'est parti si loin! : D
Conor O'Brien

3

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

Je pense que je devrais apprendre Pyth.
user8397947

5
+1, parce que tu sais, java
James

1
@dorukayhan Bizarre, il semble que j'obtienne une erreur lorsque j'essaie d'exécuter ceci dans Eclipse, il ne peut pas convertir de double en int. Je vais voir si je peux comprendre quel est le problème demain.
Loovjo

1
Je viens de
corriger

1
Je vois, mais cela ne donne pas de résultats corrects pour des entrées comme 8 ou 10. Le premier ajout ne fonctionne pas correctement, tout comme l' I + (I / 3)utilisation d'une division entière, ce qui signifie que les fractions sont rejetées et que le résultat n'est donc pas arrondi correctement.
Frozn

3

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}


N'a pas l'arrondi requis par la question.
Marv

1
Comme @Marv l'a mentionné, cette question ne fonctionne pas correctement, par exemple pour l'entrée 8, le résultat attendu serait [8,11,7,8] mais il est [8,10,7,8]
Frozn

pourquoi downvote? je l'ai réparé et ça fonctionne correctement maintenant?
user902383

Désolé pour le downvote après l'avoir corrigé. Le vote négatif est verrouillé maintenant, donc je ne peux pas le supprimer à moins que vous
apportiez

@ edc65 ok, fait
user902383

2

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]


Identique à la solution de user902383, cela ne fonctionne pas correctement, par exemple pour 8 attendus [8,11,7,8] mais est [8,10,7,8], pour 6 attendus [6,8,5,6] mais est [6,8,6,7]
Frozn

3
@Frozn cette solution ne fonctionne pas correctement aussi, et pour les cas de test que vous avez donnés, retournez le même résultat que mon ancienne solution ideone.com/LVK8FU
user902383

2

Scratch, 33 octets

Scénario
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.


2

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.


Bienvenue chez PPCG!
Erik the Outgolfer

Merci :) J'ai suivi les questions ici depuis un moment maintenant et je me suis dit que c'était peut-être une question à laquelle je pouvais participer bien que la réponse soit plus longue que ce à quoi je m'attendais.
Frozn

Je vais "+1", en espérant que vous ajouterez le obligatoire "parce que ... vous savez ... Java!"
Olivier Dulac

@Frozn Je ne sais pas si vous pouvez supprimer le a->{et le final }pour -5 octets.
Erik the Outgolfer

@OlivierDulac Pas encore :)
Erik the Outgolfer

1

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}

Cela donnera-t-il des nombres entiers ou des fractions?
David

@David entiers, sauf si les résultats ne sont pas intégraux, auquel cas des fractions.
Maltysen


1

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}

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)

1

Mathcad, [tbd] octets

entrez la description de l'image ici


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.



1

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

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]

1

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
}

2
N'étant pas un expert C ++ mais vous pouvez le raccourcir en réutilisant les valeurs déjà calculées que vous avez dans le tableau. Vous pouvez également supprimer certains espaces blancs entre) et {ne sais pas à quel point C ++ est strict.
Frozn

Ces deux derniers sont-ils corrects dans la version actuelle? Parce que je viens de vous voir calculer p+(p/3)*(2/3)ce qui est p+(2*p/9)au lieu de(p+(p/3))*(2/3)
Frozn

Il s'avère que c'était une erreur de ma part. Je mets - 1 au lieu de +1 pour la dernière itération: P
InitializeSahib

0

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

0

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

0

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


0

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!


Jolf devient ESMin lentement confirmé ??? : P
Downgoat

@Upgoat ey c'est grec. Et encore minuit. : P
Conor O'Brien

> _> oh. Très désolé si je vous ai réveillé> _> _> _>
Downgoat

@Upgoat pas encore endormi;)
Conor O'Brien

: | idk si c'est une bonne chose que je vous ai prêté vous réveiller ou une mauvaise chose que vous êtes toujours éveillé
Downgoat

0

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.




0

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


0

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


0

PHP, 67 octets

function f($x){return [$x,$y=round($x*4/3),$z=round($y*2/3),$z+1];}
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.