Scrivi un programma o una funzione che accetta un numero intero positivo. Puoi supporre che l'input sia valido e che possa prenderlo come una stringa. Se il numero è uno di

123
234
345
456
567
678
789

quindi emette un valore veritiero . Altrimenti, genera un valore errato . Ad esempio, gli input

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

deve comportare tutti risultati falsi. (L'input non avrà zero iniziali quindi non devi preoccuparti di cose del genere 012.)

Vince il codice più breve in byte.

Python, 24 byte

range(123,790,111).count

Una funzione anonima che genera 0 o 1. Crea l'elenco [123, 234, 345, 456, 567, 678, 789]e conta quante volte appare l'input.

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

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

Python, 24 byte

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

Solo un sacco di condizioni concatenate.

Haskell, 22 byte

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

Una funzione anonima. Genera l'elenco a spaziatura uniforme [123, 234, 345, 456, 567, 678, 789]e verifica se l'input è un elemento.

Brachylog , 9 byte

h:2j:12+?

Provalo online! oppure Verifica tutti i casi di test.

Ringraziamenti a Dennis per l'algoritmo .

In inglese, "(prova che) la prima cifra dell'Input, concatenata due volte a se stessa, aggiungi 12, è ancora l'Input".

Python 2, 25 byte

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

Provalo su Ideone .

Brain-Flak 76 + 3 = 79 byte

Questa risposta è un golf di questa risposta. In realtà non so bene come funzioni la mia risposta, ma DJMcMayhem dà una buona spiegazione nella sua risposta originale e la mia risposta è una sua modifica.

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

Viene eseguito con il flag -a ascii che aggiunge 3 byte.

Spiegazione (di sorta)

A partire dalla soluzione di lavoro originale:

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

Corro questo attraverso un semplice algoritmo di golf che ho scritto e ottengo:

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

Da qui vedo la sezione che <({}[()()()])>{}si moltiplica essenzialmente per uno che rende uguale {}[()()()]ridurre l'intero codice a:

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

Infine i negativi possono essere combinati:

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

Brainfuck, 32 byte

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

Provalo online!

Crediti a Lynn per il nucleo dell'algoritmo.

Gelatina , 6 byte

DI⁼1,1

Provalo online! o verifica tutti i casi di test .

Come funziona

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 byte

¥XX‚Q

Spiegazione

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

Provalo online

MATL , 8 byte

d1=tn2=*

Provalo online!

Questo stamperà 1 1per un input veritiero e un array con un 0in per un valore errato, poiché ciò è errato in MATL.

Spiegazione:

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 byte

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

Dopo aver provato diverse cose con Leaky Nun in chat, questo sembra essere il più breve. A volte devi solo fare le cose nel modo più semplice: /

Spiegazione:

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 byte

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

Spiegazione:

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

Uscite 1 per verità e 0 per falsità.

Provalo online (Prima riga aggiunta per consentire l'esecuzione di più testcase).

Rubino, 32 30 25 + 2 = 27 byte

+2 byte per le -nlbandiere.

Riceve input su STDIN e stampa trueo false.

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

Guardalo su repl.it: https://repl.it/DBn2/2 ( fai clic su ▶ ️ e digita input nella console in basso.)

Brain-Flak , 99 byte

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

Provalo online!

Sono 98 byte di codice +1per il -aflag.

Questo stampa 1per verità, e uno 0o niente (che equivale a 0) per falsa

Brain-Flak , 114 byte

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

Provalo online!

Versione corretta (nello spirito della domanda): prende l'intero come input, output 0 per falsey e 1 per verità.

Questo non è impilabile.

Algoritmo

Lascia che sia l'input n.

L'output è vero iff (n-123)(n-234)(n-345)(n-456)(n-567)(n-678)(n-789)=0.

Ho calcolato quei sette numeri sottraendo prima 12 e poi sottraendo 111 7 volte, quindi ho calcolato il doppio NOT logico di quei sette numeri e li ho sommati.

Per risultati veritieri, la somma è 6; per risultati falsi, la somma è 7.

Quindi sottraggo la somma da 7 e produco la risposta.

R, 30 22 byte

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

Non particolarmente eccitante; controlla se l'ingresso è nella sequenza data da 12 + 111k, dove k è ciascuno da 1 a 7. Nota che :precede *quindi la moltiplicazione avviene dopo che la sequenza è stata generata.

C # (compilatore interattivo Visual C #) , 41 30 23 byte

Prima presentazione del codice-golf, sii gentile :)

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

Provalo online!

• -11 byte grazie a Kirill L.
• Altri -7 byte grazie solo a ASCII.

Brainfuck, 43 byte

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

Bah, non sono bravo in questo. Uscite \x01se l'uscita è una delle stringhe 123, 234, ..., 789; output \x00altrimenti.

(Ho battuto Java 7, però ...)

Provalo online!

JavaScript ES6, 26 byte

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

Questo sfrutta il fatto che sto usando operatori logici bit-saggi su quelli che sono essenzialmente booleani (che sono basati su bit!)

Grazie a Titus per aver salvato 2.

Excel - 62 57 35 31 byte

Basato sulla risposta di Anastasiya-Romanova, ma che restituisce i TRUE/FALSEvalori di Excel .

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

Inoltre, possiamo arrivare a

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

poiché entrambi RIGHTe LEFTrestituiscono un singolo carattere per impostazione predefinita.

E, ispirato ad alcune delle soluzioni Python:

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

Grazie a Neil per altri 4 byte ...

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

Brachylog (2), 7 byte

ẹ~⟦₂-_2

Provalo online!

Spiegazione

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

Come programma completo, otteniamo un ritorno veritiero se tutte le asserzioni sono valide, un ritorno falso in caso di fallimento.

CJam, 13 9 byte

A,s3ewqe=

Provalo online!

Spiegazione

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 byte

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

Spiegazione:

La sintassi per la formula IF in Excel è:

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

Se la lunghezza dell'input N, dove è un nome della cella di riferimento, è inferiore a 3, restituirà Falsy . Altrimenti, se la lunghezza dell'input Nè 3 e sia la differenza tra la seconda cifra e la prima cifra e la differenza della terza cifra e della seconda cifra sono uguali a 1, allora restituirà Truthy .

Dyalog APL , 10 byte

Accetta l'argomento stringa.

1 1≡¯2-/⍎¨

1 1≡ {1, 1} è identico a

¯2-/ la differenza inversa in coppia di

⍎¨ ogni personaggio preso come un numero?

ProvaAPL online! ( ⍎è stato emulato eper motivi di sicurezza.)

Perl, 18 byte

Include +1 per -p

Esegui con l'input su STDIN

123.pl <<< 123

123.pl:

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

PHP, 31 byte

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

Controlla se la prima cifra di (numero meno 12) è multipla di 111

PowerShell v3 +, 24 byte

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

Utilizza lo stesso trucco "multiplo di 111 più 12" di alcune altre risposte, ma va nella direzione opposta. Accetta input $args[0], sottrae 12, divide 111e verifica se questo è -inl'intervallo 1..7. Emette un valore vero / falso booleano. Richiede v3 + per l' -inoperatore.

Casi test

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

Codice macchina ARM, 18 byte

Dump esadecimale (little endian):

3803 d105 6808 ebc0 2010 b280 f2a0 1001 4770

Questa è una funzione che accetta una lunghezza, una coppia di puntatori per la stringa. L'output è in stile bash, genera 0 per true e un valore diverso da zero per false. In C la funzione verrebbe dichiarata in oneTwoThree (size_t lunghezza, char * stringa). La codifica delle istruzioni è thumb-2, che ha istruzioni a 2 e 4 byte. Testato su un Raspberry Pi 3.

Assemblea non golfata:

.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 di test (anche assembly):

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

E un'altra opzione in JS. Accetta input come stringa e output 0per falsee 1per true.

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

Vedi le mie altre soluzioni qui e qui

Provalo

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>