Schreiben Sie ein Programm oder eine Funktion, die eine positive Ganzzahl enthält. Sie können davon ausgehen, dass die Eingabe gültig ist und als Zeichenfolge verwendet werden kann. Wenn die Nummer eine von ist

123
234
345
456
567
678
789

Geben Sie dann einen Wahrheitswert aus . Andernfalls geben Sie einen falschen Wert aus. Zum Beispiel die Eingänge

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

müssen alle zu einer falschen Ausgabe führen. (Die Eingabe wird keine führenden Nullen haben, sodass Sie sich nicht um Dinge wie kümmern müssen 012.)

Der kürzeste Code in Bytes gewinnt.

Python, 24 Bytes

range(123,790,111).count

Eine anonyme Funktion, die 0 oder 1 ausgibt. Sie erstellt die Liste [123, 234, 345, 456, 567, 678, 789]und zählt, wie oft die Eingabe erscheint.

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

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

Python, 24 Bytes

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

Nur eine Menge Zustandsverkettung.

Haskell, 22 Bytes

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

Eine anonyme Funktion. Erzeugt die gleichmäßig verteilte Liste [123, 234, 345, 456, 567, 678, 789]und prüft, ob die Eingabe ein Element ist.

Brachylog , 9 Bytes

h:2j:12+?

Probieren Sie es online! oder Überprüfen Sie alle Testfälle.

Dank an Dennis für den Algorithmus .

Auf Englisch ist "(beweisen Sie, dass) die erste Ziffer der Eingabe, die zweimal mit sich selbst verknüpft ist, also 12, immer noch die Eingabe."

Python 2, 25 Bytes

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

Teste es auf Ideone .

Brain-Flak 76 + 3 = 79 Bytes

Diese Antwort ist ein Golf dieser Antwort. Eigentlich weiß ich nicht genau, wie meine Antwort funktioniert, aber DJMcMayhem gibt in seiner ursprünglichen Antwort eine gute Erklärung und meine Antwort ist eine Modifikation seiner.

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

Es wird mit dem -a ASCII-Flag ausgeführt, das 3 Bytes hinzufügt.

Erklärung (von Art)

Ausgehend von der ursprünglichen Arbeitslösung:

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

Ich führe dies durch einen einfachen Golfalgorithmus, den ich geschrieben habe und erhalte:

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

Von hier aus sehe ich den Abschnitt, der im <({}[()()()])>{}Wesentlichen mit eins multipliziert wird, was es gleich macht {}[()()()], den gesamten Code auf Folgendes zu reduzieren:

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

Zuletzt können Negative kombiniert werden:

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

Brainfuck, 32 Bytes

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

Probieren Sie es online!

Dank an Lynn für den Kern des Algorithmus.

Gelee , 6 Bytes

DI⁼1,1

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

Erläuterung

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

Probieren Sie es online aus

MATL , 8 Bytes

d1=tn2=*

Probieren Sie es online!

Dies wird 1 1für eine wahrheitsgemäße Eingabe und ein Array mit einem 0darin enthaltenen Wert für einen falschen Wert ausgegeben, da dies in MATL falsch ist.

Erläuterung:

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

Nachdem Sie im Chat einige Dinge mit Leaky Nun ausprobiert haben, scheint dies die kürzeste zu sein. Manchmal muss man es einfach so machen: /

Erläuterung:

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)

Erläuterung:

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

Verwendung:

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

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

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

Retina , 26

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

Gibt 1 für wahr und 0 für falsch aus.

Probieren Sie es online aus (Erste Zeile hinzugefügt, damit mehrere Testfälle ausgeführt werden können).

Rubin, 32 30 25 + 2 = 27 Bytes

+2 Bytes für -nl Flags.

Übernimmt die Eingabe für STDIN und druckt trueoder false.

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

Siehe es auf repl.it: https://repl.it/DBn2/2 (Klicken Sie auf ▶ ️ und geben Sie die Eingabe in die Konsole unten ein.)

Brain-Flak , 99 Bytes

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

Probieren Sie es online!

Dies sind 98 Byte Code +1für die-a Flag.

Dies wird 1für Wahrhaftigkeit und entweder 0oder nichts (was 0 entspricht) für Falsch ausgegeben

Brain-Flak , 114 Bytes

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

Probieren Sie es online!

Richtige Version (im Sinne der Frage): Nimmt die ganze Zahl als Eingabe, gibt 0 für Falsey und 1 für Truthy aus.

Dies ist nicht stapelrein.

Algorithmus

Lass die Eingabe sein n.

Die Ausgabe ist wahr iff (n-123)(n-234)(n-345)(n-456)(n-567)(n-678)(n-789)=0.

Ich berechnete diese sieben Zahlen, indem ich zuerst 12 subtrahierte und dann 111 siebenmal subtrahierte, und dann das logische Doppel-NICHT dieser sieben Zahlen berechnete und sie aufsummierte.

Für wahrheitsgemäße Ergebnisse ist die Summe 6; für falsche Ergebnisse ist die Summe 7.

Dann subtrahiere ich die Summe von 7 und gebe die Antwort aus.

R 30 22 Bytes

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

Nicht besonders aufregend; überprüfen , ob Eingang wird in der durch 12 + 111k gegebene Reihenfolge, wobei k jeweils 1 bis 7. Man beachte , daß ist :vorausgeht , *so dass die Multiplikation passiert , nachdem die Sequenz erzeugt wird.

C # (Visual C # Interactive Compiler) , 41 30 23 Byte

Erste Code-Golf-Einreichung, sei sanft :)

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

Probieren Sie es online!

• -11 Bytes dank Kirill L.
• Weitere -7 Bytes nur dank ASCII.

Brainfuck, 43 Bytes

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

Bah, ich bin nicht gut darin. Ausgaben, \x01wenn die Ausgabe eine der Zeichenfolgen 123ist ,, 234… 789,; Ausgänge \x00sonst.

(Ich habe Java 7 geschlagen ...)

Probieren Sie es online!

JavaScript ES6, 26 Byte

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

Dies macht sich die Tatsache zunutze, dass ich bitweise Logikoperatoren für im Wesentlichen boolesche Operatoren (die bitbasiert sind!) Verwende.

Vielen Dank an Titus für das Speichern von 2.

Excel - 62 57 35 31 Bytes

Basiert auf der Antwort von Anastasiya-Romanova, gibt aber die Excel- TRUE/FALSEWerte zurück.

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

Weiter können wir kommen

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

da beide RIGHTund LEFTstandardmäßig ein einzelnes Zeichen zurück.

Und inspiriert von einigen der Python-Lösungen:

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

Vielen Dank an Neil für 4 weitere Bytes ...

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

Brachylog (2), 7 Bytes

ẹ~⟦₂-_2

Probieren Sie es online!

Erläuterung

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

Als vollständiges Programm erhalten wir eine echte Rendite, wenn alle Behauptungen zutreffen, und eine falsche Rendite, wenn eine fehlschlägt.

CJam, 13 9 Bytes

A,s3ewqe=

Probieren Sie es online!

Erläuterung

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

Erläuterung:

Die Syntax für die IF-Formel in Excel lautet:

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

Wenn die Länge der Eingabe N, bei der es sich um einen Namen der Referenzzelle handelt, weniger als 3 beträgt, wird Falsy zurückgegeben . Anderenfalls, wenn die Länge der Eingabe N3 ist und sowohl die Differenz der zweiten als auch der ersten Ziffer und die Differenz der dritten und der zweiten Ziffer gleich 1 sind, wird Truthy zurückgegeben .

Dyalog APL , 10 Bytes

Übernimmt ein String-Argument.

1 1≡¯2-/⍎¨

1 1≡ Ist {1, 1} identisch mit

¯2-/ die umgekehrte paarweise Differenz von

⍎¨ jedes Zeichen als Zahl genommen?

TryAPL online! ( ⍎Wurde eaus Sicherheitsgründen mit emuliert .)

Perl, 18 Bytes

Beinhaltet +1 für -p

Führen Sie mit der Eingabe auf STDIN

123.pl <<< 123

123.pl:

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

PHP, 31 Bytes

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

Überprüfen Sie, ob die erste Ziffer von (Zahl minus 12) ein Vielfaches von 111 ist

PowerShell v3 +, 24 Byte

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

Verwendet den gleichen Trick "Vielfaches von 111 plus 12" wie einige andere Antworten, geht aber in die andere Richtung. Nimmt Eingaben auf $args[0], subtrahiert 12, dividiert durch 111und prüft, ob dies -inder Bereich ist 1..7. Gibt einen booleschen True / False-Wert aus. Benötigt v3 + für den -inOperator.

Testfälle

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-Maschinencode, 18 Byte

Hex Dump (Little Endian):

3803 d105 6808 ebc0 2010 b280 f2a0 1001 4770

Dies ist eine Funktion, die ein Länge-Zeiger-Paar für den String benötigt. Die Ausgabe ist bash-artig, sie gibt 0 für wahr und einen Wert ungleich null für falsch aus. In C würde die Funktion als int oneTwoThree deklariert (size_t length, char * string). Die Befehlskodierung ist thumb-2, die 2- und 4-Byte-Befehle enthält. Getestet auf einem Raspberry Pi 3.

Ungolfed Versammlung:

.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

Testskript (auch 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

Und noch eine Option in JS. Nimmt Eingaben als String und gibt sie 0für falseund 1für aus true.

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

Sehen Sie meine anderen Lösungen hier und hier

Versuch es

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>