Напишите программу или функцию, которая принимает положительное целое число. Вы можете предположить, что ввод действителен и может принимать его как строку. Если номер любой из

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]и проверяет, является ли ввод элементом.

Брахилог , 9 байт

h:2j:12+?

Попробуйте онлайн! или Проверьте все контрольные примеры.

Кредиты Денису за алгоритм .

По-английски: «(докажите, что) первая цифра входа, соединенная с ним дважды, добавьте 12, по-прежнему является входом».

Python 2, 25 байт

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

Проверьте это на Ideone .

Brain-Flak 76 + 3 = 79 байт

Этот ответ - гольф этого ответа. На самом деле я не совсем понимаю, как работает мой ответ, но DJMcMayhem дает хорошее объяснение в своем первоначальном ответе, и мой ответ является его модификацией.

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

Он запускается с флагом -a ascii, добавляющим 3 байта.

Пояснение (сортов)

Начиная с оригинального рабочего решения:

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

Я запускаю это через простой алгоритм игры в гольф, который я написал, и получаю:

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

Отсюда я вижу раздел, который по <({}[()()()])>{}существу умножается на единицу, что делает его равным {}[()()()]уменьшению всего кода до:

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

Наконец негативы могут быть объединены:

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

Brainfuck, 32 байта

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

Попробуйте онлайн!

Кредиты Линн за ядро ​​алгоритма.

Желе , 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 для фальси.

Попробуйте онлайн (добавлена ​​первая строка, позволяющая запускать несколько тестовых случаев).

Рубин, 32 30 25 + 2 = 27 байт

+2 байта для -nlфлагов.

Принимает ввод на STDIN и печатает trueили false.

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

Смотрите его на repl.it: https://repl.it/DBn2/2 (Нажмите ▶ ️, а затем введите ввод в консоли ниже.)

Brain-Flak , 99 байтов

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

Попробуйте онлайн!

Это 98 байт кода +1для -aфлага.

Это печатает 1для правды, и либо 0или ничего (что эквивалентно 0) для фальсификации

Brain-Flak , 114 байт

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

Попробуйте онлайн!

Правильная версия (в духе вопроса): принимает целое число в качестве входных данных, выводит 0 для фальси и 1 для истинного.

Это не чистый стек.

Алгоритм

Пусть вход будет n.

Вывод правдив, если (n-123)(n-234)(n-345)(n-456)(n-567)(n-678)(n-789)=0.

Я вычислил эти семь чисел, сначала вычтя 12, а затем вычти 111 7 раз, а затем вычислил логическое двойное НЕ из этих семи чисел и сложил их.

Для достоверных результатов сумма равна 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 байт благодаря Кириллу Л.
• Еще -7 байт благодаря ASCII-только.

Brainfuck, 43 байта

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

Бах, я не очень хорош в этом. Выходы , \x01если выход является одной из строк 123, 234..., 789; выводит \x00иначе.

(Я бью Java 7, хотя ...)

Попробуйте онлайн!

JavaScript ES6, 26 байт

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

Это использует тот факт, что я использую побитовые логические операторы для того, что по сути является логическим (которые основаны на битах!)

Спасибо Титу за спасение 2.

Excel - 62 57 35 31 байт

Основано на ответе Анастасии-Романовой, но возвращает TRUE/FALSEзначения Excel .

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

Спасибо Нейлу за еще 4 байта ...

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

Брахилог (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"))

Объяснение:

Синтаксис формулы IF в Excel:

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

Если длина ввода N, где это имя ссылочной ячейки, меньше 3, то она вернет Falsy . Иначе, если длина ввода Nравна 3, а разность второй цифры и первой цифры, а также разница третьей и второй цифры равна 1, возвращается значение « Истина» .

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. Требуется v3 + для -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 байт

Шестнадцатеричный дамп (little endian):

3803 d105 6808 ebc0 2010 b280 f2a0 1001 4770

Эта функция принимает пару указателей длины для строки. Вывод в стиле bash, он выводит 0 для true и ненулевое значение для false. В Си функция будет объявлена ​​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>