将字符串映射到希尔伯特曲线

27

让我们将一些字符串映射到2d空间（分形样式）。您的任务是计算希尔伯特曲线并沿其放置一个字符串。

希尔伯特曲线，迭代1至8

任务

任务是获取单行输入字符串，并沿希尔伯特曲线将其布局到足以容纳它但不更大的位置。尝试使字节数尽可能少；毕竟这是 代码高尔夫！

条件

  • 空格要用空格填充，但在行尾不需要填充。
  • 该行的开始应在左上角，结束应在左下角。
  • 您可以创建一个程序或函数。
  • 可能会出现一些新的测试用例，所以不要硬编码任何东西！

奖金

注意：奖金堆栈如下：-50% & -20% on 100B= -20% on 50B或-50% on 80B= 40B。

  • -50％如果输入是多行字符串，请反向进行此过程以创建原始输入。奖金测试用例：仅使用现有的（包括奖金测试用例！）
  • -20％如果从输出中去除所有不必要的空格（例如，在一行的末尾）。
  • -5％如果您不污染全局名称空间（您知道我的意思！）

测试用例

abcdefghijklmn

adef
bchg
 nij
 mlk


The quick brown fox jumps over the lazy dog.

Thn f ju
 ewooxpm
qckr rs 
ui btevo
    hlaz
    e  y
      do
      .g

对于空白删除奖金：

No  hitespac  her 

Noher

hesc
itpa

排行榜

显示代码段

为确保您的答案显示出来，请使用以下Markdown模板以标题开头。

# Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，则可以将旧分数保留在标题中，方法是将它们打掉。例如：

# Ruby, <s>104</s> <s>101</s> 96 bytes

如果要在标头中包含多个数字（例如，因为您的分数是两个文件的总和，或者您想单独列出解释器标志罚分），请确保实际分数是标头中的最后一个数字：

# Perl, 43 + 2 (-p flag) = 45 bytes

您还可以将语言名称设置为链接，然后该链接将显示在页首横幅代码段中：

# [><>](http://esolangs.org/wiki/Fish), 121 bytes
code-golf  string  fractal 
— wizzwizz4
source
如果有人可以制作更多的测试用例，那将不胜感激。
— wizzwizz4 2015年
因此，特征应该由曲线的顶点表示吗？
— 瑕疵的
No..hitespac..her.点是空格的地方将是奖金的更好测试案例。（当前，测试用例缺少尾随的内容.）
— Martin Ender
如果您采用的是L系统方法，则可能还需要尝试http：// codegolf / questions / 48697 / ascii-l-system-renderer。它可以帮助您寻找答案。
— wizzwizz4 2015年

Answers:

7

CJam，119 117 113 112 109 * 0.5 * 0.8 = 43.6字节

感谢Dennis节省了1个字节。

这是一个开始...

{+e`W<e~}:F;q_N-,4mLm]0aa{4\#4e!1=f*\:G[zGGW%zW%G].ff+2/{~.+~}%}@:L/\_N&{N/]z:z:~$1f>sS}{4L#' e]f{f=SF}N*N}?F

测试正向变换。测试逆变换。

我敢肯定，有一种较短的方法可以生成曲线...

说明

首先，我定义了一个从数组末尾修剪某些元素的函数，因为我需要在多个地方进行修剪。它期望数组和元素（在单独的数组内）位于堆栈的顶部。

{
  +  e# Append the element to the array.
  e` e# Run-length encode.
  W< e# Discard last run.
  e~ e# Run-length decode.
}:F; e# Store in F and discard.

现在，大多数代码确定所需的希尔伯特曲线的大小，并将其构造为2D数组，其中元素是沿曲线的索引。我基于以下观察来构造它：

考虑2x2希尔伯特曲线：

01
32

4x4希尔伯特曲线为：

0345
1276
ed89
fcba

如果我们从每个象限中减去最小值（并为了视觉清晰将它们分开一点），我们将得到：

03 01
12 32

21 01
30 32

此模式适用于任何大小。这意味着我们可以通过使用四个象限从当前水平构造下一个水平：a）当前水平的转置，b）当前水平本身，c）沿着反对角线的转置，d）再次当前级别本身。然后，将它们分别偏移为当前级别大小的0、1、3、2倍。

q           e# Read input.
_N-         e# Make a copy and remove all linefeeds.
,4mLm]      e# Take that string's length's logarithm with base 4, rounded up.
            e# This is the Hilbert curve level we need.
0aa         e# Push [[0]] as the level-0 Hilbert curve.
{           e# Store the Hilbert curve level in L. Then for each i from 0 to L-1...
  4\#       e#   Compute 4^i. This is the offset of the four quadrants.
  4e!1=     e#   Get [0 1 3 2] as the second permutation returned by 4e!.
  f*        e#   Multiply each of them by the offset.
  \:G       e#   Swap with the Hilbert curve so far and call it G.
  [         e#   Create an array with...
    z       e#     The transpose of G.
    G       e#     G itself.
    GW%zW%  e#     The anti-diagonal transpose of G.
    G       e#     G itself.
  ]
  .ff+      e#   Add the appropriate offsets to the indices in each of the four quadrants.
  2/        e# Split into a 2x2 grid.
  {         e# Map this onto each pair of quadrants...
    ~       e#   Dump both quadrants on the stack.
    .+      e#   Concatenate them line by line.
    ~       e#   Dump the lines on the stack.
  }%        e# Since this is a map, the lines will automatically be collected in an array.
}@:L/

最后，我们使用索引的希尔伯特曲线将适当的变换应用于输入：

\_        e# Swap the curve with the input and make another copy.
N&{       e# If the input contains linefeeds, execute the first block, else the second...
  N/      e#   Split the input into lines. The stack now has a grid of indices and a grid
          e#   of characters.
  ]z:z:~  e#   This is some weird transposition magic which zips up the indices with the
          e#   corresponding characters from both grids, and finally flattens the grid
          e#   into a linear list of index/character pairs. Those cells that don't have
          e#   characters due to trimmed whitespace in the input will be turned into
          e#   arrays containing only an index.
  $       e#   Sort the pairs (which sorts them by indices).
  1f>     e#   Discard the indices.
  s       e#   Flatten the result into a single string.
  S       e#   Leave a space on the stack to be trim trailing spaces later.
}{        e# or...
  4L#     e#   Compute the size of the Hilbert curve.
  ' e]    e#   Pad the input to that size with spaces.
  f{      e#   Map this block over lines of the curve, passing the padding input as an
          e#   additional parameter...
    f=    e#     For each index in the current line, select the appropriate character
          e#     from the padded input.
    SF    e#     Trim spaces from the end of the line.
  }
  N*      e#   Join the lines with linefeed characters.
  N       e#   Leave a linefeed on the stack to be trim trailing linefeeds later.
}?
F         e# We left either a space or a linefeed on stack... trim that character from
          e# the end of the string.
— 马丁·恩德
source
3

Python 3中，467 434 423 457 451 426 386 374 342 291 304 * 80％* 95％= 231.04字节

这种工作方式是，我使用Lindenmayer系统制作希尔伯特曲线，并沿着一串字符串遵循左，右和前指令。不过，可能有很多方法可以更好地打高尔夫球。特别是在条件和字符串数组中。（我确实尝试过，[" "*p for i in range(p)]但是字符串不支持项目分配（显然）。如果我可以使它起作用，那么我也可以摆脱联接）

编辑：多亏了丹尼斯（Dennis），使一些条件护发运动了。然后我打高尔夫球。并且无字节更改，因为与上述示例相比，结果是转置的。

编辑：实施了空白剥离奖金。

编辑：修复了我的空格分隔代码中六个以上字节的错误

编辑：由于此答案不会污染全局名称空间，所以根据wizzwizz4 这里，我将获得5％的奖励。

编辑：更改了如何g增加和减少。现在使用eval()和str.translate。

编辑：此答案现在是程序而不是函数。

编辑：修复了以前高尔夫中的一些错误。

s=input();m=(len(bin(len(s)-1))-1)//2;t=eval("[' ']*2**m,"*2**m);t[0][0],*s=s;x=y=g=0;b="A";exec("b=b.translate({65:'-BF+AFA+FB-',66:'+AF-BFB-FA+'});"*m)
while s:
 c,*b=b;g+=(c<"-")-(c=="-")
 if"B"<c:x,y=[[x+1-g%4,y],[x,y+g%4-2]][g%2];t[x][y],*s=s
print("\n".join(''.join(i).rstrip()for i in t).rstrip())

取消高尔夫：

# hilbert(it) is now implemented in the code with exec("b=b.translate")

def hilbert(it):
    s="A"
    n=""
    for i in range(it):
        for c in s:
            if c == "A":
                n += "-BF+AFA+FB-"
            elif c == "B":
                n += "+AF-BFB-FA+"
            else:
                n += c
        s=n;n=""
    return s

def string_to_hilbert(string):
    length = len(string)
    it = (len(bin(length-1))-1)//2
    hil = hilbert(it)
    pow_2 = 2**it
    # we use eval("[' ']*pow_2,"*pow_2) in the code, but the following is equivalent
    output = [[" "for j in range(pow_2)] for i in range(pow_2)]
    output[0][0] = string[0]
    x = 0
    y = 0
    heading = 0
    while string: # while there are still characters in string
        char, *hil = hil
        if char == "-": heading = heading - 1
        elif char == "+": heading = heading + 1
        elif char == "F":
            if heading % 4 == 3: y += 1
            elif heading % 4 == 2: x -= 1
            elif heading % 4 == 1: y -= 1
            else: x += 1
            output[x][y], *string = string
    array = [''.join(i).rstrip()for i in output]
    array = "\n".join(array).rstrip()
    print(array)
    return
— 神探洛克9
source
对5％的奖金感到好奇。变量在Python中是自动局部的吗？
— edc65 '16
@ edc65我在这里问挑战挑战者一个类似的问题：chat.stackexchange.com/transcript/240?m=28529277#28529277。希望能有所帮助。如果没有，我们可以继续聊天中的讨论。
— Sherlock
2

红宝石，358 356 344 322 319 * 80％* 95％= 242.44字节

这是我的Python代码转译为Ruby。我应该在Ruby中写更多答案。打高尔夫球是一种体面的语言。

编辑：我忘记了在这个问题中不需要命名函数。

编辑：由于此答案不会污染全局名称空间，所以根据wizzwizz4 这里，我将获得5％的奖励。

->s{l=s.size;m=((l-1).bit_length+1)/2;x=2**m;t=(1..x).map{[" "]*x};t[0][0]=s[0];x=y=g=z=0;d=1;b=?A;m.times{b=b.split("").map{|c|c==?A?"-BF+AFA+FB-":c==?B?"+AF-BFB-FA+":c}.join("")};(c=b[z];z+=1;g+=c<?-?1:c==?-?-1:0;(g%2>0?y+=g%4-2:x+=1-g%4;t[x][y]=s[d];d+=1)if c>?B)while d<l;puts (t.map{|i|(i*'').rstrip}*"\n").rstrip}

取消高尔夫：

def map_string(string)
  len = string.size
  m = ((len-1).bit_length+1)/2
  pow = 2**m
  output = (1..pow).map{[" "]*pow}
  output[0][0] = s[0]
  x = y = heading = char_index = 0
  chars_in_output = 1
  b = ?A
  m.times do |j|
    a = b.split("").map do |char|
      if char == "A"
        "-BF+AFA+FB-"
      else if char == "B"
        "+AF-BFB-FA+"
      else
        char
      end
    end
    b = a.join("")
  end
  while chars_in_output < len
    char = b[char_index]
    char_index += 1
    if char == "-"
      heading += -1
    else if char == "+"
      heading += 1
    else if char == "F"
      if heading % 2 == 0
        y += heading % 4 - 2
      else
        x += 1 - heading % 4
      end
    end
    output[x][y] = string[char_index]
    char_index += 1
  end
  return (output.map{|i|(i*'').rstrip}*"\n").rstrip
— 神探洛克9
source
此代码是否在代码许可下双重许可？我想制作一个在GPL下发布的衍生作品（尽管任何与GPL兼容的许可证都可以使用该作品）。它当前在CC BY-SA 3.0下发布。
— wizzwizz4
@ wizzwizz4聊天的位置：chat.stackexchange.com/rooms/56405/...
— Sherlock9
1

JavaScript（ES6），227-20％：181.6字节

m=>{for(n=1<<((33-Math.clz32(m.length-1))/2),t='',y=0;y<n;y++,t+=`
`)for(x=0;x<n;x++,t+=m[h]||' ')for(u=y,v=x,h=0,s=n;s>>=1;q||(p&&(u=s+~u,v=s+~v),[u,v]=[v,u]))h+=s*s*(3*!!(p=u&s)^!!(q=v&s));return t.replace(/ +$/mg,'').trim()}

试图获得5％的奖金

m=>{for(var n=1<<((33-Math.clz32(m.length-1))/2),t='',x,y=0;y<n;y++,t+=`
`)for(x=0;x<n;x++,t+=m[h]||' ')for(var p,q,u=y,v=x,h=0,s=n;s>>=1;q||(p&&(u=s+~u,v=s+~v),[u,v]=[v,u]))h+=s*s*(3*!!(p=u&s)^!!(q=v&s));return t.replace(/ +$/mg,'').trim()}

241 * 0.8 * 0.95：183.16大

少打高尔夫球

m=>
{
  // calc the size of the bounding square, clz32 is a bit shorter than ceil(log2()
  n = 1<<( (33-Math.clz32(m.length-1)) / 2); 
  t = '';
  for(y = 0; y < n; y++) 
  {
    for(x = 0 ; x < n; x++)
    {
      // for each position x,y inside the square
      // get the index postion in the hilbert curve
      // see https://en.wikipedia.org/wiki/Hilbert_curve (convert x,y to d)
      for(u=y, v=x, h=0, s=n; s >>= 1; )
      {
        h += s*s*(3 * !!(p = u & s) ^ !!(q = v & s));
        q || (p && (u = s+~u, v = s+~v),[u,v]=[v,u])
      }
      // add char at given index to output  
      t += m[h]||' '; // blank if beyond the length of m
    }
    t += '\n'; // add newline add end line
  }
  return t.replace(/ +$/mg,'').trim() // to get the 20% bonus
}

测试

F=m=>{for(n=1<<((33-Math.clz32(m.length-1))/2),t='',y=0;y<n;y++,t+=`
`)for(x=0;x<n;x++,t+=m[h]||' ')for(u=y,v=x,h=0,s=n;s>>=1;q||(p&&(u=s+~u,v=s+~v),[u,v]=[v,u]))h+=s*s*(3*!!(p=u&s)^!!(q=v&s));return t.replace(/ +$/mg,'').trim()}

function Test() { O.textContent = F(I.value) }

Test()
#I { width: 90% }
#O { border: 1px solid #ccc}
<input id=I oninput='Test()' value='The quick brown fox jumps over the lazy dog.'>
<pre id=O></pre>
展开摘要

— edc65
source
值得补充吗 var s以获得5％的奖金是否？
— wizzwizz4 2016年
var s,x,y,u,v,t,p,q,n,h 不，它不值得@ wizzwizz4
— edc65 '16
你可以放 var第一次使用之前...哦，这甚至更糟。
— wizzwizz4 2016年
@ wizzwizz4总而言之，也许您有一个观点……我正在尝试……不。太糟了
— edc65 '16
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.