# Tak łatwe jak jeden-dwa-trzy

35

Napisz program lub funkcję, która przyjmuje dodatnią liczbę całkowitą. Możesz założyć, że dane wejściowe są prawidłowe i możesz je traktować jako ciąg. Jeśli liczba jest dowolna z

``````123
234
345
456
567
678
789
``````

następnie wypisz prawdziwą wartość. W przeciwnym razie wypisz wartość fałszowania . Na przykład dane wejściowe

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

wszystkie muszą skutkować wynikiem fałszowania. (Dane wejściowe nie będą miały zer wiodących, więc nie musisz się martwić takimi rzeczami `012`.)

Najkrótszy kod w bajtach wygrywa.

Och, łańcuchy są dozwolone? Co z tablicami cyfrowymi?
Dennis

@Dennis Nie. Trzymajmy to zwykłe ciągi znaków lub zwykłe int.
Calvin's Hobbies

6
Jeśli wezmę ciąg znaków, czy powinienem to obsługiwać `012`?
Lynn,

1
@ Lynn No. `012`byłoby fałszem, ale możesz założyć, że nie jest wprowadzane.
Calvin's Hobbies

1
@ BradGilbertb2gills Nie. Powinien on po prostu spełniać powiązaną definicję prawdy / falsy - meta.codegolf.stackexchange.com/questions/2190/…
Calvin's Hobbies

Odpowiedzi:

46

## Python, 24 bajty

``range(123,790,111).count``

Anonimowa funkcja, która wyprowadza 0 lub 1. Tworzy listę `[123, 234, 345, 456, 567, 678, 789]`i zlicza, ile razy pojawi się wejście.

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

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

Czy nie możesz usunąć bajtu, rozpoczynając od 12 zamiast 123?
var firstName

1
Nie musi zawierać 12.
xnor

Ale możemy założyć, że to nie będzie dane wejściowe? Jestem zdezorientowany
var firstName

1
Jeśli mówisz o komentarzach, mówią, że jeśli weźmiesz dane wejściowe jako ciąg (co nie jest), możesz spodziewać się, że liczby nie będą miały zer wiodących, więc 12 będzie podane jako „12”, a nie „ 012 ”.
xnor

34

## Python, 24 bajty

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

Po prostu wiele łańcuchów warunków.

Możliwość porównania zakresu, który z łatwością pokonuje dowolny język, który już znam. Musiałem to sprawdzić, żeby zobaczyć, jak to działa.
GuitarPicker,

Wow, gdyby nie to słowo `lambda`, nie zgadłbym nawet, że to Python. To okropne.
Steve Bennett,

25

## Haskell, 22 bajty

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

Anonimowa funkcja. Generuje listę o równych odstępach `[123, 234, 345, 456, 567, 678, 789]`i sprawdza, czy dane wejściowe są elementem.

1
Nie ma mowy! To magia!
YSC

12

# Brachylog , 9 bajtów

``````h:2j:12+?
``````

W języku angielskim „(udowodnij, że) pierwsza cyfra wejścia, połączona ze sobą dwa razy, dodaj 12, wciąż jest wejściem”.

1
To jest genialne!
datagod

11

# Python 2, 25 bajtów

``lambda n:`n-12`==`n`*3``

Przetestuj na Ideone .

8

# Brain-Flak 76 + 3 = 79 bajtów

Ta odpowiedź jest golfem tej odpowiedzi. Właściwie nie wiem dokładnie, jak działa moja odpowiedź, ale DJMcMayhem daje dobre wyjaśnienie w swojej oryginalnej odpowiedzi, a moja odpowiedź jest modyfikacją jego.

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

Jest uruchamiany z flagą -a ascii, która dodaje 3 bajty.

## Wyjaśnienie (swego rodzaju)

Począwszy od oryginalnego działającego rozwiązania:

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

Przeprowadzam to przez prosty algorytm golfowy, który napisałem i otrzymuję:

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

Stąd widzę sekcję, która `<({}[()()()])>{}`zasadniczo mnoży się przez jedną, co sprawia, że ​​równa się `{}[()()()]`zmniejszeniu całego kodu do:

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

Wreszcie negatywy można łączyć:

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

14
„Nie wiem do końca, jak działa moja odpowiedź” , wygrywasz internet
Leaky Nun

@LeakyNun Nie wierzę, że tryb Ascii działa na wypróbowanie online. Będziesz musiał pobrać wersję github.
Wheat Wizard

1
Tryb @WheatWizard ASCII zdecydowanie działa na TIO. Możesz to sprawdzić, dodając 48 („0”) na górze stosu . Dziurawa zakonnica ma rację, algorytm ( mój algorytm) jest niepoprawny, ponieważ po prostu sprawdza, czy suma różnic wynosi 2 (co działa, jeśli różnica wynosi +3 i -1). Niestety obie nasze odpowiedzi są błędne.
DJMcMayhem

1
@WheatWizard Ta odpowiedź wydaje się nieprawidłowa. Wypróbuj online! (Mojej pierwotnej odpowiedzi też nie było)
DJMcMayhem

7

# Galaretka , 6 bajtów

``````DI⁼1,1
``````

### Jak to działa

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

012 nie zwraca wartości fałszywej, chociaż tak naprawdę nic nie zwraca ...
Jamie Barker

Dane wejściowe muszą być liczbą całkowitą. Jeśli chodzi o `ast.literal_eval`to, `012`nie reprezentuje liczby całkowitej .
Dennis

7

# 05AB1E , 5 bajtów

``````¥XX‚Q
``````

Wyjaśnienie

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

Wypróbuj online

Użyłem `2Å1`zamiast `XX,`, tylko do cholery mniej poleceń (4 zamiast 5).
Erik the Outgolfer,

@ErikGolfer エ リ ッ ク ゴ ル フ ァ ー: i `Å`jest zapisywalny na mojej klawiaturze (w przeciwieństwie do `‚`) co jest zaletą :)
Emigna

`‚`(nie `,`użyłem) nie ma też sekwencji klawiszy komponowania, podczas gdy `Å`jest `oA`na klawiaturze en-US.
Erik the Outgolfer,

6

# MATL , 8 bajtów

``````d1=tn2=*
``````

Wypróbuj online!

To zostanie wydrukowane `1 1` dla prawdziwych danych wejściowych i tablicy z `0`nią dla wartości fałszowania, ponieważ jest to fałsz w MATL.

Wyjaśnienie:

``````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
``````

Może `d1=Ep4=`(nie testowałem dokładnie)
Luis Mendo

1
Lub `dTTX=`za 5 bajtów
Luis Mendo

@luismendo whaaa? How does that even work? I can't find documentation on `T`
DJMcMayhem

`T` is the literal `true`, and `F` is `false`. Neighbouring `T` and `F` stick together, so `TT` is `[true true]`, which for these purposes is equivalent to `[1 1]`. See section 4.3 of the spec
Luis Mendo

6

## Java 7, 46 bytes

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

After trying several things with Leaky Nun in chat, this seems to be the shortest. Sometimes you just have to do things the straightforward way :/

Explanation:

``````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?
}
``````

6

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

## Explanation:

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

6

# Retina, 26

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

Outputs 1 for truthy and 0 for falsey.

Try it online (First line added to allow multiple testcases to be run).

5

# Ruby, 3230 25 + 2 = 27 bytes

+2 bytes for `-nl` flags.

Takes input on STDIN and prints `true` or `false`.

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

See it on repl.it: https://repl.it/DBn2/2 (Click on ▶️ and then type input into the console below.)

Your tests show 12 going to true.
xnor

@xnor Oops. That'll teach me to golf after bedtime. Fixed!
Jordan

I thought `-a` does a `split`, not `chop`? Also, what does the `&` do? I'm using an older Ruby which throws an error. Anyway, it works perfectly at 26 bytes without it.
xsot

Oops, I meant `-l`, not `-a`. `&.` is the "safe navigation" operator, added in Ruby 2.3. Without it inputs like `19`, which aren't substrings if `"123456789"`, will raise a NoMethodError.
Jordan

@Jordan I'm not getting an error in 2.2. Maybe it's new in 2.3 too?
xsot

5

# Brain-Flak, 99 bytes

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

Try it online!

This is 98 bytes of code `+1` for the `-a` flag.

This prints `1` for truthy, and either `0` or nothing (which is equivalent to 0) for falsy

Try to get rid of push pop inefficiencies. I can see a bunch in your code. They look like `...)({}` but vary. If you push and pop without using the value you can condense it into one thing. I can link you to a version of your code with all of these golfed out if you want.
Wheat Wizard

Here is my 76 byte golf of your program. I pretty much ran my brain-flak optimizer over your code with a few custom settings.
Wheat Wizard

4

# Brain-Flak, 114 bytes

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

Try it online!

Correct version (in the spirit of the question): takes the integer as input, output 0 for falsey and 1 for truthy.

This is not stack clean.

### Algorithm

Let the input be `n`.

The output is truthy iff `(n-123)(n-234)(n-345)(n-456)(n-567)(n-678)(n-789)=0`.

I computed those seven numbers by first subtracting 12 and then subtract 111 7 times, and then computed the logical double-NOT of those seven numbers and added them up.

For truthy results, the sum is 6; for falsey results, the sum is 7.

Then, I subtract the sum from 7 and output the answer.

I don't understand the code, but the algorithm is clever so have a +1.
Cyoce

4

# R, 30 22 bytes

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

Not particularly exciting; check if input is in the sequence given by 12 + 111k, where k is each of 1 to 7. Note that `:` precedes `*` so the multiplication happens after the sequence is generated.

4

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

First code-golf submission, be gentle :)

``````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
``````

Try it online!

• -11 bytes thanks to Kirill L.
• Another -7 bytes thanks to ASCII-only.

1
Welcome to PPCG! You can save some bytes by dropping the curly braces and `return` keyword: 30 bytes
Kirill L.

1

1
Nice first submission!
Embodiment of Ignorance

3

# Brainfuck, 43 bytes

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

Bah, I'm no good at this. Outputs `\x01` if the output is one of the strings `123`, `234`, …, `789`; outputs `\x00` otherwise.

(I beat Java 7, though…)

Try it online!

What's the point of `[>>]<`? Couldn't that just be `>`?
DJMcMayhem

I want to veer the program into failure (by throwing it off-track) if the cell under the pointer isn't zero at that point.
Lynn

Leaky Nun

@LeakyNun That looks completely different; feel free to post it as a separate answer
Lynn

@Lynn Done.
Leaky Nun

3

# JavaScript ES6, 26 bytes

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

This takes advantage of the fact that I'm using bit-wise logic operators on what are essentially booleans (which are bit-based!)

Thanks to Titus for saving 2.

1
two bytes: `(n-12)` and `n>99`
Titus

@Titus Oh, very nice, +1 to you!
WallyWest

1
=> is ES6, not ES5.
Neil

1
I believe it was decided in meta that you didn't have to count "f=" making this 26 bytes
Charlie Wynn

1
@WallyWest I think it's because it's not necessary to have "f=" to use the function in every case, so why assume you need it for this case? People smarted than me decided it's fine so I just go with it ;)
Charlie Wynn

3

# Excel - 625735 31 bytes

Based on Anastasiya-Romanova's answer, but returning Excel's `TRUE/FALSE` values.

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

Further, we can get to

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

since both `RIGHT` and `LEFT` return a single character by default.

And, inspired by some of the Python solutions:

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

Thanks to Neil for 4 more bytes...

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

Doesn't `N<900` save you a byte, in which case you can also use `N>99` instead of `LEN(N)=3`.
Neil

1
21 bytes: `=REPT(LEFT(N),3)+12=N` where `N` is the name of the reference cell.
Engineer Toast

3

# Brachylog (2), 7 bytes

``````ẹ~⟦₂-_2
``````

Try it online!

## Explanation

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

As a full program, we get a truthy return if all assertions hold, a falsey return if any fail.

3

# CJam, 13 9 bytes

``````A,s3ewqe=
``````

Try it online!

Explanation

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

5
doesn't work if number is like `2345`
Maltysen

@Maltysen Fixed

2

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

Explanation:

The syntax for the IF formula in Excel is:

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

If the length of input `N`, where it's a name of the reference cell, is less than 3, then it will return Falsy. Else, if the length of input `N` is 3 and both of the difference of second digit and first digit and the difference of third digit and second digit are equal to 1, then it will return Truthy.

21 bytes: `=REPT(LEFT(N),3)+12=N` where `N` is the name of the reference cell.
Engineer Toast

2

# Dyalog APL, 10 bytes

Takes string argument.

``1 1≡¯2-/⍎¨``

`1 1≡` Is {1, 1} identical to

`¯2-/` the reversed pair-wise difference of

`⍎¨` each character taken as a number?

TryAPL online! (`⍎` has been emulated with `e` for security reasons.)

2

# Perl, 18 bytes

Includes +1 for `-p`

Run with the input on STDIN

``````123.pl <<< 123
``````

`123.pl`:

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

2

# PHP, 31 bytes

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

Check if first digit of (number minus 12) is multiple of 111

2

## PowerShell v3+, 24 bytes

``````(\$args-12)/111-in1..7
``````

Uses the same "multiple of 111 plus 12" trick as some other answers, but goes the other direction. Takes input `\$args`, subtracts `12`, divides by `111`, and checks whether that's `-in` the range `1..7`. Outputs a Boolean true/false value. Requires v3+ for the `-in` operator.

### Test Cases

``````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
``````

2

# ARM Machine Code, 18 bytes

Hex dump (little endian):

``````3803 d105 6808 ebc0 2010 b280 f2a0 1001 4770
``````

This is a function that takes in a length, pointer pair for the string. The output is bash-style, it outputs 0 for true and a non-zero value for false. In C the function would be declared int oneTwoThree(size_t length, char* string). The instruction encoding is thumb-2, which has 2 and 4 byte instructions. Tested on a Raspberry Pi 3.

Ungolfed assembly:

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

Testing script (also assembly):

``````.syntax unified
.text
.global main
.thumb_func
main:
push {r4,lr}
ldr r4,[r1,#4] @r0=argv
mov r0,r4
bl strlen
@Now r0 is the length of the string argv
mov r1,r4
bl oneTwoThree @oneTwoThree(strlen(argv),argv)
cmp r0,#0
it ne
movne r0,#1 @Output through return code, 1 if false
pop {r4,pc}
``````

2

# JavaScript (ES6), 34 bytes

And one more option in JS. Takes input as a string and outputs `0` for `false` and `1` for `true`.

``````n=>++n==n&++n==n&!n
``````

See my other solutions here and here

## Try it

``````f=
n=>++n==n&++n==n&!n
``<input id=i type=number><pre id=o>``