Escriba un programa o función que tome un entero positivo. Puede suponer que la entrada es válida y puede tomarla como una cadena. Si el número es cualquiera de

123
234
345
456
567
678
789

luego genera un valor verdadero . De lo contrario, genera un valor falso . Por ejemplo, las entradas

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

todo debe dar como resultado una salida falsa. (La entrada no tendrá ceros a la izquierda, por lo que no debe preocuparse por cosas como 012).

El código más corto en bytes gana.

Python, 24 bytes

range(123,790,111).count

Una función anónima que genera 0 o 1. Crea la lista [123, 234, 345, 456, 567, 678, 789]y cuenta cuántas veces aparece la entrada.

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

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

Python, 24 bytes

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

Solo muchas condiciones encadenando.

Haskell, 22 bytes

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

Una función anónima. Genera la lista espaciada uniformemente [123, 234, 345, 456, 567, 678, 789]y comprueba si la entrada es un elemento.

Brachylog , 9 bytes

h:2j:12+?

Pruébalo en línea! o Verificar todos los casos de prueba.

Créditos a Dennis por el algoritmo .

En inglés, "(demuestre que) el primer dígito de la entrada, concatenado consigo mismo dos veces, agregue 12, sigue siendo la entrada".

Python 2, 25 bytes

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

Pruébalo en Ideone .

Brain-Flak 76 + 3 = 79 bytes

Esta respuesta es un golf de esta respuesta. En realidad no sé cómo funciona mi respuesta, pero DJMcMayhem da una buena explicación en su respuesta original y mi respuesta es una modificación de la suya.

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

Se ejecuta con el indicador -a ascii que agrega 3 bytes.

Explicación (de algún tipo)

Comenzando con la solución de trabajo original:

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

Ejecuté esto a través de un algoritmo de golf simple que escribí y obtengo:

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

Desde aquí veo la sección que <({}[()()()])>{}esencialmente se multiplica por uno, lo que hace que sea igual {}[()()()]reducir todo el código a:

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

Por último, los negativos se pueden combinar:

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

Brainfuck, 32 bytes

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

Pruébalo en línea!

Créditos a Lynn por el núcleo del algoritmo.

Jalea , 6 bytes

DI⁼1,1

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo 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

Explicación

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

Pruébalo en línea

MATL , 8 bytes

d1=tn2=*

Pruébalo en línea!

Esto imprimirá 1 1para una entrada veraz y una matriz con un0 valor falso, ya que eso es falso en MATL.

Explicación:

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

Después de probar varias cosas con Leaky Nun en el chat, esta parece ser la más corta. A veces solo tienes que hacer las cosas de la manera más sencilla: /

Explicación:

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)

Explicación:

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

Salidas 1 para la verdad y 0 para falsey.

Pruébelo en línea (se agregó la primera línea para permitir la ejecución de múltiples casos de prueba)

Ruby, 32 30 25 + 2 = 27 bytes

+2 bytes para -nlbanderas.

Toma entrada en STDIN e imprime trueo false.

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

Véalo en repl.it: https://repl.it/DBn2/2 (Haga clic en ▶ ️ y luego escriba input en la consola a continuación).

Brain-Flak , 99 bytes

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

Pruébalo en línea!

Esto es 98 bytes de código +1para la -abandera.

Esto imprime 1para la verdad, y una 0o ninguna (que es equivalente a 0) para la falsedad

Brain-Flak , 114 bytes

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

Pruébalo en línea!

Versión correcta (en el espíritu de la pregunta): toma el entero como entrada, salida 0 para falsey y 1 para verdadero.

Esto no es una pila limpia.

Algoritmo

Deje que la entrada sea n.

La salida es veraz iff (n-123)(n-234)(n-345)(n-456)(n-567)(n-678)(n-789)=0.

Calculé esos siete números restando primero 12 y luego restando 111 7 veces, y luego calculé el NOT lógico doble de esos siete números y los sumé.

Para resultados verdaderos, la suma es 6; para los resultados de falsey, la suma es 7.

Luego, resto la suma de 7 y envío la respuesta.

R, 30 22 bytes

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

No particularmente emocionante; compruebe si la entrada está en la secuencia dada por 12 + 111k, donde k es cada uno de 1 a 7. Tenga en cuenta que :precede a *la multiplicación después de que se genera la secuencia.

C # (compilador interactivo de Visual C #) , 41 30 23 bytes

Primera presentación de código de golf, sé amable :)

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

Pruébalo en línea!

• -11 bytes gracias a Kirill L.
• Otros -7 bytes gracias a ASCII-only.

Brainfuck, 43 bytes

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

Bah, no soy bueno en esto. Salidas \x01Si la salida es una de las cadenas 123, 234, ..., 789; salidas de lo \x00contrario.

(Pero vencí a Java 7 ...)

Pruébalo en línea!

JavaScript ES6, 26 bytes

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

Esto aprovecha el hecho de que estoy usando operadores lógicos de bits en lo que son esencialmente booleanos (¡que están basados ​​en bits!)

Gracias a Titus por salvar 2.

Excel - 62 57 35 31 bytes

Basado en la respuesta de Anastasiya-Romanova, pero devolviendo los TRUE/FALSEvalores de Excel .

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

Además, podemos llegar a

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

ya que ambos RIGHTyLEFT devuelve un solo carácter por defecto.

Y, inspirado en algunas de las soluciones de Python:

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

Gracias a Neil por 4 bytes más ...

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

Brachylog (2), 7 bytes

ẹ~⟦₂-_2

Pruébalo en línea!

Explicación

ẹ~⟦₂-_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 programa completo, obtenemos un verdadero retorno si todas las afirmaciones se mantienen, un falso retorno si alguno falla.

CJam, 13 9 bytes

A,s3ewqe=

Pruébalo en línea!

Explicación

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

Explicación:

La sintaxis para la fórmula IF en Excel es:

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

Si la longitud de la entrada N, donde es un nombre de la celda de referencia, es menor que 3, entonces devolverá Falsy . De lo contrario, si la longitud de entrada Nes 3 y la diferencia entre el segundo dígito y el primer dígito y la diferencia entre el tercer dígito y el segundo dígito son iguales a 1, entonces devolverá Verdad .

Dyalog APL , 10 bytes

Toma un argumento de cadena.

1 1≡¯2-/⍎¨

1 1≡ Es {1, 1} idéntico a

¯2-/ la diferencia inversa en pares de

⍎¨ cada personaje tomado como un número?

TryAPL en línea! ( ⍎ha sido emulado epor razones de seguridad).

Perl, 18 bytes

Incluye +1 para -p

Ejecutar con la entrada en STDIN

123.pl <<< 123

123.pl:

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

PHP, 31 bytes

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

Compruebe si el primer dígito de (número menos 12) es múltiplo de 111

PowerShell v3 +, 24 bytes

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

Utiliza el mismo truco "múltiplo de 111 más 12" que otras respuestas, pero va en la otra dirección. Toma entrada $args[0], resta 12, divide 111y comprueba si ese es -inel rango 1..7. Emite un valor booleano verdadero / falso. Requiere v3 + para-in operador.

Casos de prueba

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 de máquina ARM, 18 bytes

Hex dump (little endian):

3803 d105 6808 ebc0 2010 b280 f2a0 1001 4770

Esta es una función que toma un par de punteros de longitud para la cadena. La salida es de estilo bash, emite 0 para verdadero y un valor distinto de cero para falso. En C, la función se declararía int oneTwoThree (size_t length, char * string). La codificación de instrucciones es thumb-2, que tiene instrucciones de 2 y 4 bytes. Probado en una Raspberry Pi 3.

Asamblea sin golf:

.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 prueba (también ensamblado):

.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

Y una opción más en JS. Toma la entrada como una cadena y las salidas 0para falsey 1para true.

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

Vea mis otras soluciones aquí y aquí

Intentalo

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>