Ecrivez un programme ou une fonction qui prend un entier positif. Vous pouvez supposer que la saisie est valide et la prendre comme une chaîne. Si le nombre est l'un des

123
234
345
456
567
678
789

puis sortie une valeur de vérité . Sinon, indiquez une valeur de fausseté . Par exemple, les entrées

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

doit aboutir à une sortie de fausseté. (L'entrée n'aura pas de zéros non significatifs, vous n'avez donc pas à vous soucier de choses comme 012.)

Le code le plus court en octets gagne.

Python, 24 octets

range(123,790,111).count

Fonction anonyme dont le résultat est 0 ou 1. Elle crée la liste [123, 234, 345, 456, 567, 678, 789]et compte le nombre de fois où l’entrée apparaît.

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

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

Python, 24 octets

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

Juste beaucoup de condition chaining.

Haskell, 22 octets

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

Une fonction anonyme. Génère la liste à espacement régulier [123, 234, 345, 456, 567, 678, 789]et vérifie si l'entrée est un élément.

Brachylog , 9 octets

h:2j:12+?

Essayez-le en ligne! ou Vérifiez tous les cas de test.

Crédits à Dennis pour l'algorithme .

En anglais, "(prouver que) le premier chiffre de l'entrée, concaténé deux fois, ajouter 12, est toujours l'entrée."

Python 2, 25 octets

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

Testez-le sur Ideone .

Brain-Flak 76 + 3 = 79 octets

Cette réponse est un golf de cette réponse. Je ne sais pas vraiment comment ma réponse fonctionne, mais DJMcMayhem donne une bonne explication dans sa réponse initiale et ma réponse est une modification de la sienne.

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

Il est exécuté avec le drapeau -a ascii en ajoutant 3 octets.

Explication (de toutes sortes)

À partir de la solution de travail d'origine:

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

Je lance ceci à travers un algorithme de golf simple que j'ai écrit et obtient:

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

À partir de là, je vois la section que <({}[()()()])>{}cela multiplie essentiellement par un, ce qui revient à {}[()()()]réduire le code entier à:

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

Enfin, les négatifs peuvent être combinés:

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

Brainfuck, 32 octets

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

Essayez-le en ligne!

Crédits à Lynn pour le noyau de l'algorithme.

Gelée , 6 octets

DI⁼1,1

Essayez-le en ligne! ou vérifier tous les cas de test .

Comment ça marche

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 octets

¥XX‚Q

Explication

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

Essayez-le en ligne

MATL , 8 octets

d1=tn2=*

Essayez-le en ligne!

Cela affichera 1 1pour une entrée de vérité et un tableau contenant une 0valeur de fausseté, puisque c'est faux en MATL.

Explication:

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 octets

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

Après avoir essayé plusieurs choses avec Leaky Nun dans le chat, cela semble être le plus court. Parfois, il suffit de faire les choses de manière simple: /

Explication:

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 octets

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

Explication:

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

Usage:

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

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

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

Rétine , 26 ans

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

Sorties 1 pour la vérité et 0 pour falsey.

Essayez-le en ligne (première ligne ajoutée pour permettre l'exécution de plusieurs cas de test).

Ruby, 32 30 25 + 2 = 27 octets

+2 octets pour les -nldrapeaux.

Prend une entrée sur STDIN et imprime trueou false.

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

Voir le sur repl.it: https://repl.it/DBn2/2 (Cliquez sur ▶ puis tapez une entrée dans la console ci-dessous.)

Flaque de cerveau , 99 octets

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

Essayez-le en ligne!

C'est 98 octets de code +1pour le -adrapeau.

Ceci 1affiche pour la vérité, et 0rien ou rien (ce qui équivaut à 0) pour la fausseté

Brain-Flak , 114 octets

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

Essayez-le en ligne!

Version correcte (dans l'esprit de la question): prend le nombre entier en tant qu'entrée, la sortie 0 pour falsey et 1 pour la vérité.

Ce n'est pas pile propre.

Algorithme

Laissez l'entrée être n .

La sortie est vraie si et si (n-123)(n-234)(n-345)(n-456)(n-567)(n-678)(n-789)=0 .

J'ai calculé ces sept nombres en soustrayant d'abord 12 puis en soustrayant 111 7 fois, puis j'ai calculé le double-NON logique de ces sept nombres et les ai additionnés.

Pour des résultats véridiques, la somme est 6; pour les résultats de falsey, la somme est de 7.

Ensuite, je soustrais la somme de 7 et édite la réponse.

R, 30 22 octets

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

Pas particulièrement excitant. vérifier si l' entrée se trouve dans la séquence donnée par 12 + 111k, où k est chacun 1 à 7. On notera que :précède de *sorte que la multiplication se produit après que la séquence est générée.

C # (compilateur interactif Visual C #) , 41 30 23 octets

Première soumission de code-golf, soyez 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

Essayez-le en ligne!

• -11 octets grâce à Kirill L.
• Encore 7 octets grâce à ASCII uniquement.

Brainfuck, 43 octets

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

Bah, je ne suis pas bon à ça. Les sorties\x01 si la sortie est l' une des chaînes 123, 234..., 789; les sorties\x00 autrement.

(J'ai battu Java 7, cependant…)

Essayez-le en ligne!

JavaScript ES6, 26 octets

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

Cela profite du fait que j'utilise des opérateurs logiques bit par bit sur ce qui est essentiellement booléen (qui est basé sur des bits!)

Merci à Titus d’avoir économisé 2.

Excel - 62 57 35 31 octets

Basé sur la réponse d'Anastasiya-Romanova, mais en renvoyant les TRUE/FALSEvaleurs d'Excel .

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

De plus, nous pouvons arriver à

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

depuis RIGHTet LEFTretourne un seul caractère par défaut.

Et, inspiré par certaines des solutions Python:

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

Merci à Neil pour 4 octets de plus ...

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

Brachylog (2), 7 octets

ẹ~⟦₂-_2

Essayez-le en ligne!

Explication

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

En tant que programme complet, nous obtenons un retour de vérité si toutes les affirmations sont vérifiées, un retour de Falsey si d’autres échouent.

CJam, 13 à 9 octets

A,s3ewqe=

Essayez-le en ligne!

Explication

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 octets

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

Explication:

La syntaxe de la formule IF dans Excel est la suivante:

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

Si la longueur de l'entrée N, où il s'agit d'un nom de la cellule de référence, est inférieure à 3, elle renverra Falsy . Sinon, si la longueur de l'entrée Nest 3 et que la différence du deuxième chiffre et du premier chiffre et la différence du troisième chiffre et du deuxième chiffre sont égales à 1, le résultat est renvoyé. Truthy .

Dyalog APL , 10 octets

Prend l'argument de chaîne.

1 1≡¯2-/⍎¨

1 1≡ Est {1, 1} identique à

¯2-/ la différence par paire inversée de

⍎¨ chaque caractère pris comme un nombre?

TryAPL en ligne! ( ⍎a été imité avec epour des raisons de sécurité.)

Perl, 18 octets

Comprend +1 pour -p

Exécuter avec l'entrée sur STDIN

123.pl <<< 123

123.pl:

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

PHP, 31 octets

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

Vérifiez si le premier chiffre de (nombre moins 12) est multiple de 111

PowerShell v3 +, 24 octets

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

Utilise le même truc "multiple de 111 plus 12" que certaines autres réponses, mais va dans l'autre sens. Prend les entrées $args[0], soustrait 12, divise par 111et vérifie si c'est -inla plage1..7 . Affiche une valeur booléenne true / false. Nécessite v3 + pour le-in opérateur.

Cas de 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

Code machine ARM, 18 octets

Hex dump (petit endien):

3803 d105 6808 ebc0 2010 b280 f2a0 1001 4770

C'est une fonction qui prend en longueur une paire de pointeurs pour la chaîne. La sortie est de type bash, elle affiche 0 pour vrai et une valeur non nulle pour faux. En C, la fonction serait déclarée int oneTwoThree (size_t length, char * string). Le codage des instructions est le pouce 2, qui comporte des instructions de 2 et 4 octets. Testé sur un Raspberry Pi 3.

Assemblée non-golfée:

.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 test (également assemblage):

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

Et encore une option dans JS. Prend les entrées sous forme de chaîne et les sorties 0pour falseet 1pour true.

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

Voir mes autres solutions ici et ici

L'essayer

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>