编写一个使用正整数的程序或函数。您可以假定输入有效，并且可以将其作为字符串。如果数字是以下任何一个

123
234
345
456
567
678
789

然后输出真实值。否则，输出一个伪造的值。例如，输入

1
2
3
12
122
124
132
321
457
777
890
900
1011
1230
1234

必须全部导致虚假输出。（输入不会有前导零，因此您不必担心诸如此类的东西012。）

以字节为单位的最短代码获胜。

Python，24个字节

range(123,790,111).count

一个匿名函数，输出0或1。它将创建列表[123, 234, 345, 456, 567, 678, 789]并计算输入出现的次数。

f=range(123,790,111).count

f(123)
=> 1
f(258)
=> 0

Python，24个字节

lambda n:n%111==12<n<900

只是很多条件链。

Haskell，22个字节

(`elem`[123,234..789])

匿名函数。生成等距列表，[123, 234, 345, 456, 567, 678, 789]并检查输入是否为元素。

Brachylog，9个字节

h:2j:12+?

在线尝试！或验证所有测试用例。

该算法归功于Dennis。

用英语来说，“（证明）输入的第一位数字与自身连接两次，再加上12，仍然是输入。”

Python 2，25个字节

lambda n:`n-12`==`n`[0]*3

在Ideone上进行测试。

Brain-Flak 76 + 3 = 79字节

这个答案就是这个答案。我实际上并不十分了解我的答案如何工作，但DJMcMayhem在他的原始答案中给出了很好的解释，而我的答案是对他的修改。

([]<>)<>({}[({})]<>)<>(({}[({})()()()()()]<>{}{}<(())>)){{}{}(((<{}>)))}{}{}

它与-a ascii标志添加3个字节一起运行。

说明（各种）

从原始的工作解决方案开始：

([]<>)<>({}[({})]<>)<>({}[({})]<>)({}{}[()()])({}<({}[()()()])>)(({}{}<(())>)){{}{}(((<{}>)))}{}{}

我通过编写的一个简单的高尔夫算法来运行此程序并得到：

([]<>)<>({}[({})]<>)<>(({}[({})]<>{}[()()]<({}[()()()])>{}<(())>)){{}{}(((<{}>)))}{}{}

从这里我看到该部分<({}[()()()])>{}实际上乘以一，这等于{}[()()()]将整个代码减少为：

([]<>)<>({}[({})]<>)<>(({}[({})]<>{}[()()]{}[()()()]<(())>)){{}{}(((<{}>)))}{}{}

最后，底片可以合并：

([]<>)<>({}[({})]<>)<>(({}[({})()()()()()]<>{}{}<(())>)){{}{}(((<{}>)))}{}{}

Brainfuck，32个字节

+>,+>,>,-[-<-<->>],[<]<[<]<[<]<.

在线尝试！

将算法的核心归功于Lynn。

果冻，6 字节

DI⁼1,1

在线尝试！或验证所有测试用例。

怎么运行的

DI⁼1,1  Main link. Argument: n (integer)

D       Decimal; convert n to base 10.
 I      Increments; compute the differences of all pairs of adjacent digits.
   1,1  Yield [1, 1].
  ⁼     Test the results to both sides for equality.

05AB1E，5个字节

¥XX‚Q

说明

¥      # deltas
    Q  # are equal to
 XX‚   # [1,1]

在线尝试

MATL，8字节

d1=tn2=*

在线尝试！

这将打印1 1出真实的输入，并0在其中打印一个数组以显示伪造的值，因为这在MATL中是伪造的。

说明：

d           % Calculate the difference between consecutive digits
 1=         % Push an array of which elements equal one
   t        % Duplicate this array
    n       % Push the length of this array
     2=     % Push a one if the length is 2, and a zero otherwise
            % Now, if we have a truthy input, the stack looks like:
            %   [1 1]
            %   1
            % And if we have a falsy input, the stack looks something like this:
            %   [1 0]
            %   1
            % Or this:
            %   [1 1]
            %   0
       *    % Multiply the top two elements

Java 7，46个字节

boolean f(int a){return a>12&a<790&a%111==12;}

在与Leaky Nun聊天尝试了几件事之后，这似乎是最短的。有时，您只需要简单明了的方法即可：/

说明：

boolean f(int a){
    return a>12         Is it more than 12? (stupid edge case)
           &
           a<790        Is it in range the other way? 
           &
           a%111==12;   Is it 12 more than a multiple of 111? 
}

Perl 6的， 35 29 24 21  19个字节

{.chars==3&&'0123456789'.index: $_}
{$_ (elem) (123,*+111...789)}
{$_∈(123,*+111...789)}
*∈(123,*+111...789)
*∈(123,234...789)

说明：

# Whatever lambda ( the parameter is ｢*｣ )
*

∈ # is it an element of:

# this sequence
(
  123,
  234,

  # deduce rest of sequence
  ...

  # stop when you generate this value
  789
)

用法：

my &code = *∈(123,234...789);

say code 123; # True
say code 472; # False

say (  *∈(123,234...789)  )( 789 ); # True

视网膜 26

.
$*: 
^(:+ ):\1::\1$

输出1为真，0为假。

在线尝试（添加第一行以允许运行多个测试用例）。

Ruby，32 30 25 + 2 = 27字节

+2个字节用于-nl标志。

在STDIN上输入并打印true或false。

p"123456789"[$_]&.size==3

在repl.it上查看它：https ://repl.it/DBn2/2 （单击▶️，然后在下面的控制台中输入输入。）

脑筋急转弯，99字节

([{}]({})<>)<>([{}]{}<>)(({})<([{}]{})((){[()](<{}>)}{})>)([{}]{})((){[()](<{}>)}{})<>{{{}}<>{}}<>

在线尝试！

这是+1该-a标志的98个字节的代码。

这是1为真而打印，对于虚假则为真0或为零（等于0）

脑筋急转弯，114字节

([((()()()){}){}]{})(((()()()){}())<>)<>{({}<(({}[(((((()()()){}()){}){}){}){}]())){(<{}>)<>({}[()])<>}{}>[()])}<>

在线尝试！

正确的版本（本着问题的精神）：将整数用作输入，对于falsey，输出0，对于true，输出1。

这不是干净的堆栈。

算法

让输入为n。

输出是正确的iff (n-123)(n-234)(n-345)(n-456)(n-567)(n-678)(n-789)=0。

我先减去12，再减去111 7次，计算出这七个数字，然后计算出这七个数字的逻辑双NOT并将它们相加。

对于真实结果，总和为6；对于假结果，总和为7。

然后，我从7中减去总和并输出答案。

R，30 22字节

scan()%in%(12+1:7*111)

并不特别令人兴奋；检查输入是否在12 + 111k给定的序列中，其中k是1到7。请注意，输入是在:前面的，*所以乘法发生在序列生成之后。

C＃（Visual C＃交互式编译器），41 30 23字节

第一次提交代码高尔夫球，请保持谨慎:)

a=>{return a>12&&a<790?a%111==12:false;};
a=>a>12&&a<790?a%111==12:false
a=>a>12&a<790&a%111==12

在线尝试！

• -11个字节，感谢KirillL。
• 由于仅使用ASCII，另外-7个字节。

Brainfuck，43个字节

,>,>,>,[>>]<[[-<-<->>]<+[>>]<++[>>->]<+<]>.

ah，我不好。输出\x01如果输出是一个字符串时123，234，...，789; \x00否则输出。

（尽管我击败了Java 7，...）

在线尝试！

JavaScript ES6，26个字节

n=>1>(n-12)%111&n>99&n<790

这利用了以下事实：我对本质上为布尔值（基于位的布尔值）使用按位逻辑运算符。

感谢Titus的保存2。

Excel- 62 57 35 31字节

基于Anastasiya-Romanova的答案，但返回Excel的TRUE/FALSE值。

=AND(LEN(N)=3,MID(N,2,1)-MID(N,1,1)=1,MID(N,3,1)-MID(N,2,1)=1)

此外，我们可以

=AND(LEN(N)=3,MID(N,2,1)-LEFT(N)=1,RIGHT(N)-MID(N,2,1)=1)

因为这两个RIGHT和LEFT默认返回单个字符。

并且，受到一些Python解决方案的启发：

=AND(LEN(N)=3,MOD(N,111)=12,N<>900)

感谢Neil提供4个字节...

=AND(N>99,MOD(N,111)=12,N<900)

Brachylog（2），7个字节

ẹ~⟦₂-_2

在线尝试！

说明

ẹ~⟦₂-_2
ẹ        Split into digits
 ~⟦₂     Assert that this is an increasing range; take its endpoints
    -_2  Assert that the starting minus ending endpoint is -2

作为一个完整的程序，如果所有断言都成立，我们将得到真实的回报，如果失败则返回虚假的回报。

CJam，13个 9字节

A,s3ewqe=

在线尝试！

说明

A,s        e# Push "0123456789".
   3ew     e# Split it into contiguous length-3 chunks: ["012" "123" "234" ... "789"].
      q    e# Push the input.
       e=  e# Count the number of times the input appears in the array.

Excel-104个字节

=IF(LEN(N)<3,"Falsy",IF(AND(LEN(N)=3,MID(N,2,1)-MID(N,1,1)=1,MID(N,3,1)-MID(N,2,1)=1),"Truthy","Falsy"))

说明：

Excel中IF公式的语法为：

IF( condition, [value_if_true], [value_if_false] )

如果输入的长度N（小于等于3）是参考单元格的名称，则它将返回Falsy。否则，如果输入的长度N为3，并且第二位和第一位的差与第三位和第二位的差都等于1，则它将返回Truthy。

Dyalog APL，10 个字节

接受字符串参数。

1 1≡¯2-/⍎¨

1 1≡ {1，1}是否等于

¯2-/ 的反向成对差

⍎¨ 每个字符都视为一个数字？

在线尝试APL！（出于安全原因⍎已被模拟e。）

Perl，18个字节

包括+1的 -p

使用STDIN上的输入运行

123.pl <<< 123

123.pl：

#!/usr/bin/perl -p
$_=$_=/./.2==$_-$&x3

PHP，31字节

<?=($n=$_GET[n])-12==$n[0]*111;

检查（数字减12）的第一位数是否为111的倍数

PowerShell v3 +，24个字节

($args[0]-12)/111-in1..7

使用与其他答案相同的“ 111加12的倍数”技巧，但使用其他方向。接受输入$args[0]，减去12，除以111，然后检查是否是-in范围1..7。输出布尔值true / false。要求v​​3 +为-in运营商。

测试用例

PS C:\Tools\Scripts\golfing> 123,234,345,456,567,678,789|%{.\easy-as-one-two-three.ps1 $_}
True
True
True
True
True
True
True

PS C:\Tools\Scripts\golfing> 1,2,3,12,122,124,132,321,457,777,890,900,1011,1230,1234|%{.\easy-as-one-two-three.ps1 $_}
False
False
False
False
False
False
False
False
False
False
False
False
False
False
False

ARM机器码，18个字节

十六进制转储（小端）：

3803 d105 6808 ebc0 2010 b280 f2a0 1001 4770

此函数需要一个长度为字符串的指针对。输出为bash样式，其输出0为true，为非零值。在C语言中，该函数将声明为int oneTwoThree（size_t长度，char *字符串）。指令编码为thumb-2，具有2和4字节指令。在Raspberry Pi 3上测试。

非高尔夫装配：

.syntax unified
.text
.global oneTwoThree
.thumb_func
oneTwoThree:
    @Input: r0 - the number of characters in the string
    @r1 - A pointer to the (not necessarily NUL-terminated)
    @string representation of the number (char*)
    @Output: r1 - 0 if the number is in 123,234,...,789, else non-zero (bash-style)
    subs r0,r0,#3
    bne end @Return non-zero if r0!=3
    ldr r0,[r1] @Remember that this is little endian
    @So the first digit is the most siginificant byte
    @I.e. if the input was 123 then r0 contains 0xXY010203 where XY is garbage

    rsb r0,r0,r0,lsr #8 @r0=(r0>>8)-r0 (rsb is reverse subtract)
    uxth r0,r0 @r0&=((1<<16)-1) (mask off top half)
    @Now r0 is 0x0101 iff we have a matching number
    sub r0,r0,#0x101
    @Now r0 is 0 iff the string fit the specification

    end:
    bx lr @return

测试脚本（也是汇编）：

.syntax unified
.text
.global main
.thumb_func
main:
    push {r4,lr}
    ldr r4,[r1,#4] @r0=argv[1]
    mov r0,r4
    bl strlen
    @Now r0 is the length of the string argv[1]
    mov r1,r4
    bl oneTwoThree @oneTwoThree(strlen(argv[1]),argv[1])
    cmp r0,#0
    it ne
    movne r0,#1 @Output through return code, 1 if false
    pop {r4,pc}

JavaScript（ES6），34个字节

还有JS中的另一个选项。取输入作为一个字符串，并输出0为false和1为true。

n=>++n[0]==n[1]&++n[1]==n[2]&!n[3]

在这里和这里查看我的其他解决方案

试试吧

f=
n=>++n[0]==n[1]&++n[1]==n[2]&!n[3]
i.addEventListener("input",_=>o.innerText=f(i.value))

<input id=i type=number><pre id=o>