建造稳定的砖墙


39

砖墙是由水平的1乘n的砖砌成几排而成的矩形。这是一堵高4宽8的墙,右侧显示了砖块大小。

[______][______]    4 4
[__][____][__][]    2 3 2 1
[][______][____]    1 4 3
[____][______][]    3 4 1

这堵墙是不稳定的,因为它有断层,即砖之间的两个垂直裂缝排列的位置,如下图所示,周围的砖中有孔。

[______][______]    
[__][____)(__][]
[][______)(____]
[____][______][]

但是,与右边的1号砖块相邻的裂缝并不构成断层,因为它们被一行隔开。

编写代码,查找并显示由指定大小的砖块构成的稳定墙。最少的字节数获胜。

输入值

砖块大小(正数)和高度至少为2的非空列表。可以根据需要对该列表进行排序。您也可以选择各种大小的砖块。

输出量

使用所有给定砖块的所需高度的稳定矩形墙的图片。打印它或将其作为带换行符的字符串返回。

绘制大小为n的2n个字符的砖,下划线用方括号括起来。

1: []
2: [__]
3: [____]
4: [______]
...

保证输入至少有一个解决方案。如果有多个,您仍然应该只画一堵墙。

没有时间限制;使用尽可能多的蛮力。理论上,您的算法应适用于任何大小的输入。

测试用例:

有多种解决方案,因此您的输出可能会有所不同。

>> [1, 1, 2, 2], 2
[][__]
[__][]

>> [1, 1, 1, 2, 2, 2, 2, 3], 2
[__][____][__]
[][__][][__][]

>> [1, 1, 2, 2, 3, 3, 3, 3], 3
[][__][____]
[__][____][]
[____][____]

>> [1, 2, 3, 4, 5, 6, 7, 8, 9], 5
[][______________]
[__][____________]
[________________]
[____][__________]
[______][________]

>> [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], 5
[][__][__]
[__][__][]
[][__][__]
[__][__][]
[][__][__]

您为什么决定制作2n字符宽而不是n> 1字符宽的积木?
Sparr

2
@Sparr 1 x 2个字符块看起来大致是正方形。我曾尝试过要求n>1,但不喜欢它如何限制测试用例。另外,显然有先例
xnor 2015年

我不是说n> 1的2n。我的意思是n> 1。
Sparr

Answers:


20

Perl,166170194

对于由Larry Wall创建的语言而言,这是一项完美的任务。

#!perl -pa
$_=(1x($x=2/($y=pop@F)*map{1..$_}@F)."
")x$y;sub
f{my$l=$_;$-|=!@_;for$=(@_){$Z=__
x~-$=;$f=0;s/(11){$=}/[$Z]/&!/\]..{$x}\[/s&&f(grep$=ne$_||$f++,@_);$-or$_=$l}}f@F

蛮力,但是在测试用例上非常快(<1s)。用法:

$ perl ~/wall.pl <<<"1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 5"
[][__][__]
[__][__][]
[][__][__]
[__][__][]
[][__][__]

测试


9
哈,我想知道拉里·沃尔(Larry Wall)是否曾以为人们会使用这种语言……:)
crazyhatfish

12

CJam,94 92 82字节

这是92字节的版本。随后是82字节版本。

l~1$,:L,:)m*{1bL=},\e!\m*{~W<{/(\e_}%}%{::+)-!},{{_,,\f<1fb}%2ew{:&,(},!}={{(2*'_*'[\']}/N}/

这将砖划分为各种可能的方式,并且仅采用有效的方式。目前来说,蛮力的,但是仍然可以在我的机器上的Java解释器上运行最后的测试用例,大约需要10秒。

说明

该代码分为5部分:

1)给定一个length数组,L我们如何将其划分为多个H部分。

l~1$,:L,:)m*{1bL=},
l~                     e# Read the input as string and evaluate it.
  `$,:L                e# Copy the array and take its length. Store that in L
       ,:)             e# Get an array of 1 to L
          m*           e# Cartesian power of array 1 to L of size H (height of wall)
            {1bL=},    e# Take only those parts whose sum is L

在此之后,我们可以采用所有可能的方式将输入数组拆分为H砖层。

2)获取输入数组的所有排列,然后进一步获取所有排列的所有分区

\e!\m*{~W<{/(\e_}%}%
\e!                    e# Put the input array on top of stack and get all its permutations
   \m*                 e# Put the all possible partition array on top and to cartesian
                       e# product of the two permutations. At this point, every
                       e# permutation of the input array is linked up with every
                       e# permutation of splitting L sized array into H parts
      {           }%   e# Run each permutation pair through this
       ~W<             e# Unwrap and remove the last part from the partition permutation
          {     }%     e# For each part of parts permutation array
           /           e# Split the input array permutation into size of that part
            (\         e# Take out the first part and put the rest of the parts on top
              e_       e# Flatten the rest of the parts so that in next loop, they can be
                       e# split into next part length

此后,我们将输入砖的所有可能布局都布置为H层状砖墙。

3)仅过滤出砖长相同的那些布局

{::+)-!},
{      },              e# Filter all brick layouts on this condition
 ::+                   e# Add up brick sizes in each layer
    )-!                e# This checks if the array contains all same lengths.

在此过滤器结束之后,所有剩余的布局将是完美的矩形。

4)取出符合稳定性标准的第一个砖块布局

{{_,,\f<1fb}%2ew{:&,(},!}=
{                       }=   e# Choose the first array element that leaves truthy on stack
 {         }%                e# For each brick layer
  _,,                        e# Create an array of 0 to layer length - 1
     \f<                     e# Get all sublists starting at 0 and ending at 0
                             e# through length - 1
        1fb                  e# Get sum of each sub list. This gives us the cumulative
                             e# length of each brick crack except for the last one
           2ew               e# Pair up crack lengths for every adjacent layer
              {    },        e# Filter layer pairs
               :&            e# See if any cumulative crack length is same in any two
                             e# adjacent layers. This means that the layout is unstable
                 ,(          e# make sure that length of union'd crack lengths is greater
                             e# than 1. 1 because 0 will always be there.
                     !       e# If any layer is filtered through this filter,
                             e# it means that the layer is unstable. Thus negation

完成此步骤后,我们只需要打印布局

5)打印布局

{{(2*'_*'[\']}/N}/
{               }/           e# For each brick layer
 {           }/              e# For each brick
  (2*'_*                     e# Get the (brick size - 1) * 2 underscores
        '[\']                e# Surround with []
               N             e# Newline after each layer

在这里在线尝试


82字节

l~:H;{e_mrH({H-X$,+(mr)/(\e_}%_::+)-X${_,,\f<1fb}%2ew{:&,(},+,}g{{(2*'_*'[\']}/N}/

这几乎与92字节版本相似,不同之处在于它具有随机性。如果您已阅读过92字节版本的说明,则在82字节版本中,第3、4和5部分完全相同,而无需遍历第1部分和第2部分的所有排列,此版本只是随机生成其中一个一次排列,使用第3部分和第4部分进行测试,然后如果第3部分和第4部分的测试失败,则重新启动该过程。

这将非常快速地打印出前3个测试用例的结果。height = 5测试用例尚未在我的计算机上提供输出。

差异说明

l~:H;{e_mrH({H-X$,+(mr)/(\e_}%_::+)-X${_,,\f<1fb}%2ew{:&,(},+,}g
l~:H;                           e# Eval the input and store the height in H
     {   ...   }g               e# A do-while loop to iterate until a solution is found
      e_mr                      e# Flatten the array and shuffle it.
          H({               }%  e# This is the random partition generation loop
                                e# Run the loop height - 1 times to get height parts
             H-X$,+(            e# While generating a random size of this partition, we
                                e# have to make sure that the remaining parts get at least
                                e# 1 brick. Thus, this calculation
                    mr)         e# Get a random size. Make sure its at least 1
                       /(\e_    e# Similar to 92's part 2. Split, pop, swap and flatten

_::+)-                          e# 92's part 3. Copy and see if all elements are same
      X${_,,\f<1fb}%2ew{:&,(},  e# 92's part 4. Copy and see if layers are stable
+,                              e# Both part 3 and 4 return empty array if
                                e# the layout is desirable. join the two arrays and
                                e# take length. If length is 0, stop the do-while

这个版本的想法是由randomra给出的(明白吗?)

在线尝试这个


9

Python 2中,680个 670 660字节

我不知道为什么我坚持要拥有这些超长的“高尔夫球”……但是无论如何,这就是你要去的地方。

M,L,R,N=map,len,range,None
exec"J=@:M(''.join,x);B=@:'['+'_'*2*~-x+']';K=@:M(B,x);W=@:J(M(K,x));C=@:set(M(sum,[x[:i]for i in R(L(x))]))-{0};T=@,w:w[x:]+w[:x]\ndef F(i):f=filter(@:i[x-1]&i[x],R(1,L(i)));return f and f[0]".replace('@','lambda x')
def P(e,x,i,w,h):
 for j in[-~_%h for _ in R(i-1,h+i-2)]:
    for s in R(w):
     if not e&C(T(s,x[j])):return j,s
 return N,N
def b(l,h):
 w,d=[[]for _ in R(h)],2*sum(l)/h
 for _ in l[::-1]:q=M(L,W(w));w[[q.index(i)for i in sorted(q)if i+L(B(_))<=d][-1]]+=_,
 g=M(C,w);i=F(g)
 while i:
    e=g[i-1];j,s=P(e,w,i,d,h)
    if j!=N:w[j]=T(s,w[j]);w[i],w[j]=w[j],w[i];g=M(C,w);i=F(g)
    else:b(T(-1,l),h);return
 print'\n'.join(W(w))

这要求输出按升序排序,并通过调用b(brick_sizes, height)

测试用例:

>>> tests = [([1, 1, 2, 2], 2),([1, 1, 1, 2, 2, 2, 2, 3], 2), ([1, 1, 2, 2, 3, 3, 3, 3], 3), ([1, 2, 3, 4, 5, 6, 7, 8, 9], 5), ([1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], 5)]
>>> for t in tests:
...     b(*t); print
... 
[__][]
[][__]

[____][__][__]
[][][__][__][]

[____][____]
[__][__][][]
[____][____]

[________________]
[______________][]
[____________][__]
[__________][____]
[________][______]

[__][__][]
[][__][__]
[__][__][]
[][__][__]
[__][__][]

它的工作方式是:

  1. 将砖块(最长->最短)分配给层,尝试在移动到下一层之前填充每一层。
  2. 每当相邻的层不稳定时,请尝试交换层并移动砖块,直到找到有用的为止。
  3. 如果没有任何效果,请将最长的砖移到尺寸列表的前面并递归。

1
您可能会continue从结尾处删除。也return(N,N)不会需要括号。
PurkkaKoodari

好电话-这continue是早期版本的遗物。
sirpercival

1
无法运行它,您有一个多余的括号,WT传递了一个额外的参数。
crazyhatfish

哎呀,谢谢!固定。
sirpercival,2015年

5

Haskell,262个字节

import Data.List
c=concat
n=init.scanl1(+)
1%l=[[[l]]]
n%l=[map(h:)(c$(n-1)%t)|(h,t)<-map(`splitAt`l)[1..length l]]
v[x]=1<2
v(x:y:z)=sum x==sum y&&n x==n x\\n y&&v(y:z)
l#n=unlines$map(>>=(\b->'[':replicate(2*b-2)'_'++"]"))$head$filter v$c.(n%)=<<permutations l

用法示例:

*Main> putStr $  [1, 2, 3, 4, 5, 6, 7, 8, 9] # 5
[______][________]
[__________][____]
[____________][__]
[][______________]
[________________]

*Main> putStr $ [1, 1, 2, 2, 3, 3, 3, 3] # 3
[____][____]
[__][__][][]
[____][____]

工作原理:main函数#获取一个列表l(砖块列表)和一个数字h(高度),并在所有可能的位置(通过函数,例如-> )将所有置换l分为h子列表。它保留了两个连续元素的总和相同(即,砖中的长度相同)并且小计列表中没有共同元素的元素(即,裂纹未排列,起作用)。选择适合的第一个列表并构建一串砖块。%2%[1,2,3,4][ [[1],[2,3]] , [[1,2],[3]] , [[1,2,3],[]] ]v


4

蟒蛇2,528417393,381

很长的蛮力解决方案。它有效,但仅此而已,在获得最后一个测试用例的结果之前,Universe可能会结束。

exec u"from itertools import*;m=map;g=@w,n:([[w]],[[w[:i]]+s#i?range(1,len(w))#s?g(w[i:],n-1)])[n>1];r=@x:set(m(sum,[x[:i]#i?range(1,len(x))]));f=@w:1-all(m(@(x,y):not x&y,zip(m(r,w[:-1]),m(r,w[1:]))));a=@s,h:['\\n'.join([''.join(['[%s]'%(' '*(s-1)*2)#s?r])#r?o])#p?permutations(s)#o?g(p,h)if len(set([sum(r)#r?o]))<2 and~-f(o)][0]".translate({64:u"lambda ",35:u" for ",63:u" in "})

a是主要功能:

>> a([1, 1, 2, 2], 2)
'[][  ]\n[  ][]'

通过将导入更改为呼叫from itertools import*itertools.permutations呼叫中删除,可以节省4个字节。此外,最后的ifs可以更改为if all(x==w[0] for x in w)and~-f(o):return...以节省13个字节。
PurkkaKoodari

另外,不是f总是在第一次迭代时返回?看起来很奇怪。这是一个错误或巨大的高尔夫机会。
PurkkaKoodari'5

您可以删除大量多余的空间-在引号/括号/括号之前或之后,运算符周围等。您还为分配了t=0两次r();您可以将该功能设置为map(sum,[x[:i] for i in range(len(x))])单行(如果需要,适合于lambdaing)。使用isdisjoint和set in f()将大大减少它(f()当前也仅在一次测试后返回,无论是否发现错误)。我个人会f()return not all(map(isdisjoint,map(set,map(r,w[:-1])),map(set,map(r,w[1:]))))或类似的方式重写。
sirpercival,2015年

@ Pietu1998哦,是的,错过了一个空格。感谢您提供的提示,我很惊讶您可以发现这些东西。
crazyhatfish

笑得太糟糕了,我讨厌那种“宇宙可能在得到结果之前就结束了”的代码,但这是最短的字节,它们共同测试了xD
Abr001am 2015年

3

的JavaScript(ES6)222 232 265 279 319

仍然要打高尔夫球。这可以找到所有解决方案,只输出最后找到的解决方案,而且速度非常快。

在Firefox中运行代码段进行测试

f=(n,h,b=[],s=0)=>
  (R=(z,l,p,k,t)=>
    z?b.map((v,a)=>
      v&&k.indexOf(v=t+a)<0&v<=s&&(
        --b[a],h=l+`[${'__'.repeat(a-1)}]`,
        v-s?R(z,h,[...p,v],k,v):R(z-1,h+'\n',[],p,0),
        ++b[a]
      ))
    :n=l
  )(h,'',[],[],0,n.map(n=>(b[n]=-~b[n],s+=n)),s/=h)&&n

// Test suite


out=x=>OUT.innerHTML=OUT.innerHTML+x+'\n'

;[ 
 [[1, 1, 2, 2], 2], [[1, 1, 1, 2, 2, 2, 2, 3], 2], [[1, 1, 2, 2, 3, 3, 3, 3], 3]
,[[1, 2, 3, 4, 5, 6, 7, 8, 9], 5], [[1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], 5]]
.forEach(([a,b])=>out(a+' '+b+'\n'+f(a,b)))
<pre id=OUT></pre>

脱节并解释

function f(n, h) {
  var b=[], s=0, result // in golfed version will re-use n for result variable
  n.forEach(function (n) {
    b[n] = -~b[n] // group equal input numbers in buckets
    s+=n          // calc sum of input numbers
  });
  // example of buckets: input 1,1,4,1,5,4 -> b[1]=3,b[4]=2,b[5]=1
  s /= h // total sum / height => sum expected for each brick layer

  // recursive scan function 
  function R(z, // layer count, from h downto 1
             l, // output so far
             p, // current layer partial sums array, mark intervals between bricks
             k, // prev layer parial sums, checked to avoid faulds
             t  // current partial sum 
             ) 
  {
    if (z > 0) 
    { // still building
      b.forEach( function (v,a) { // a:number from input list, v: repeat count 
        var w, m   // locals (in golfed version, reuse other variables avoid defining locals)
        w = t + a; // increased running total for current layer
        if (v != 0  // repeat count still > 0 
           && k.indexOf(w) < 0 // running total not found on list in prev layer (no fault)
           && w <= s) // current layer length not exceeded
        {
           --b[a]; // decrease repeat count, number used one more time
           m = l+"["+ '__'.repeat(a-1) + "]"; // new output with a brick added
           // l is not changed, it will be used again in this loop
           if (w == s) 
           {   // layer complete, go to next (if any)
               // recurse, new layer, add newline to output, p goes in k, and t start at 0 again
               R(z-1, m+'\n', [], p, 0); 
           }
           else
           {   // layer still to complete
               // recurse, same layer, m goes in l, add current sum to array p
               R(z, m, [...p,w], k, w);
           }
           ++b[a]; // restore value of repeat count for current loop
        }
      })
    }   
    else
    { // z == 0, all layers Ok, solution found, save in result and go on to next
      result = l;
    }
  }

  R(h,'',[],[],0);
  return result; // this is the last solution found
}

2

Python 2,网格方法(290个字符)

x,h=input()
from itertools import *
w = sum(x)*2/h
for p in permutations(x):
 bricks = ''.join('[' + '_'*(2*n-2) + ']' for n in p)
 cols = map(''.join,zip(*zip(*[iter(bricks)]*w)))
 if all(c=='[' for c in cols[0]) and all(c==']' for c in cols[-1]) and not any(']]' in col or '[[' in col for col in cols[1:-1]):
  print('\n'.join(map(''.join,zip(*cols))))
  print()

此处的方法是转置网格并在列中查找[[]]。您还测试了墙的左侧和右侧的所有砖是否对齐:这里的可爱之处是测试字符串的所有元素是否相同:'[[[[[['.strip('[')==''


迷你版以上:

x,h=input()
from itertools import*
w=sum(x)*2/h
z=zip
j=''.join
for p in permutations(x):
 C=map(j,z(*z(*[iter(j('['+'_'*(2*n-2)+']'for n in p))]*w)))
 if C[0].strip('[')==''and C[-1].strip(']')==''and not any(']]'in c or '[['in c for c in C[1:-1]):
  print('\n'.join(map(j,z(*C))))
  break

使用矩阵操作语言可以更轻松地完成此操作。

...或滥用正则表达式,这使我们可以将“块对齐对齐”条件与“无裂纹”条件结合使用:

假设墙的宽度为w = 6。子字符串“ [..... [”和“] .....]”的位置必须完全是集合{0,w-1,w,2w-1,2w,3w-1,。 ..}。在这些点上不存在意味着砖块“换行”,如下所示:

       v
[][__][_
___][__]
       ^

在这些点上不存在意味着墙中存在不稳定的“裂缝”:

     vv
[][__][]
[    ][]
     ^^

因此,我们将问题简化为对等集,其中问题中的集合是正则表达式匹配项的索引。

# assume input is x and height is h

from itertools import *
import re
w=sum(x)*2/h

STACKED_BRACKET_RE = r'(?=\[.{%i}\[|\].{%i}\])'%(w-1,w-1)  # ]....] or [....[
STRING_CHUNK_RE = '.{%i}'%w  # chunk a string with a regex!
bracketGoal = set().union(*[(x*w,x*w+w-1) for x in range(h-1)])  # expected match locations

for p in permutations(x):
 string = ''.join('['+'_'*(2*n-2)+']'for n in p)
 bracketPositions = {m.start() for m in re.finditer(STACKED_BRACKET_RE,string)}
 print(string, bracketPositions, bracketGoal, STACKED_BRACKET_RE) #debug
 if bracketPositions==bracketGoal:
  break

print('\n'.join(re.findall(STRING_CHUNK_RE,string)))

Python,regexp方法(304个字符):

from itertools import*
import re
x,h=input()
w=sum(x)*2/h
for p in permutations(x):
 s=''.join('['+'_'*(2*n-2)+']'for n in p)
 if {m.start()for m in re.finditer(r'(?=\[.{%i}\[|\].{%i}\])'%(w-1,w-1),s)}==set().union(*[(x*w,x*w+w-1) for x in range(h-1)]):
  break

print('\n'.join(re.findall('.{%i}'%w,s)))

有趣的想法直接与壁画一起使用以检查故障。您需要一行来接受输入,例如x,h=input()
xnor 2015年

0

Matlab(359)

function p(V),L=perms(V);x=sum(V);D=find(rem(x./(1:x),1)==0);for z= 2:numel(D-1)for y=1:numel(L),x=L(y,:);i=D(z);b=x;l=numel(x);for j=1:l,for k=j-1:-1:2,m=sum(x(1:k));if mod(m,i),if mod(m,i)<mod(sum(x(1:k-1)),i)||sum(x(1:j))-m==i,b=0;,end,end,end,end,if b,for j=1:l,fprintf('[%.*s]%c',(b(j)-2)+b(j),ones(9)*'_',(mod(sum(x(1:j)),i)<1)*10);end,return,end;end,end

输入值

一个整数向量,例如:p([1 1 2 2 3])

输出量

墙实例的方案:

[____]

[__][]

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