양의 정수를받는 프로그램이나 함수를 작성하십시오. 입력이 유효하다고 가정하고 문자열로 사용할 수 있습니다. 숫자가

123
234
345
456
567
678
789

그런 다음 진실한 가치 를 산출하십시오 . 그렇지 않으면 거짓 값을 출력하십시오 . 예를 들어, 입력

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

모두 잘못된 결과를 초래해야합니다. (입력에는 선행 0이 없으므로 다음과 같은 것에 대해 걱정할 필요가 없습니다 012.)

바이트 단위의 가장 짧은 코드가 이깁니다.

파이썬, 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

파이썬, 24 바이트

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

많은 조건 체인.

하스켈, 22 바이트

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

익명의 기능. 균등 간격 목록을 생성하고 [123, 234, 345, 456, 567, 678, 789]입력이 요소인지 확인합니다.

Brachylog , 9 바이트

h:2j:12+?

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오.

알고리즘에 대한 Dennis의 크레딧 .

영어에서 "(증명) 입력의 첫 번째 숫자는 두 번 연결되어 12를 추가해도 여전히 입력입니다."

파이썬 2, 25 바이트

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

Ideone에서 테스트하십시오 .

Brain-Flak 76 + 3 = 79 바이트

이 답변의 골프 인 이 대답. 나는 실제로 내 대답이 어떻게 작동하는지 잘 모르겠지만 DJMcMayhem은 그의 원래 대답에 좋은 설명을 제공하며 내 대답은 그의 수정입니다.

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

3 바이트를 추가하는 -a ascii 플래그로 실행됩니다.

설명 (정렬)

원래 작업 솔루션으로 시작 :

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

나는 내가 작성한 간단한 골프 알고리즘을 통해 이것을 실행하고 얻는다 :

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

여기에서 나는 <({}[()()()])>{}이것이 {}[()()()]전체 코드를 줄이는 것과 동등한 섹션을 본질적으로 곱하는 부분을 ​​본다 :

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

마지막으로 네거티브를 결합 할 수 있습니다.

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

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

온라인으로 사용해보십시오!

이것은 MATL에서는 거짓이기 때문에 1 1정확한 입력을 위해, 그리고 0잘못된 값을 위해 그 안에 배열을 인쇄 합니다 .

설명:

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

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

펄 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$

truey이면 1을 출력하고 false이면 0을 출력합니다.

온라인으로 사용해보십시오 (첫 번째 행이 추가되어 여러 테스트 케이스를 실행할 수 있음).

루비, 32 30 25 + 2 = 27 바이트

-nl플래그의 경우 +2 바이트

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 번 빼서 7 개의 숫자를 계산 한 다음 7 개의 숫자의 논리적 이중 -NOT를 계산하여 더했습니다.

진실한 결과의 합은 6입니다. 잘못된 결과의 경우 합계는 7입니다.

그런 다음 7에서 합계를 빼고 답을 출력합니다.

R, 30 22 바이트

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

특별히 흥미롭지 않은; 체크 k는 1 내지 7 참고 각 여기서 입력 + 111K (12)에 의해 주어진 순서에 있으면 :선행를 *시퀀스를 생성 한 후, 승산이 발생되도록.

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

온라인으로 사용해보십시오!

• Kirill L 덕분에 -11 바이트
• ASCII 전용 덕분에 또 다른 -7 바이트.

Brainfuck, 43 바이트

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

바, 난 이거 잘 못해 출력 \x01출력 문자열 중 하나 인 경우 123, 234, ... 789; 출력\x00그렇지 않으면 합니다.

(하지만 Java 7을 이겼습니다 ...)

온라인으로 사용해보십시오!

자바 스크립트 ES6, 26 바이트

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

이것은 본질적으로 부울 (비트 기반)에 비트 단위 논리 연산자를 사용한다는 사실을 이용합니다.

2를 저장해 준 Titus에게 감사합니다.

엑셀 -62 57 35 31 bytes

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)

4 바이트를 더한 Neil 덕분에 ...

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

엑셀-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참조 셀의 이름 인 input의 길이 가 3보다 작 으면 Falsy 를 반환 합니다 . 그렇지 않으면 입력 길이 N가 3이고 두 번째 숫자와 첫 번째 숫자의 차이와 세 번째 숫자와 두 번째 숫자의 차이가 모두 1이면 Truthy 를 반환 합니다 .

Dyalog APL , 10 바이트

문자열 인수를 취합니다.

1 1≡¯2-/⍎¨

1 1≡ {1, 1}은 (는)

¯2-/ 반전 된 쌍별 차이

⍎¨ 각 문자는 숫자로?

TryAPL 온라인! ( 보안상의 이유로 ⍎에뮬레이션되었습니다 e.)

펄, 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인지 확인합니다 . 부울 참 / 거짓 값을 출력합니다. 연산자 에는 v3 +가 필요합니다 .-in1..7-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 바이트

16 진 덤프 (little endian) :

3803 d105 6808 ebc0 2010 b280 f2a0 1001 4770

문자열의 길이, 포인터 쌍을 취하는 함수입니다. 출력은 bash 스타일이며, 0은 true이고 0이 아닌 값은 false입니다. C에서 함수는 int oneTwoThree (size_t length, char * string)로 선언됩니다. 명령어 인코딩은 thumb-2이며 2와 4 바이트 명령어가 있습니다. 라즈베리 파이 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}

자바 스크립트 (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>