九模式

9

介绍

前几天，我在看电视时偶然发现了这种（无用的）模式。我将其命名为“ 9模式”，因为要使用的第一个数字是9。其要旨是，输入数字（假设x），然后返回：

  • X
  • x +（x / 3）[我们叫这个y ]
  • y的三分之二[我们称为z ]
  • z + 1

所以，如果我把这个模式里面的数字9为X，这是会出来：

  • 9（9）
  • 12（9 + 9/3）[3分上的9是3，而9 + 3是12]
  • 8（三分之二的12倍）[12的三分之一是4，而4 * 2是8]
  • 9（8 +1是9）

挑战

给我写一个函数（使用任何编程语言），该函数接受一个数字，并使用该模式输出一个整数数组。
像这样的伪代码： 

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

澄清说明

有关该问题规格的评论引起了讨论。本节旨在澄清其中一些问题。

“更好地以字节为单位而不是字符”

我选择字符是因为（至少对我而言）判断起来更容易。当然，我现在无法更改。（很多答案已经发布）

“四舍五入”

四舍五入遵循此韵律：

如果它是5或更高，请提高分数
如果它是4或更低，请让它休息

简而言之，如果它是4.7或3.85，则分别将它们四舍五入到5和4。

例子

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]

但是，如果数字为2.3或10.435446，则分别将其舍入为2和10。

“语言支持”

如果选择的语言不支持函数和/或数组，则可以自由使用。如果这样做（即使它将增加您的字符数），则必须使用它们。

code-golf  array-manipulation  integer 
— 初始化
source
1
输出必须是数组，还是数字本身足够（如Pyth答案）？
— 大卫，
2
您可以随意限制为仅使用完整程序或仅使用函数，但是有关于默认值元数据的讨论，可以为您提供一些有用的背景信息，以防它影响您对未来挑战的决策。默认情况下，挑战会同时接受，以允许更多的语言竞争。
— trichoplax
1
输入和输出也有默认值。同样，您不必跟随它们，这只是让您知道。
— trichoplax
3
-1用于任意数组和函数要求，这可以防止没有数组/列表类型或函数的语言相互竞争。
— Mego
4
另外，您应该以字节为单位给参赛者打分，而不是以字符为单位。我们有一个Sandbox，您可以在其中发布帖子之前获得反馈。
— 罗夫霍

Answers:

11

MarioLANG，659 621 591 582 556 543 516 458 418 401 352 308 369字节

舍入是相当昂贵的：/

在线尝试

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

好吧，这比预期的要有趣，这可能不是最佳选择，但我想我要到达那里。

解释时间：

（对于352字节版本）

首先我们得到参数并打印：

;
:

很简单

然后我们转到程序的大部分：除法输入/ 3

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

这是对大脑他妈的部门的稍微修改后的转换

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

需要输入 

n 0 d 0 0

还给你

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

一旦得到除法，就可以用它得到n和n / d的和并打印出来

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

然后我们需要做另一个除法：（2 *（n + n / d））/ 3

所以我们得到（2 *（n + n / d）

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

再把3放回去

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

那时一切都爆发了，马里奥陷入无限循环，永远对越来越大的数字进行除法。

并确定我们需要一种区分第一和第二部门的方法，结果就是，哦，喜悦，我们确实有一种方法

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

基本上我们看x in

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

是0，如果是，则表示我们在第一级

否则我们在第二个分区上，我们只打印该分区的结果，加1然后再次打印

和薄饼一样容易。

— 醚蛙
source
欢迎来到PPCG！
— 暴民埃里克（Erik the Outgolfer）'16年
不符合问题提供的规范（当然，我在发布答案后确实对它进行了更新，但您至少应该更新您的答案以适应新的规范）
— InitializeSahib
做完了 当我们谈论测试用例时，您应该加10以使您在第一手操作中舍入一个数字。
— 以太蛙
9

Emotinomicon 99字节，33个字符

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

说明：

😷                                 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
— 巴林特
source
3
是的，适合非常规语言！：P
— user48538 '16
4

MATL，14个字节

Xot4*3/tE3/tQv

在线尝试

非常简单，v将堆栈连接成一个数组。Xo转换为整数数据类型，此后所有操作均为整数操作。

— 大卫
source
3
规范是返回一个数组，而不仅仅是返回最终结果。
— 价值墨水
3
也大笑那些标记为在2分钟内删除的人：D
— David David
@David D：我认为我不能撤回删除票
— Downgoat
@David对您的回答表示敬意：)
— InitializeSahib，
1
我很确定这也不是一个函数，如果我错了，请纠正我。
— Maltysen '16
4

Cheddar，27个字节

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

$0是随输入变量的。Cheddar并不是一种喜欢打高尔夫球的语言，\\ _（ツ）_ /¯也不是竞争性的，因为Cheddar的输入功能是在挑战之后做出的。

取消高尔夫：

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
]
— 下山羊
source
1
喜极而泣！到此为止！：D
— 科纳·奥布莱恩
3

Java，86 82 84 85个字符

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

d紧跟在整数后面的字母使整数成为a double。

取消高尔夫：

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

如果没有该类（class c{}长度为8个字符），则它将缩减为76个字符：

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

更准确的版本为110个字符（带有枚举的118个字符）-使用floats是因为没有人有足够的空间进行转换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)};}
— 用户8397947
source
我想我应该学习Pyth。
— user8397947
5
+1，因为您知道，Java
— 詹姆斯
1
@dorukayhan Weird，当我尝试在Eclipse中运行它时似乎出现错误，它无法从double转换为int。我看看是否能找出明天的问题。
— 罗夫霍
1
我刚刚修复了代码
— user8397947 '16
1
我看到了，但是对于像8或10这样的输入，它没有给出正确的结果。第一次加法不能像I + (I / 3)使用整数除法那样正常工作，这意味着分数被舍弃，因此结果无法正确舍入。
— Frozn
3

Java，56 80字节

正如某些用户指出的那样，此解决方案（与Java中的其他解决方案一样）不能正确舍入数据。所以现在我要提出更长的解决方案，它应该返回正确的结果

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

或60个字节的lamda版本

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

高尔夫版

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

和无高尔夫球

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

或36个字节定义为lambda

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

— 用户902383
source
没有问题所要求的舍入。
— Marv
1
正如@Marv所提到的，该问题无法正确运行，例如，对于输入8，预期结果为[8,11,7,8]，但预期结果为[8,10,7,8]
— Frozn
为什么要投票？我修复了它，现在可以正常工作了吗？
— user902383 '16
修复问题后，抱歉。Downvote现在已锁定，因此除非您对答案做出一些更改（任何微不足道的更改就足够了），否则我无法删除它
— edc65 '16
@ edc65确定，完成
— user902383 '16
2

Java，64字节

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

笔记

  • 它具有所需的舍入内置功能，不确定与@ user902383的解决方案混合使用时是否可以缩短它的执行时间。

不打高尔夫球

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

i = 9的输出

[9, 12, 8, 9]
— 马尔夫
source
1
+1。
— 库兹
与user902383的解决方案相同，此操作无法正常工作，例如，对于8个预期的[8,11,7,8]，但对于[6,8,5,6]来说为[8,10,7,8]但是是[6,8,6,7]
— Frozn
3
@冻结此解决方案也无法正常工作，对于您给出的测试用例，其返回的结果与我的旧解决方案相同ideone.com/LVK8FU
— user902383
2

暂存，33个字节

脚本
要求输入，设置a输入圆，套b及c各自的变化，然后说，所有四个数字，用逗号分隔。

— Weatherman115
source
2

Java 8 lambda，109 81 79 75个字符

因为...您知道...甚至Java都可以打高尔夫...

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

Lambda不在课堂上：

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

我假设我允许使用long，因为它们也是整数类型。可悲的是，人们需要正确舍入整数，因此“短”强制转换不起作用。通过使用long，我们不需要将舍入结果转换回int。

更新资料

使用漂亮的小数+ 0.5并进行后续转换，我们保留正确的舍入并节省2个字符！

同样，此技巧不需要再使用long了，因此我们可以切换回ints方式，将更多的4个字符剃掉。

— 弗罗兹
source
欢迎来到PPCG！
— 暴民埃里克
谢谢：）我现在在这里关注了一段时间，我想这可能是一个我可以参与的问题，尽管答案比我预期的要长。
— Frozn
我将“ +1”，希望您添加强制性的“因为……您知道……Java！”
— 奥利维尔·杜拉克
@Frozn我不确定是否可以删除-5字节a->{的最后一个}字节。
— 暴民埃里克
@OlivierDulac尚未:)
— Outgolfer的埃里克
1

Mathematica-21个字节

刚从我的兄弟RPi那里获得了Mathematica，所以尝试一下它很有趣，还有比PPCG挑战更好的方法。

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

定义一个匿名函数。像这样尝试一下：

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

In[27]:= x[9]                                                                 

Out[27]= {9, 12, 8, 9}
— 马尔蒂森
source
结果是整数还是分数？
— 大卫，
@David整数，除非结果是非整数，否则为小数。
— Maltysen '16
1

Lua，52个字节

该程序通过命令行参数获取数字并返回相应的数组。lua中的程序在技术上是函数，因为解释器将始终将它们封装在一个函数中。这也是您在其他文件中“调用”代码时使用的机制（基本上使用loadfile/ dofile）。

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

其实是21个位元组

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

该程序声明一个函数，该函数对顶部堆栈的值执行所需的操作。

在线尝试！（额外的.评估功能并打印结果）

说明：

`;;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)
— 梅果
source
1

Mathcad，[tbd]字节

在此处输入图片说明

Mathcad代码高尔夫球字节的等效性尚未确定。以键盘数量为大致等效值，解决方案约为40个字节。

— 斯图尔特·布拉夫
source
1

Pyke，11个字节

D}[}3/bD)[h

在这里尝试！

            - 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
— 蓝色
source
1

Javascript，50个字节

我将Java解决方案转换为JavaScript并略去了一下。

var r=Math.round,g=a=>[a,r(a+a/3),a=r(a*8/9),++a]
— 用户902383
source
1

的C ++ 0x - 95 102 185 189 109 129个字符

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;}
  • 这要求cmath标头起作用。

脱胶

#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
}
— 初始化
source
2
不是C ++专家，但是您可以通过重新使用数组中已有的计算值来缩短它。另外，您也许可以删除）和{之间的空白，不知道C ++有多严格。
— Frozn
在当前版本中，最后两个是否正确？因为我刚刚看到您计算的p+(p/3)*(2/3)是- p+(2*p/9)而不是(p+(p/3))*(2/3)
— Frozn
原来这是我的错误。我在上次迭代中使用-1而不是+1：P
— InitializeSahib
0

Erlang，80个字节

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

要运行，另存为f.erl，然后编译并调用该函数。它将返回一个整数列表：

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>

请注意，如果您在ASCII值范围内，则Erlang会自动将int转换为ASCII字符，因为Erlang没有char类型。用100调用该函数可以使可读性更好[100,133,88,89]。

取消高尔夫：

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

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

Erlang，46个字节

受@ fxk8y启发的答案（我无法对他的答案发表评论）

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

您还可以通过以下方式查看结果：

2> io:fwrite("~w~n", [F(9)]).                         
[9,12,8,9]
ok
— 多米尼克·帕拉克（Dominik Pawlak）
source
0

Pyth，20个字节

m.RdZ[Jc*4Q3Kc*2J3hK

说明：

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

在这里测试

— RK。
source
0

Jolf，17个字节

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

定义一个函数Ώ。它隐式地接受输入，因此它也可以作为一个完整程序加倍。在这里尝试！

— 科纳·奥布莱恩
source
Jolf正在逐渐确认ESMin？：P
— Downgoat
@Upgoat ey是希腊文。又是午夜。：P
— Conor O'Brien
> _>哦。非常抱歉，如果我叫醒您> _> _> _>
— Downgoat
@Upgoat还没睡着；）
— Conor O'Brien
：| idk如果我确实借了好事叫醒您，或者您仍然醒着了不好的事情
— Downgoat
0

Mathematica，51个字节

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

符合当前（在发布时）发布版本的匿名函数，这意味着在每个步骤都进行舍入。

FoldList是编程中的典型操作。将其作为调用FoldList[f, list]，并将双参数函数f重复应用于结果（或第一次迭代中列表的第一个元素），并将列表的下一个元素作为第二个参数。

Ungolfed： #2 @ # &是匿名函数，将其第二个参数应用于第一个参数。因此，of的list参数FoldList由要应用于输入的连续函数组成。

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

因为输入是整数并且除以3，所以永远不会有像4.5这样的结果，因此，当最后一位为a时，就不必担心舍入规则5：它始终总是更接近一个整数或另一个整数。

— 拉姆尼普
source
0

CJam，21个字节

qi__3d/+mo_2d3/*i_)]`

欢迎反馈

说明

  • qi__ -将输入读取为整数并重复两次
  • 3D/+mo -将输入的一个实例除以3，然后将其添加到第二个实例中以使y
  • _2d3/*i -复制y，然后乘以.6
  • _）]`-复制，递增，包装在数组中，打印为数组（由于`运算符:(），因此不在代码中

编辑：忘记使前三个加倍，所以程序被打破了。固定。

— The_Basset_Hound
source
0

公理，59字节

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

测试

(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
— 罗斯鲁普
source
0

PHP，67字节

function f($x){return [$x,$y=round($x*4/3),$z=round($y*2/3),$z+1];}
— jstnthms
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.