三角计数的二进制图像

18

我的挑战往往有点艰巨和缺乏吸引力。所以这里有些简单而有趣的事情。

阿尔金序列

Alcuin的序列 A(n)是通过计算三角形来定义的。A(n)是具有整数边和周长的三角形的数量n。这个顺序被称为约克·阿尔库恩。

此序列的前几个元素从以下开始n = 0：

0, 0, 0, 1, 0, 1, 1, 2, 1, 3, 2, 4, 3, 5, 4, 7, 5, 8, 7, 10, 8, ...

举例来说A(9) = 3，因为整边和周边唯一的三角形9是1 - 4 - 4，3 - 3 - 3和2 - 3 - 4。您可以在下面看到3个有效三角形。

具有整数边和周长的三角形9

此序列中有一些非常有趣的模式。例如A(2*k) = A(2*k - 3)。

有关更多信息，请参阅OEIS上的A005044。

挑战

但是您面临的挑战是这些数字的二进制表示形式。如果我们将每个序列号转换为二进制表示形式，然后将它们放在列向量中并排列起来，则会创建一个非常有趣的二进制图片。

在下图中，您可以看到序列号的二进制表示形式A(0), A(1), ..., A(149)。在第一列中，您可以看到的二进制表示形式A(1)，在第二列中，您可以看到的表示形式A(1)，依此类推。

Alcuin序列从n = 0到149的二进制表示

您可以在这张图片中看到某种重复的图案。如果您查看带有序列号的图像，它甚至看起来像分形A(600), A(601), ..., A(899)。

Alcuin序列从n = 600到899的二进制表示

您的工作是生成这样的图像。您的函数，您的脚本将接收两个整数0 <= m < n，并且必须生成Alcuin序列的二进制图像A(m), A(m+1), A(m+2), ..., A(n-2), A(n-1)。因此，输入0, 150生成第一张图片，输入生成600, 900第二张图片。

您可以使用任何所需的流行图形格式。假设每种可以使用image.online-convert.com转换为png的格式。或者，您可以在屏幕上显示图像。不允许前导白行！

这是代码高尔夫球。因此，最短的代码（以字节为单位）获胜。

code-golf  graphical-output  sequence  binary 
— 雅库比
source
3
嗯，直到我接触到创建二进制映像的部分之前，我都对完成这一挑战很感兴趣。这似乎是一个多余的步骤。我不想学习使用Python创建图像的库，而且我希望如果这样做的话，打高尔夫球的东西就不会太多了。
— xnor
1
@xnor：然后使用一些简单的图像格式，例如PBM。
— 2015年
难道white=1 and black=0或周围的其他方式？
— Maltysen
@Maltysen white=0 and black=1。换一种方式。A(0)产生一个白色的列，A(9)=3产生一个底部有2个黑色像素的白色列。
— 雅库布2015年
1
您确定第一张图片正确吗？它0,0,0,1,0,2而列表中的问题开始说0,0,0,1,0,1。
— Maltysen

Answers:

2

J（52 45（代码页437））

这将被允许（我认为）

[:|:' █'{~[:#:[:([:<.48%~*:+24+6*]*2|])(}.i.)

十六进制转储

（没什么特别的实在，黑方是DB 16或219 10的代码页437）

0000: 5b 3a 7c 3a 27 20 db 27 7b 7e 5b 3a 23 3a 5b 3a   [:|:' .'{~[:#:[:
0010: 28 5b 3a 3c 2e 34 38 25 7e 2a 3a 2b 32 34 2b 36   ([:<.48%~*:+24+6
0020: 2a 5d 2a 32 7c 5d 29 28 7d 2e 69 2e 29            *]*2|])(}.i.)

用法

输出如下（代码标记通过在行之间添加空格将其弄乱了）：

   A=:[:|:' █'{~[:#:[:([:<.48%~*:+24+6*]*2|])(}.i.)
   0 A 100
                                                                             █ █████████████████████                                          
                                                     █ ██████████████████████ █              █ █████                          
                                     █ ██████████████ █          █ ██████████ █      █ ██████ █                   
                         █ ██████████ █      █ ██████ █    █ ████ █    █ ████ █  █ ██ █  █ ██ █  █ █  
                 █ ██████ █    █ ████ █  █ ██ █  █ ██ █  █  █  █  █  █  ██ ██ ██  ██  ██  ██  ██  ██
           █ ████ █  █ ██ █  █  █  █  ██  ██  ██  ██  ██  █  █  █  █ ██ █  █ ████ █                               
       █ ██ █  █  ██  ██  ██  █  █ ██ █                █ ██ █  █  ██  ██  ██  █  █ ██ █                                   
   █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █    
   2000 A 2100
████████████████████████████████████████████████████████████████████████████████████████████████████

████████████████████████████████████████████████████████████████████████████████████████████████████
                                                                             █ █████████████████████
                             █ ██████████████████████████████████████████████ █
     █ ██████████████████████ █                      █ ██████████████████████ █
█████ █          █ ██████████ █          █ ██████████ █          █ ██████████ █          █ █████████
 ████ █    █ ████ █    █ ████ █    █ ████ █    █ ████ █    █ ████ █    █ ████ █    █ ████ █    █ ███
█  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █
██  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █ ██ ██ █
 █ ██ ██ ██ ██ ██ █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  ██ ██ ██ ██ ██  █  █
  ██ ██ ██  █  █  ██ ██ ██  █  █  █  █  █  █  █  █  █  █  █  █  █  █ ██ ██ ██ █  █  █  █ ██ █  █ ██
 █ ██ █  █ ██ █  █ ██ █  █ ██ █  █  █  █  █  █  █  █  █  █  ██ ██ ██  █  █  ██  ██ ██ ██  ██  ██  ██
  ██  ██  ██  ██  ██  ██  ██  ██ ██ ██  █  █  █  █  █  █ ██ █  █ ██ █  █ ████ █    █ ██████ █
█ █                        █ ████ █  █ ██ █  █  █  █  ██  ██  ██  ██  ██  █  █  █  █ ██ █  █ ████ █
 █ ██ █                █ ██ █  █  ██  ██  ██  █  █ ██ █                █ ██ █  █  ██  ██  ██  █  █ █
██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██

在标准的J控制台中，行之间没有间距，因此我将规则称为“或者，您可以在屏幕上显示图像”。（没有人说此图像必须在内部表示为明智的图像格式）

编辑：Jconsole（与JQT相对）默认使用代码页437，并且从字符串中使用矩形时，DOES会正确渲染矩形。

— ɐɔıʇǝɥʇuʎs
source
9

Mathematica，126 122 121 89字节

Image[1-Thread@IntegerDigits[l=Round[(#+3#~Mod~2)^2/48]&/@Range@##,2,⌈2~Log~Max@l⌉]]&

这定义了一个以两个整数为参数并在屏幕上显示图像的未命名函数。它将每个正方形绘制为单个像素，但是如果您愿意，也可以放大。

我现在使用的是OEIS文章中给出的明确公式（Mathematica部分中的第一个公式，感谢David Carraher指出了这一点）。现在它也非常快。

这是带有一些注释的缩进代码：

Image[1-Thread@IntegerDigits[   (* 3. Convert each number to padded binary, transpose
                                      invert colours, and render as Image. *)
    l = Round[
      (#+3#~Mod~2)^2/48
    ] & /@ Range@##,            (* 1. Turn input into a range and get the Alcuin
                                      number for each element. *)
    2,
    ⌈2~Log~Max@l⌉               (* 2. Determine the maximum number of binary digits. *)
]] &

这是输出0, 600：

在此处输入图片说明

— 马丁·恩德
source
几乎相同的大小（因为必须Image[1 - Thread@IntegerDigits[ l = Round[If[EvenQ[#], #^2, (# + 3)^2]/48] & /@ Range@##, 2, \[LeftCeiling]2~Log~Max@l\[RightCeiling]]] &
— 清楚
@DavidCarraher谢谢，我进一步打了高尔夫球。：）（应该检查OEIS文章。）
— Martin Ender
8

CJam（56 55 53个字符）/ GolfScript（64个字符）

CJam：

"P1"q~,>{_1&3*+_*24+48/}%_:e>2b,\2_$#f+2fbz(,@@:~~]N*

GolfScript：

"P1"\~,>{.1&3*+.*24+48/}%.$-1=2base,\{2.$?+2base}%zip(,@@{~}/]n*

两者都产生NetPBM格式的输出，并且它们实质上是彼此的端口。

解剖

CJam                 GolfScript           Explanation

"P1"                 "P1"\                NetPBM header
q~,>                 ~,>                  Create array [m .. n-1]
{_1&3*+_*24+48/}%    {.1&3*+.*24+48/}%    Map the sequence calculation
_:e>2b,\             .$-1=2base,\         Compute image height H as highest bit
                                          in largest number in sequence
2_$#f+2fb            {2.$?+2base}%        Map sequence to bits, ensuring that
                                          each gives H bits by adding 2^H
z(,@@                zip(,@@              Transpose and pull off dummy row to use
                                          its length as the "width" in the header
:~~                  {~}/                 Flatten double array and dump on stack
]N*                  ]n*                  Separate everything with whitespace

感谢Optimizer for CJam 56-> 53。

— 彼得·泰勒
source
1
任何原因，您开头都没有“ P1”，因此可以通过避免“？”来节省1个字节。
— Optimizer
@Optimizer，也曾经在GS中思考过。
— 彼得·泰勒
不完全是：高度需要出现在输出中。但是，缩短地图仍然可以节省很多钱。
— 彼得·泰勒
51：'PoXq~{_1&3*+_*24+48/}%>_:e>2b,\2_$#f+2fbz(,@@]e_N*
— 优化器
5

腐霉-101 60 59

输出一个.pbm。可能会打更多的高尔夫球。

Km.B/++24*dd**6%d2d48rvzQJCm+*\0-eSmlkKlddK"P1"lhJlJjbmjbdJ

高度虚张声势，因为我将翻译成Pyth。

下一个解释。现在来看等效的Python代码。

它使用OEIS算法计算序列，然后将其转换为二进制，填充数字，进行矩阵旋转并将其格式化为pbm图像。由于我没有使用蛮力，因此速度非常快。

         K=
 m          rvzQ      Map from eval input to eval input
  .B                  Binary rep
   /      48          Divided by 48
    ++                Triple sum      
     24               Of 24,
     *dd              Square of d
     **               Triple product
      6               6
      %d2             Modulo d%2
      d               Var d
J                     Set J=
 C                    Matrix rotation from columns of row to rows of columns
  m           K       Map K (This does padding)
   +                  String concat
    *                 String repeat
     \0               "0"
     -     ld         Subtract the length of the column from
      eS              The max
       mlkK           Of all the column lengths
    d                 The column
"P1"                  Print header "P1"
l                     Length of
 hJ                   First row
lJ                    Number of columns
jb                    Join by linebreaks
 m  J                 Map on to J
  jb                  Joined columns by linb
   d

这是600,900示例：

600-900

在这里在线尝试。

— 马尔蒂森
source
4

的R - 127 125

我不确定这是否完全符合规则。它不会将图像输出到文件，但是会创建栅格并将其打印到输出设备。

我在这里找到了与马丁相同的公式。

它使用一个未命名的函数。

require(raster);function(m,n)plot(raster(mapply(function(n)rev(as.integer(intToBits(round((n+n%%2*3)^2/48)))),m:n),0,n,0,32))

运行如下

require(raster);(function(m,n)plot(raster(mapply(function(n)rev(as.integer(intToBits(round((n+n%%2*3)^2/48)))),m:n),0,n,0,32)))(0,600)

产生以下情节

在此处输入图片说明

— 米奇
source
您可以通过不附加raster到名称空间来丢弃7个字节，因为这raster()是该包中唯一的特定内容。取而代之raster::raster(...)。
— Alex A.
@AlexA。谢谢，将进行编辑
— MickyT 2015年
@AlexA。不幸的是，我只是尝试了一下，但对我来说却出错了。我怀疑这是因为栅格也需要sp。我将查看是否可以跟踪。
— MickyT 2015年
笨蛋 抱歉使您误入歧途。
— Alex A.
3

蟒2 + PIL，255 184

我的第一个版本使用PIL来显示图像：

i,R,B=input,range,lambda x:bin((x*x+6*x*(x%2)+24)/48)[2:]
def F(k,v):i.load()[k]=v
a,b=i(),i();h=len(B(b));from PIL import Image;i=Image.new('P',(b-a,h))
[F((x-a,y),int(B(x).zfill(h)[y])) for x in R(a,b) for y in R(h)]
i.putpalette([255]*3+[0]*3)
i.show()

新版本仅在stdout上生成b＆w PPM图像：

i,R,B=input,range,lambda x:bin((x*x+6*x*(x%2)+24)/48)[2:]
def p(s):print s
a,b=i(),i();h=len(B(b));p('P1 %i %i'%(b-a,h))
[p(' '.join([B(x).zfill(h)[y] for x in R(a,b)])) for y in R(h)]
— 节食者
source
PPM版本会保存一些字符：之前不需要空格for。您可以x%2通过将顺序更改为来避免重复x%2*...。不要将print定义为一个函数，而只是使用两个嵌套for循环，print ...,避免使用换行符，并使用空格print来开始新的一行，这要短得多。一个小窍门来强制使用二进制扩展到具有长度h不zfill就是添加2**h，然后提取最后的h数字。
— xnor 2015年
2

JAVASCRIPT-291

码：

(function(a,b,c){c.width=b;t=c.getContext('2d');t.strokeStyle='black';for(i=a;i<=b;i++){g=(Math.floor(((i*i)+6*i*(i%2)+24)/48)>>>0).toString(2);l=g.length;for(j=0;j<l;j++){if(g[l-1-j]=='1'){t.rect(i-a,j,1,1);t.fill();}}}document.body.appendChild(c);})(0,300,document.createElement('canvas'))

说明：

(function (a, b, c) {
    //setting canvas width
    c.width = b;
    //get context 2d of canvas
    t = c.getContext('2d');
    //setting storke style.
    t.strokeStyle = 'black';
    //looping from a to b
    for (i = a; i <= b; i++) {
        //calculating A(i) and converting it to a binary string
        g = (Math.floor(((i * i) + 6 * i * (i % 2) + 24) / 48) >>> 0).toString(2);
        //looping through that string
        for (j = 0; j < g.length; j++) {
            //since canvas is upside down and the first digit is actually the last digit:
            if (g[g.length - 1 - j] == '1') {
                //we create the 1 by 1 rect
                t.rect(i - a, j, 1, 1);
                //we draw the rect
                t.fill();
            }
        }
    }
    //we append everything to the body
    document.body.appendChild(c);
    //parameters are put here
})(0, 300, document.createElement('canvas'))

结果：

是的，结果是上下颠倒的，但这是因为0,0a js canvas在左上方。：3 Alquin的序列

演示：

jsfiddle上的演示

— kemicofa支持Monica
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.