Escreva um programa ou função que receba um número inteiro positivo. Você pode assumir que a entrada é válida e pode tomá-la como uma sequência. Se o número for qualquer um

123
234
345
456
567
678
789

em seguida, imprima um valor de verdade . Caso contrário, imprima um valor falso . Por exemplo, as entradas

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

todos devem resultar em saída falsa. (A entrada não terá zeros à esquerda, portanto você não precisa se preocupar com coisas assim 012.)

O código mais curto em bytes vence.

Python, 24 bytes

range(123,790,111).count

Uma função anônima que gera 0 ou 1. Cria a lista [123, 234, 345, 456, 567, 678, 789]e conta quantas vezes a entrada aparece.

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

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

Python, 24 bytes

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

Apenas um monte de encadeamento de condições.

Haskell, 22 bytes

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

Uma função anônima. Gera a lista com espaçamento uniforme [123, 234, 345, 456, 567, 678, 789]e verifica se a entrada é um elemento.

Braquilog , 9 bytes

h:2j:12+?

Experimente online! ou Verifique todos os casos de teste.

Créditos a Dennis pelo algoritmo .

Em inglês, "(prove que) o primeiro dígito da entrada, concatenado para si mesmo duas vezes, adicione 12, ainda é a entrada".

Python 2, 25 bytes

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

Teste em Ideone .

Flacidez cerebral 76 + 3 = 79 bytes

Esta resposta é um golfe desta resposta. Na verdade, eu não sei bem como minha resposta funciona, mas DJMcMayhem fornece uma boa explicação em sua resposta original e minha resposta é uma modificação na dele.

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

É executado com o sinalizador -a ascii adicionando 3 bytes.

Explicação (das sortes)

Começando com a solução de trabalho original:

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

Eu corro isso através de um algoritmo simples de golfe que escrevi e recebo:

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

A partir daqui, vejo a seção que se <({}[()()()])>{}multiplica essencialmente por uma que torna igual a {}[()()()]redução de todo o código para:

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

Por fim, os negativos podem ser combinados:

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

Brainfuck, 32 bytes

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

Experimente online!

Créditos ao Lynn pelo núcleo do algoritmo.

Gelatina , 6 bytes

DI⁼1,1

Experimente online! ou verifique todos os casos de teste .

Como funciona

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 bytes

¥XX‚Q

Explicação

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

Experimente online

MATL , 8 bytes

d1=tn2=*

Experimente online!

Isso imprimirá 1 1 para uma entrada verdadeira e uma matriz com uma 0para um valor falso, já que isso é falso no MATL.

Explicação:

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 bytes

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

Depois de tentar várias coisas com a Freira Furada no bate-papo, isso parece ser o mais curto. Às vezes, você só precisa fazer as coisas da maneira direta: /

Explicação:

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 bytes

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

Explicação:

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

Uso:

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

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

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

Retina , 26

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

Saídas 1 para verdade e 0 para falsey.

Experimente on-line (primeira linha adicionada para permitir a execução de vários casos de teste).

Ruby, 32 30 25 + 2 = 27 bytes

+2 bytes para -nl sinalizadores.

Recebe entrada em STDIN e imprime trueou false.

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

Veja em repl.it: https://repl.it/DBn2/2 (Clique em ▶ ️ e digite entrada no console abaixo.)

Brain-Flak , 99 bytes

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

Experimente online!

São 98 bytes de código +1para o -asinalizador.

Isso imprime 1por verdade, e um 0ou nada (que é equivalente a 0) para falsificação

Flacidez Cerebral , 114 bytes

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

Experimente online!

Versão correta (no espírito da pergunta): pega o número inteiro como entrada, gera 0 para falsey e 1 para verdade.

Isso não é pilha limpa.

Algoritmo

Deixe a entrada ser n.

A saída é verdadeira se (n-123)(n-234)(n-345)(n-456)(n-567)(n-678)(n-789)=0.

Calculei esses sete números primeiro subtraindo 12 e depois subtraí 111 7 vezes, e depois calculei o NÃO duplo lógico desses sete números e os somei.

Para resultados de verdade, a soma é 6; para resultados de falsey, a soma é 7.

Então, subtraio a soma de 7 e produzo a resposta.

R, 30 22 bytes

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

Não é particularmente emocionante; verifique se a entrada está na sequência fornecida por 12 + 111k, onde k é cada um de 1 a 7. Observe que :precede *que a multiplicação ocorra após a geração da sequência.

C # (compilador interativo do Visual C #) , 41 30 23 bytes

Primeiro envio de código-golfe, seja gentil :)

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

Experimente online!

• -11 bytes graças a Kirill L.
• Outros -7 bytes, graças apenas ao ASCII.

Brainfuck, 43 bytes

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

Bah, eu não sou bom nisso. Saídas \x01Se a saída for uma das cordas 123, 234, ..., 789; saídas \x00caso contrário.

(Eu venci o Java 7, no entanto ...)

Experimente online!

JavaScript ES6, 26 bytes

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

Isso tira vantagem do fato de eu estar usando operadores lógicos em bits no que são essencialmente booleanos (que são baseados em bits!)

Agradecimentos a Titus por salvar 2.

Excel - 62 57 35 31 bytes

Com base na resposta de Anastasiya-Romanova, mas retornando os TRUE/FALSEvalores do Excel .

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

Além disso, podemos chegar a

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

desde que ambos RIGHTeLEFT retornam um único caractere por padrão.

E, inspirado por algumas das soluções Python:

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

Obrigado a Neil por mais 4 bytes ...

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

Braquilog (2), 7 bytes

ẹ~⟦₂-_2

Experimente online!

Explicação

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

Como um programa completo, obtemos um retorno verdadeiro, se todas as afirmações se mantiverem, um retorno falsey, se houver alguma falha.

CJam, 13 9 bytes

A,s3ewqe=

Experimente online!

Explicação

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 bytes

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

Explicação:

A sintaxe da fórmula SE no Excel é:

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

Se o comprimento da entrada N, onde é o nome da célula de referência, for menor que 3, ele retornará o Falsy . Caso contrário, se o comprimento da entrada Nfor 3 e a diferença do segundo e do primeiro dígito e a diferença do terceiro e do segundo dígitos forem iguais a 1, retornará Truthy .

Dyalog APL , 10 bytes

Aceita argumento de string.

1 1≡¯2-/⍎¨

1 1≡ É {1, 1} idêntico a

¯2-/ a diferença inversa entre pares de

⍎¨ cada caractere tomado como um número?

TryAPL online! ( ⍎foi copiado epor motivos de segurança.)

Perl, 18 bytes

Inclui +1 para -p

Execute com a entrada em STDIN

123.pl <<< 123

123.pl:

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

PHP, 31 bytes

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

Verifique se o primeiro dígito de (número menos 12) é múltiplo de 111

PowerShell v3 +, 24 bytes

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

Usa o mesmo truque "múltiplo de 111 mais 12" como algumas outras respostas, mas segue na outra direção. Recebe entrada$args[0] , subtrai 12, divide por 111e verifica se esse é -ino intervalo 1..7. Gera um valor booleano verdadeiro / falso. Requer v3 + para o-in operador.

Casos de teste

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

Código da máquina ARM, 18 bytes

Despejo hexadecimal (little endian):

3803 d105 6808 ebc0 2010 b280 f2a0 1001 4770

Essa é uma função que possui um par de ponteiros de comprimento para a sequência. A saída é no estilo bash, gera 0 para true e um valor diferente de zero para false. Em C, a função seria declarada int oneTwoThree (size_t length, char * string). A codificação da instrução é thumb-2, que possui instruções de 2 e 4 bytes. Testado em um Raspberry Pi 3.

Montagem não destruída:

.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

Script de teste (também montagem):

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

E mais uma opção em JS. Recebe entrada como uma sequência e gera 0para falsee 1para true.

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

Veja minhas outras soluções aqui e aqui

Tente

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>