您有一个在每个角都有一个数字的框：

1|2
---
3|4

如果我们将数字从左到右连接起来，我们得到12和34。如果我们将数字从上到下连接起来，我们得到13和24。如果我们将所有这些数字相加，我们得到12 + 34 + 13 + 24 = 83。

挑战

编写一个程序以打印所有这样的框，其中上述总和等于100。

假设每个角包含1到9之间的一个数字，则有9种组合：1157、1247、1337、1427、1517、2138、2228、2318和3119。（请注意，如果包含0，则有25种组合，但是我们不适合这个挑战。）

请注意，示例1234不起作用，因为12 + 34 + 13 + 24不等于100。

输入值

没有

输出量

答案框的格式如下：

A|B
---
C|D

输出应打印到STDOUT或最接近的替代品。

规则

• AB + CD + AC + BD = 100
• 每个角将仅包含正整数1-9。
• 排除0。
• 数字可以使用多次。
• 您需要如上所述绘制方框。（A|B\n---\nC|D\n）
• 您需要输出所有有效答案。
• 附加的尾随换行符也可以。
• code-golf，因此以字节为单位的最短代码获胜。
• 标准漏洞和条款和条件适用。

这是我的首次提交，因此如果需要澄清任何内容，请告诉我。

Pyth，42 38 34字节

V ^ ST4IqC \ ds * VNsM ^，T1 2Xj \ | N3“
---

代码中的尾随换行符很重要。主要的原因我竞争的是我用的向量的点积[1, 1, 5, 7]和[20, 11, 11, 2]，并将其与100。

Ruby，71岁

由于不允许使用硬编码（在任何情况下都很难画线），所以这里有部分硬编码的答案。

1.upto(3){|i|1.upto(7-i*2){|j|print i,?|,j,'
---
',8-j-2*i,?|,i+6,'
'}}

说明

解决方案的公式如下：

A*20+(B+C)*11+D*2=100

通过模块化算术参数，我们可以看到A和D必须相差一个常数，即(A*20+D*2)%11常数。实际上，D = A + 6。将i通过A的三个可能的值循环迭代

B的值可以是1至之间的任何值，7-i*2并且B和C的总和必须为14-A-D。因此，我们获得了以下表达式，这些表达式已被打印出来。Ruby允许在包含在字符串中的文字换行符''

   i     |    j
------------------
8-j-2*i  |   i+6

Java中，202 200 198

第一次尝试：D

编辑：保存2个字节，并在其他注释中找到较小的计算值。

class C{public static void main(String[]c){for(int i=0;++i<5;)for(int j=0;++j<7;)for(int k=0;++k<10;)for(int l=0;++l<10;)if(20*i+11*(j+k)+2*l==100)System.out.printf("%s|%s%n---%n%s|%s%n",i,j,k,l);}}

批次-187字节

蛮力。

@!! 2>nul||cmd/q/v/c%0&&exit/b
set y=for /l &set z= in (1,1,9)do 
%y%%%a%z%%y%%%b%z%%y%%%c%z%%y%%%d%z%set/aa=%%a%%b+%%c%%d+%%a%%c+%%b%%d&if !a!==100 echo %%a^|%%b&echo ---&echo %%c^|%%d

不打高尔夫球，它的恶心程度略有降低：

@echo off
setLocal enableDelayedExpansion
for /l %%a in (1,1,9) do (
    for /l %%b in (1,1,9) do (
        for /l %%c in (1,1,9) do (
            for /l %%d in (1,1,9) do (
                set/aa=%%a%%b+%%c%%d+%%a%%c+%%b%%d
                if !a!==100 (
                    echo %%a^|%%b
                    echo ---
                    echo %%c^|%%d
                )
            )
        )
    )
)

CJam，40个字节

A4m*{[KBBY].*:+56=},{:)2/'|f*"
---
"*N}/

查找组合的方法与@Optimizer的方法不同，但是用于打印它们的代码是相同的。

在CJam解释器中在线尝试。

怎么运行的

A4m*     e# Push all vectors of length 4 with coordinates in [0 ... 9].
         e# We'd normally use [0 ... 8] here, but "9 4m*" is 1 byte longer and
         e# "A4m*" doesn't produce any false positives.

{        e# Filter the vectors:
[KBBY].* e#   Multiply the elements of the vector by 20, 11, 11 and 2.
:+       e#   Add all four products.
56=      e#   Check if the sum is 56. 56 is used instead of 100 since all elements
         e#   of the vector will be incremented and 56 + 20 + 11 + 11 + 2 == 100.
},       e# Keep only vectors for which = pushed a truthy value.

{        e# For each vector:
:)       e#   Increment each coordinate.
2/       e#   Split into pair.
'|f*     e#   Join each pair, delimiting by '|'.
"
---
"*       e#   Join the two pairs, delimiting by "\n---\n".
N        e#   Push "\n".
}/       e#

Haskell中，107个 131字节

s=show
r=[1..9]
v=putStr$unlines[s a++"|"++s b++"\n---\n"++s c++"|"++s d++"\n"|a<-r,b<-r,c<-r,d<-r,(2*a+b+c)*10+b+2*d+c==100]

我的第一个Haskell程序的第二版！

这个时间显示为按客户要求，无耻地被盗改编自NIMI的（好，我做了一些研究，但似乎没有那么可有效的方式，显示字符在Haskell让putStr $ unlines是难以避免的）。

而且...除了最后的公式分解外，它还是可读的=）

Haskell中，125个 121字节

s=show
f=putStr$unlines[s a++'|':s b++"\n---\n"++s c++'|':s d|[a,b,c,d]<-mapM id$"abcd">>[[1..9]],20*a+11*(b+c)+2*d==100]

用法：

*Main> f
1|1
---
5|7
1|2
---
4|7
1|3
---
3|7
1|4
---
2|7
1|5
---
1|7
2|1
---
3|8
2|2
---
2|8
2|3
---
1|8
3|1
---
1|9

>>in "abcd">>[[1..9]]创建一个包含第二个元素的4（第一个参数的长度）副本的列表，即[[1..9],[1..9],[1..9],[1..9]]。mapM id使得它们的所有组合，即列表[0,0,0,0]来[9,9,9,9]。保留那些总结起来的内容，100并在其中加上框。打印所有框。

感谢@Mauris提供了1个字节，让我查看了我的帖子以发现另外3个。

Python 2中，145个 129字节

我目前正在使用几种不同的计算方法，这些方法应该比概述的要短，但是我将发布现在的内容。

i=int
for k in range(1000,9999):
 a,b,c,d=`k`
 if i(a+b)+i(c+d)+i(a+c)+i(b+d)==100and not'0'in`k`:print a+'|'+b+'\n---\n'+c+'|'+d

CJam，43 42字节

A,1>4m*{2/_z+Afb:+100=},{2/'|f*"
---
"*N}/

今天EOD跟进的解释..

在这里在线尝试

Python 3、159

快速又脏。

N='123456789'
D='%s|%s\n'
O=D+'---\n'+D
I=int
[print(O%(a,b,c,d)if I(a+b)+I(c+d)+I(a+c)+I(b+d)==100 else'',end='')for a in N for b in N for c in N for d in N]

R，165字节

e=expand.grid(d<-1:9,d,d,d)
a=apply
o=a(e[a(e,1,function(x)20*x[1]+11*(x[2]+x[3])+2*x[4]==100),],1,function(x)cat(x[1],"|",x[2],"\n---\n",x[3],"|",x[4],"\n",sep=""))

如果我选择以某种方式对输出进行硬编码，则该时间将大大缩短。像其他一些解决方案一样，这利用了标识20 x ₁ + 11（x ₂ + x ₃）+ 2 x ₄ = 100。

取消+说明：

# Create a matrix where each row is a combination of the digits 1-9
e <- expand.grid(1:9, 1:9, 1:9, 1:9)

# Filter the rows of the matrix using the aforementioned identity
e <- e[apply(e, 1, function(x) 20*x[1] + 11*(x[2]+x[3]) + 2*x[4] == 100), ]

# Print each row formatted into boxes
o <- apply(e, 1, function(x) cat(x[1], "|", x[2], "\n---\n", x[3], "|", x[4], sep = ""))

您可能想知道为什么最后一个语句是赋值。事实证明，cat连接并打印的函数返回值NULL。当您cat从类似之类的函数中调用时apply，输出之后将是NULL，这是不希望的。有两种解决方法：将其分配给变量或将其包装在中invisible。在这里，我选择了前者，因为它明显更短。

您可以在线尝试。

爪哇，450

我的第一次尝试（未脱胶）如下所示：

B级{
  公共静态void main（String [] a）{
    for（int i = 1; i <10; i ++）
      for（int j = 1; j <10; j ++）
        for（int k = 1; k <10; k ++）
          for（int l = 1; l <10; l ++）
            if（Integer.parseInt（i +“” + j）+ Integer.parseInt（k +“” + 1）+ Integer.parseInt（i +“” + k）+ Integer.parseInt（j +“” + l）== 100）{
              System.out.println（i +“ |” + j）;
              System.out.println（“-”）;
              System.out.println（k +“ |” + l +“ \ n”）;
            }
  }
}

的PowerShell 98

修改过的steveverrill公式

:\>cat printbox.ps1

1..9|%{for($j=1;$j-lt10;$j++){if(($k=(8-$j-2*$_))-gt0){"{0}|{1}`n---`n{2}|{3}"-f$_,$j,$k,
($_+6)}}}

:\>powershell -f printbox.ps1
1|1
---
5|7
1|2
---
4|7
1|3
---
3|7
1|4
---
2|7
1|5
---
1|7
2|1
---
3|8
2|2
---
2|8
2|3
---
1|8
3|1
---
1|9