给定一个标准的密码锁，如图所示。解锁的方法是在组合行的代码中对齐4个数字。经过多年的忠诚服务，您已被锁厂解雇，并决定通过在下锁之前先放下锁来进行严格的报复，从而使每把锁都留在组合线上以在组合线上解锁。

您还知道，通过查看其他行中数字的顺序，可以计算出组合线上必须有哪些数字（因此，将其解锁的​​组合就是）。

如果为锁上的每一行提供了一个编号，该编号从组合行（用于解锁锁的行）的第0行开始到第9行。例如，如果第4行上的数字为5336，则要解锁的组合为1992。

不幸的是，这些锁已经打包，并且您对每个锁的查看都变得模糊了，因此您只能在锁的不同行上看到数字。

挑战

给定4对数字，其中整数的第一个数字表示行号，第二个数字表示在该行上出现的数字，请对锁进行组合。例如，如果您输入：

57 23 99 45

然后它应该输出：

2101

要么

25 78 63 15

和

3174

假设输入将始终是4个正整数，格式为`25 64 72 18。

这是code-golf，所以最短的程序以字节数为准。

这也是我的第一个问题，因此感谢您提供任何反馈意见。

CJam，9个 8字节

ea9fbAf%

读取数字对作为命令行参数。要在线尝试代码，请更改ea为lS/从模拟的STDIN读取。

运行示例

$ cjam <(echo ea9fbAf%) 57 23 99 45; echo
2101
$ cjam <(echo ea9fbAf%) 25 78 63 15; echo
3174

怎么运行的

数字d的字符代码是48 + d。因此，考虑两位数的字符串xy为9的基数，得出9 *（48 + x）+（48 + y）= 10 *（48 + x）+ y-x y-x（mod 10）。

ea       " Push the array of command-line arguments.                                      ";
  9fb    " Mapped base 9 conversion; replace each string 'xy' with (9 * ord(x) + ord(y)). ";
     Af% " Take the results modulo 10.                                                    ";

CJam，13 12 11个字符

多亏了user23013，它现在减少到11个字符：)

4{Ar:--A%}*

说明：

4{       }*     "Run the code block 4 times";
   r            "Read the next input token (whitespace separated)";
    :-          "Subtract 2nd number from the first treating r as a 2 numbered string";
  A   -         "Subtract the result of above from 10";
       A%       "Take modulus of 10 and store it on stack";

在线尝试

我知道它可以打更多。但这是我对CJam的第一次真正尝试，受经验的限制：)

另外，其他方法也可以用一个额外的字符来做同样的事情：

l~]{_A/-A%}/     // My previous solution

要么

4{ri_A/-A%}*     // As pointed out by Ingo

要么

ea{i_A/-A%}/     // If input is passed through command line

高尔夫球稿（14 13）

在这里在线尝试

它与Optimizer的解决方案几乎相同，只是语言不同。很难用不同的方法来解决它，因为问题很简单，所以关系肯定归于Optimizer，无论如何，Optimizer的条目还早。

~]{.10:^/-^%}/

对于相同数量的字节，您可以执行

~]{.10/- 10%}/

GNU dc，14个字节

借用@Dennis 聪明的9级技巧：

9i[?A%nd]dxxxx

从STDIN读取的输入整数，每行一个。

说明：

9i                # Set input radix to 9
  [     ]         # push a macro, defined thus:
   ?              #   read number from STDIN and push
    A             #   push literal 10
     %            #   calculate number mod 10
      n           #   print, with no newline
       d          #   duplicate macro
         d        # duplicate macro
          xxxx    # execute the macro 4 times    

输出：

$ for i in 57 23 99 45; do echo $i; done | dc ./combolock.dc
2101$ 
$ for i in 25 78 63 15; do echo $i; done | dc ./combolock.dc
3174$ 
$ 

上一个答案，18个字节：

因为我以为这样可以更接近“高尔夫”语言（但没有）：

[A?A~--A%n]dddxxxx

C 64 63 56或61

如果输入可以通过文件传递

main(a){while(scanf("%d",&a)>0)putchar(48+(a-a/10)%10);}

如果输入应键入stdin

i;main(a){for(;i++-4;putchar(48+(a-a/10)%10))scanf("%d",&a);}

循环读取四个数字，然后通过从值中减去第一个数字并以10为模输出结果来处理每个数字。

由于以下各种注释以及使用putchar而不是printf而节省了费用

Python 3、64

直截了当。

print(''.join([(i-i//10)%10 for i in map(int,input().split())]))

如果允许打印，它可以更短一些，例如[2, 1, 0, 1]（46）：

print([i%10-i//10 for i in map(int,input().split())])

C，92

#define a(n) ,(10+v[n][1]-*v[n])%10
main(int c,char**v){printf("%d%d%d%d"a(1)a(2)a(3)a(4));}

从命令行输入。从第二个参数中减去每个参数的第一个ASCII码，加10并取模10。

我认为这是我第一次printf用4 %而不是逗号写a （逗号在中 #define.）

Java-203字节

仅仅因为必须有一个Java条目，我看到了一个很好的机会让此代码成为可能（有史以来第一次提交）。

class M{public static void main(String[] a){String r="";for(int i=0;i<4;i++){int l=Byte.valueOf(a[i].substring(1));int f=Byte.valueOf(a[i].substring(0,1));r+=(l-f<0)?l-f+10:l-f;}System.out.print(r);}}

如果还有改进的余地，我很乐意了解它们；-)

Lua-46个字符

while''do a,b=io.read(1,1,1)print((b-a)%10)end

一次读取三个字符（请给我一点点的怜悯，在末尾输入一个空格），尽管a和b是字符串y。打印时是否进行环绕检查。

JavaScript ES6 – 53 43字节

f=n=>n.replace(/.. ?/g,a=>(1+a[1]-a[0])%10)

相当简单的函数，使用正则表达式获取数字。在尝试 http://jsfiddle.net/efc93986/1/上。如果不允许使用功能，请使用52字节的独立程序：

alert(prompt().replace(/.. ?/g,a=>(1+a[1]-a[0])%10))

由于ES6当前仅在Firefox上运行，因此以下代码可在任何现代浏览器上运行，字节数为70：

alert(prompt().replace(/.. ?/g,function(a){return(1+a[1]-a[0])%10}))

Python 2-33个字节

for i in input():print(i-i/10)%10

接受以逗号分隔的用户输入。例如输入：

29,26, 31, 88

输出：

7
4
8
0

如果要求输出与示例完全匹配，则它会更长。47个字节：

print"%d"*4%tuple((i-i/10)%10 for i in input())

APL，14

10|{--/⍎¨⍕⍵}¨⎕

说明
⎕从屏幕输入。以空格分隔的值被解析为数组。
{...}¨对于每个数字，将其输入函数。
⍎¨⍕⍵接受参数，创建其数字数组。
--/计算单位减去十。
10|国防部10。

歼20 15

非动词形式（作为语句而不是函数定义）短5个字符：

10|-~/|:10#.inv

动词形式是一个很好的火车：

10|[:-~/[:|:10#.inv]

在示例输入中使用的动词：

   10|-~/|:10#.inv 57 23 99 45
2 1 0 1
   10|-~/|:10#.inv 25 78 63 15
3 1 7 4

rotd =: 10|[:-~/[:|:10#.inv] NB. verb form

   rotd 25 78 63 15
3 1 7 4
   rotd 57 23 99 45
2 1 0 1

哈斯克尔60 58

main=interact$show.map((\x->mod(x-x`div`10)10).read).words

单字符数字，这是Haskell打高尔夫球的真正克星。

佩尔：38 40

print abs($_-int$_/10)%10for split" ",<>

输出：

% perl code.pl
57 23 99 45
2101

25 78 63 15                                     
3174

Ruby，35个字节

$*.map{|n|a,b=n.bytes;$><<(b-a)%10}

说明

输入作为命令行参数。String#bytes返回一个整数数组（ASCII字符代码）。只有最后一个字符代码和第一个字符代码之间的差异才是重要的，而不是整数本身。

C＃和LinqPad：104

Util.ReadLine<string>("").Split(' ').Select(s =>(s[1]-s[0])).Aggregate("",(r,a)=>r+(a<0?10+a:a)).Dump();

C ++ 118

int main()
{
int a,b,c;
for(int i=0; i<4; i++)
{
cin>>a;
b=a/10;
a=a%10;
c=a-b;
if(c<0)c+=10;
cout<<c;
}
}

PHP-90个字符

以为我会尝试打高尔夫球，所以这是我的第一次尝试-可能会打更多的高尔夫球。

<?php $a=array(57,23,99,45);foreach($a as$b){echo abs(substr($b,0,1)-substr($b,1,1)%10);}

58个字符（由Ismael Miguel提供）

for($i=0,$a=$_GET[n];$i<8;)echo abs($a[$i++]-$a[$i++]);

使用访问文件

file.php?n=57239945

Python 3、60

for x in input().split():print(-eval('-'.join(x))%10,end='')

输入和输出完全按照指定的方式进行，尽管它不会打印尾随的换行符。这里有两个有趣的技巧：1）用到的int()一个调用替换两个to的调用eval()，以及2）使用join()get a-b，然后b-a根据需要取反。幸运的是，即使第一个参数为负，Python的模运算符也会给出正值！