As Easy as One-Two-Three

Question

Write a program or function that takes in a positive integer. You can assume the input is valid and may take it as a string. If the number is any of

123
234
345
456
567
678
789

then output a truthy value. Otherwise, output a falsy value. For example, the inputs

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

must all result in falsy output. (The input will not have leading zeroes so you needn't worry about things like 012.)

The shortest code in bytes wins.

Answer 1

Python, 24 bytes

range(123,790,111).count

An anonymous function that outputs 0 or 1. It creates the list [123, 234, 345, 456, 567, 678, 789] and counts how many times the input appears.

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

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

Answer 2

Python, 24 bytes

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

Just a lot of condition chaining.

Answer 3

Haskell, 22 bytes

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

An anonymous function. Generates the evenly-spaced list [123, 234, 345, 456, 567, 678, 789] and checks if the input is an element.

Answer 4

Python 2, 25 bytes

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

Test it on Ideone.

Answer 5

Brachylog, 9 bytes

h:2j:12+?

Try it online! or Verify all test-cases.

Credits to Dennis for the algorithm.

In English, "(prove that) the Input's first digit, concatenated to itself twice, add 12, is still the Input."

Answer 6

Brain-Flak 76 + 3 = 79 bytes

This answer is a golf of this answer. I don't actually know quite how my answer works but DJMcMayhem gives a good explanation in his original answer and my answer is a modification of his.

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

It is run with the -a ascii flag adding 3 bytes.

Explanation (of sorts)

Starting with the original working solution:

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

I run this through a simple golfing algorithm I wrote and get:

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

From here I see the section <({}[()()()])>{} this essentially multiplies by one which makes it equal to {}[()()()] reduce the whole code to:

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

Lastly negatives can be combined:

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

Answer 7

05AB1E, 5 bytes

¥XX‚Q

Explanation

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

Try it online

Answer 8

Brainfuck, 32 bytes

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

Try it online!

Credits to Lynn for the core of the algorithm.

Answer 9

Jelly, 6 bytes

DI⁼1,1

Try it online! or verify all test cases.

How it works

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.

Answer 10

MATL, 8 bytes

d1=tn2=*

Try it online!

This will print 1 1 for a truthy input, and an array with a 0 in it for a falsy value, since that is falsy in MATL.

Explanation:

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

Answer 11

Java 7, 46 bytes

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

After trying several things with Leaky Nun in chat, this seems to be the shortest. Sometimes you just have to do things the straightforward way :/

Explanation:

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? 
}

Answer 12

Perl 6,  35 29 24 21  19 bytes

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

Explanation:

# 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
)

Usage:

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

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

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

Answer 13

Retina, 26

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

Outputs 1 for truthy and 0 for falsey.

Try it online (First line added to allow multiple testcases to be run).

Answer 14

R, 30 22 bytes

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

Not particularly exciting; check if input is in the sequence given by 12 + 111k, where k is each of 1 to 7. Note that : precedes * so the multiplication happens after the sequence is generated.

Answer 15

Brain-Flak, 99 bytes

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

Try it online!

This is 98 bytes of code +1 for the -a flag.

This prints 1 for truthy, and either 0 or nothing (which is equivalent to 0) for falsy

Answer 16

C# (Visual C# Interactive Compiler), 41 30 23 bytes

First code-golf submission, be gentle :)

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

Try it online!

• -11 bytes thanks to Kirill L.
• Another -7 bytes thanks to ASCII-only.

Answer 17

Ruby -nl, 32 30 25 bytes

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

Attempt This Online!

Answer 18

Brain-Flak, 114 bytes

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

Try it online!

Correct version (in the spirit of the question): takes the integer as input, output 0 for falsey and 1 for truthy.

This is not stack clean.

Algorithm

Let the input be n.

The output is truthy iff (n-123)(n-234)(n-345)(n-456)(n-567)(n-678)(n-789)=0.

I computed those seven numbers by first subtracting 12 and then subtract 111 7 times, and then computed the logical double-NOT of those seven numbers and added them up.

For truthy results, the sum is 6; for falsey results, the sum is 7.

Then, I subtract the sum from 7 and output the answer.

Answer 19

JavaScript ES6, 26 bytes

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

This takes advantage of the fact that I'm using bit-wise logic operators on what are essentially booleans (which are bit-based!)

Thanks to Titus for saving 2.

Answer 20

Vyxal, 4 bytes

¯k₁⁼

Try it Online!

Explained

¯k₁⁼
¯    # Deltas
 k₁  # [1,1]
   ⁼ # compare lists

Answer 21

K (ngn/k), 15 bytes

{($x-12)=3#*$x}

Try it online!

Port of Dennis' algorithm.

Explanation:

{($x-12)=3#*$x}  Main function. Takes x as input
            $x   Convert x to string
           *     Then get the first character
         3#      And duplicate it thrice
        =        Is it equal to
 ( x-12)         x - 12
  $              Converted to string?

Answer 22

Brainfuck, 43 bytes

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

Bah, I'm no good at this. Outputs \x01 if the output is one of the strings 123, 234, …, 789; outputs \x00 otherwise.

(I beat Java 7, though…)

Try it online!

Answer 23

Excel - 62 57 35 31 bytes

Based on Anastasiya-Romanova's answer, but returning Excel's TRUE/FALSE values.

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

Further, we can get to

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

since both RIGHT and LEFT return a single character by default.

And, inspired by some of the Python solutions:

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

Thanks to Neil for 4 more bytes...

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

Answer 24

Brachylog (2), 7 bytes

ẹ~⟦₂-_2

Try it online!

Explanation

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

As a full program, we get a truthy return if all assertions hold, a falsey return if any fail.

Answer 25

CJam, 13 9 bytes

A,s3ewqe=

Try it online!

Explanation

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.

Answer 26

MathGolf, 6 4 bytes

│ª▒=

Try it online!

Explanation

│       get differences of digits in integer
 ª      push [1]
  ▒     duplicate items in list
   =    pop(a, b), push(a==b)

Answer 27

Regex (ECMAScript), 20 bytes

The input n is in unary, as the length of a string of xs.

^x{12}(x{111}){1,7}$

Try it online!

This works by asserting that \$n-12\$ is of the form \$111k\$ where \$1\le k\le 7\$.

Answer 28

BRASCA, 15 bytes

Ci,:::SSL{+,SS=

Try it online!

Explanation

Ci                - Set implicit output to output numbers, and turn "0-9" into 0-9
  ,               - Reverse stack
   :::SSL{+       - First digit of input, concatenated to itself twice, + 12
           ,SS=   - Concatenate the digits of the original, then check if both numbers are equal
<implicit output> - Output 1 if truthy, 0 if falsy

Answer 29

Thunno 2, 4 bytes

Ṣk&⁼

Attempt This Online!

Explanation

Ṣk&⁼  # Implicit input
Ṣ     # deltas
   ⁼  #        ==
 k&   #           [1, 1]
      # Implicit output

Answer 30

Pyth, 8 Bytes

qi>3SeQT

Try online!

Explanation:

q       Q  Is the input equal to:
  <3S       The last three digits of the range from 1 to
     eQ      The last digit of the input    
 i     T      Concatenated together into an integer