Olumlu bir tamsayı alır bir program veya işlev yazın. Girişin geçerli olduğunu varsayabilir ve bir dize olarak alabilir. Eğer numara herhangi biriyse

123
234
345
456
567
678
789

daha sonra bir gerçek değer verin. Aksi takdirde, sahte bir değer verin. Örneğin, girişler

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

hepsi sahte çıktıyla sonuçlanmalıdır. (Girdide baştaki sıfırlar olmayacağından, böyle şeyler için endişelenmenize gerek yoktur 012.)

Bayt cinsinden en kısa kod kazanır.

Python, 24 bayt

range(123,790,111).count

0 veya 1 çıktısını alan adsız bir işlev Liste oluşturur [123, 234, 345, 456, 567, 678, 789]ve girişin kaç kez görüntülendiğini sayar.

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

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

Python, 24 bayt

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

Sadece bir çok koşul zincirleme.

Haskell, 22 bayt

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

Anonim bir işlev. Eşit aralıklı bir liste oluşturur [123, 234, 345, 456, 567, 678, 789]ve girişin bir eleman olup olmadığını kontrol eder.

Brachylog , 9 bayt

h:2j:12+?

Çevrimiçi deneyin! veya Tüm test durumlarını doğrulayın.

Algoritma için Dennis'e kredi verir .

İngilizce’de, “(ispatın) Giriş’in iki kez birleştirilmiş, ilk 12 rakamı hala Giriş’dir.”

Python 2,25 bayt

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

İdeone üzerinde test et .

Brain-Flak 76 + 3 = 79 bayt

Bu cevap, bu cevabın bir golf . Cevabımın nasıl çalıştığını aslında tam olarak bilmiyorum ama DJMcMayhem orijinal cevabını iyi bir şekilde açıklıyor ve cevabım onun bir modifikasyonu.

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

3 bayt ekleyen -a ascii bayrağıyla çalıştırılır.

Açıklama (çeşit)

Orijinal çalışma çözümüyle başlayarak:

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

Bunu yazdığım ve aldığım basit bir golf algoritması ile çalıştırıyorum:

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

Buradan, <({}[()()()])>{}bu bölümün esasen {}[()()()], kodun tamamını indirgemeye eşit kılan bir bölümle çarptığını görüyorum :

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

Son olarak negatifler birleştirilebilir:

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

Brainfuck, 32 bayt

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

Çevrimiçi deneyin!

Algoritmanın çekirdeği için Lynn'e kredi verir.

Jöle , 6 bayt

DI⁼1,1

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

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 bayt

¥XX‚Q

açıklama

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

Çevrimiçi deneyin

MATL , 8 bayt

d1=tn2=*

Çevrimiçi deneyin!

Bu 1 1bir truthy girdisi ve 0içinde bir sahte değer için içinde bulunan bir dizi için basılacaktır, çünkü MATL'de sahtedir.

Açıklama:

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 bayt

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

Sohbet sırasında Leaky Nun ile birkaç şey denedikten sonra, bu en kısa gibi görünüyor. Bazen işleri basit bir şekilde yapmanız gerekir:

Açıklama:

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 bayt

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

Açıklama:

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

Kullanımı:

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

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

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

Retina , 26

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

Truthy için 1 ve falsey için 0 çıktılar.

Çevrimiçi deneyin (birden fazla test uygulamasının çalışmasına izin vermek için ilk satır eklendi).

Ruby, 32 30 25 + 2 = 27 bayt

-nlBayraklar için +2 bayt .

STDIN'e girdi alır ve trueveya yazdırır false.

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

Repl.it üzerinde bakın: https://repl.it/DBn2/2 (▶ ️ üzerine tıklayın ve sonra aşağıdaki konsola giriş yazın.)

Brain-Flak , 99 bayt

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

Çevrimiçi deneyin!

Bu bayrak +1için 98 baytlık koddur -a.

Bu 1, truthy için basar ya da 0ya hiçbiri ya da hiçbiri (0'a eşittir) sahtedir.

Brain-Flak , 114 bayt

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

Çevrimiçi deneyin!

Doğru versiyon (sorunun özünde): tamsayıyı girdi, falsey için 0, gerçeği için 1 çıktı olarak alır.

Bu yığın temiz değil .

Algoritma

Giriş olsun n.

Çıktı truthy iff (n-123)(n-234)(n-345)(n-456)(n-567)(n-678)(n-789)=0.

Bu yedi sayıyı önce 12 çıkardıktan sonra 111 7 kez çıkardıktan sonra hesapladım ve daha sonra bu yedi sayının mantıksal çiftini hesapladım ve ekledim.

Gerçek sonuçlar için, toplam 6'dır; falsey sonuçları için toplam 7'dir.

Sonra toplamı 7'den çıkardım ve cevabı çıkardım.

R, 30 22 bayt

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

Özellikle heyecan verici değil; kontrol k, 1 olduğu Not 7. nin her biri burada girişi + 111k 12 tarafından verilen sırada ise :önce gelen *dizisi oluşturulur, sonra çarpma olur, böylece.

C # (Visual C # Etkileşimli Derleyici) , 41 30 23 bayt

İlk kod-golf gönderimi, nazik ol :)

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

Çevrimiçi deneyin!

• Kirill L sayesinde -11 bayt
• Sadece ASCII-sayesinde -7 bayt daha.

Brainfuck, 43 bayt

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

Bah, bu konuda iyi değilim. Çıkışlar \x01çıkış dizeleri biriyse 123, 234, ..., 789; \x00aksi takdirde çıktılar .

(Yine de Java 7'yi yendim ...)

Çevrimiçi deneyin!

JavaScript ES6, 26 bayt

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

Bu, esasen booleans (bit tabanlı olan!) Konusunda bit-akıllı mantık operatörleri kullandığım gerçeğinden faydalanır.

2 tasarruf için Titus teşekkürler.

Excel - 62 57 35 31 bayt

Anastasiya-Romanova'nın cevabına göre, ancak Excel'in TRUE/FALSEdeğerlerini geri veriyor .

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

Dahası, alabiliriz

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

her ikisinden de RIGHTve LEFTvarsayılan olarak tek bir karakter döndürür.

Ve bazı Python çözümlerinden esinlenerek:

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

Neil'e 4 bayt daha teşekkürler ...

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

Brachylog (2), 7 bayt

ẹ~⟦₂-_2

Çevrimiçi deneyin!

açıklama

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

Tam bir program olarak, tüm iddialar geçerli olursa bir haksızlık iadesi, başarısız olursa bir falsey iadesi alırız.

CJam, 13 9 bayt

A,s3ewqe=

Çevrimiçi deneyin!

açıklama

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 bayt

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

Açıklama:

Excel'deki IF formülünün sözdizimi şöyledir:

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

NReferans hücrenin adı olan girişin uzunluğu 3'ten az ise, Falsy değerini döndürür . Aksi takdirde, girişin uzunluğu N3 ise ve hem ikinci hane ile birinci hane arasındaki fark hem de üçüncü hane ve ikinci hane arasındaki fark 1'e eşitse, o zaman Truthy değerini döndürür .

Dyalog APL , 10 bayt

Dize argümanı alır.

1 1≡¯2-/⍎¨

1 1≡ {1, 1} ile aynı mı

¯2-/ ters çift yönlü fark

⍎¨ Her karakter bir sayı olarak alınır?

TryAPL çevrimiçi! ( güvenlik nedeniyle ⍎taklit edilmiştir e.)

Perl, 18 bayt

İçin +1 içerir -p

STDIN'deki giriş ile çalıştırın

123.pl <<< 123

123.pl:

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

PHP, 31 bayt

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

İlk basamağın (eksi 12 sayı) 111'in katı olup olmadığını kontrol edin

PowerShell v3 +, 24 bayt

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

Diğer 111 cevap ile aynı "çoklu 111 artı 12" numarasını kullanır , ancak diğer yöne gider. Girdiyi alır $args[0], çıkarır 12, ikiye böler ve aralığın 111bu olup olmadığını kontrol eder . Bir Boole doğru / yanlış değeri çıktılar. Operatör için v3 + gerektirir .-in1..7-in

Test Kılıfları

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 Makine Kodu, 18 bayt

Hex dökümü (küçük endian):

3803 d105 6808 ebc0 2010 b280 f2a0 1001 4770

Bu, dize için işaretçi çiftinin uzunluğunu alan bir işlevdir. Çıktı bash stilindedir, true için 0, false için sıfır olmayan bir değer verir. C'de fonksiyon int oneTwoThree (size_t uzunluk, char * string) olarak bildirilir. Komut kodlaması, 2 ve 4 baytlık talimatlara sahip olan thumb-2'dir. Ahududu Pi 3'te test edilmiştir.

Ungolfed montaj:

.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

Test komut dosyası (ayrıca montaj):

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

Ve JS'de bir seçenek daha. Bir dize ve çıkışlar olarak girdi Alır 0için falseve 1için true.

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

Diğer çözümleri burada ve burada görün

Dene

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>