Hedef:

İki doğal sayı (0'dan sonsuza kadar tam sayı) verildiğinde, bu sayıların toplamı olmayan, ancak doğal bir sayı olan bir sayı çıkar.

Örnek çözümler (TI-Basic):

• A+B+1

• not(A+B)

Geçersiz çözümler:

• A+B-1(girişler için 0,0, -1doğal olmayan döner )

• "ABC"( ABCbir sayı değildir)

Notlar:

• Çıktı her zaman iki doğal sayının toplamı olmalıdır (bu aslında doğal sayıdır)

• -1, undefined, infinity, NaNVe hata mesajları doğal sayılar değildir. Amaçlarımız 0için doğaldır (tüm matematikçiler aynı fikirde olmasa da).

RProgN , 4 3 1 Bayt

_{Geçti 4 hala 4;}

E

En basit çözüm, A ve B'nin eşit olup olmadığını karşılaştırır. Doğru, eğer aynıysa RProgN 1 olarak görür, aksi takdirde yanlış aka 0 olur.

Test Kılıfları

0+0 = 1
1+0 = 0
0+1 = 0
1+1 = 1

Çevrimiçi deneyin!

Retina , 3 bayt

 
1

Çevrimiçi deneyin!

(İlk satırda yeni satırdan önce bir boşluk var. Stack Exchange izleyen boşlukları göstermede çok iyi değil.)

Giriş, ondalık boşlukta, boşlukla (örneğin 12 34) ayrılan sayıdır . Bu program sadece boşluğu a olarak değiştirir 1, girdi numaralarının toplamı olmayacak kadar büyük bir sayı oluşturur (her ikisinden de en az 2 hane olmak zorundadır ve iki sayı eklemek, en fazla 1 hane olmayan bir çıktı üretir. daha büyük giriş).

Python , 13 bayt

[(0,0)].count

Çevrimiçi deneyin! Girişi tuple olarak alır.

İşlev için bir nesne yöntemi kullanmak , a'nın kazan plakasını engeller lambda.

lambda a,b:a-~b   # 15 bytes

Burada, fikri haritalarını çıkarmak (0,0)için 1ve her şey 0. Sadece doğal sayılar arasında 0+0bir toplam verdiğinden 0, her zaman toplamı eşleştirmekten kaçınır.

Biri burada bir Boolean yazdırabilir, gölgeli bulabilirsem, bir bayt olarak kaydedilebilirdi.

(0,0).__ge__

Bu, giriş demetinin en fazla olup olmadığını kontrol eder (0,0); bu sadece için geçerlidir (0,0). Python'da True==1ve False==0. Daha da gölgeli bir şekilde, çıkış koduyla çıktı almak ve bir Python Boolen olarak iki bayt tasarruf edeceğini kabul etmek:

[(0,0)].pop

Dize G / Ç izin verilirse ve baştaki sıfırlar tamamsa, 8 baytlık çözüm vardır.

'1'.join

Bu a1b, her zaman olduğundan daha büyük olan bitiştirir a+b.

MATL, vd. 1 bayt

=

İki doğal sayıyı girdi olarak kabul eder ve karşılaştırır. Eşitlerse, çıktı 1ve eşit değillerse çıktıdır 0. Bu @ ATaco'nun çözümü ile aynı yaklaşımdır.

• Matl

• Jelly (@ ais523) Tarafından Çekilen En Yeni Fotoğrafları İncele

• Yığılmış (@Conor O'Brien tarafından)

• APL (Dyalog APL) (@ Adám tarafından)

• J (@ Adám)

• Aslında (by @Mego)

• Örtülü (@MD XF tarafından)

Javascript, 10 bayt

x=>y=>!x+y

Bunun gibi currying sözdizimini kullanarak 2 sayı alır:

(x=>y=>!x+y)(0)(0) // 1

Vim, 3 bayt / tuş vuruşlarını

<C-a>gJ

Çevrimiçi deneyin!

Bunun <C-a>aslında bayt'ı temsil eden ctrl-a olduğuna dikkat edin 0x01.

Vim'in (bir programlama dili bile olmayan) golf dilleriyle rekabet edebildiğini seviyorum. :) Giriş bu biçimde gelir:

a
b

Bu sadece ilk sayıyı bir artırır (Bu <C-a>kısımdır) ve sonra iki sayının dizgi gösterimlerini birleştirir. Söyleyebileceğim kadarıyla, bu asla toplamla sonuçlanmamalı.

Beyin Flak , 8 bayt

({}{}())

Çevrimiçi deneyin!

Bu şimdiye kadar yazdığım en okunaklı beyin lafı cevabı. :)

Açıklama:

(      )    # Push the sum of all the following:
 {}         #   The first input
   {}       #   The second input
     ()     #   and one

Alternatif çözümler (ayrıca 8 bayt):

({}[]{})    # Sum + 1
([]{}{})    # Sum + 2

Sadece pozitif sayılarla çalışan bir sürü başka çözüm var:

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

Jöle , 2 byte

+‘

+, İki girişi birbirine ekler ve 'yanıtı birer birer artırır

Çevrimiçi deneyin!

TI-Basic, 3 bayt

not(max(Ans

Alternatif çözümler:

10^(sum(Ans         3 bytes @DestructibleWatermelon
not(sum(Ans         3 bytes
1+sum(Ans           4 bytes
Input :X=Y          5 bytes @ATaco
Input :X+not(Y      6 bytes
Input :not(X+Y      6 bytes
Input :10^(X+Y      6 bytes
Input :X+Y+1        7 bytes
Input :not(max(X,Y  7 bytes
Ans(1)=Ans(2        8 bytes
Ans(1)+not(Ans(2    9 bytes
not(Ans(1)+Ans(2    9 bytes

Sorunun örneklerini TI-Basic'te yapmış olmanız ilginçtir, ancak daha kısa olanı unuttunuz A=B(ya da belki öğrenmek bize kalmıştı?)

Brachylog , 2 bayt

+<

Çevrimiçi deneyin!

açıklama

+     The sum of the elements in the Input...
 <    ...is strictly less than the Output
      (implicitely label the output with an integer respecting this constraint)

Bu her zaman sonuçlanır A+B+1, eğerInput = [A, B] .

Mathematica, 5 bayt

1+##&

İki argüman artı 1'in toplamını 1+##&[2,5]verir 8. Örneğin, verim .

(Yan not: Binomialher ne kadar neredeyse eser Binomial[1,0]=1ve Binomial[4,2]=6karşı örnekleridir; Gerçi onlar sadece counterexamples olduğunu düşünüyorum.)

PHP, 17 bayt

<?=1-join($argv);

Bu şekilde koş:

echo '<?=1-join($argv);' | php -- 0 0
> 1

açıklama

Bu sadece argümanları birleştirir. İlk argüman (script ismi) içerir -. Bu eksi işareti ile olumsuz bir olumsuz sayı ile sonuçlanır. Sonra ilk giriş numarasının bir 0(0123 = 123) olması durumunda 1 eklerim .

Perl 6 , 4 bayt

!*+*

Birinci argümanın boolean tersini (1 veya 0) ikinci argümana ekleyen bir lambda ( Ne olursa olsun-kurutma ) tarafından oluşturulur .

Çevrimiçi deneyin!

Turtlèd , 12 bayt

çok büyük sayılar yapar

'1?:?:[1'0l]

Çevrimiçi deneyin!

Açıklama:

'1                write one on the starting grid square
  ?:?:            take a number, move right that many (repeat)
      [1   ]      while not on a grid square with a one on it
        '0l       put a zero on that square, move left
[implicit output of grid]

Böylece 10 ** (x + y) çıkışı verir.

PHP, 19 bayt

1<?=max([0]+$argv);

Java (OpenJDK 9) , 10 bayt

a->b->a-~b

Çevrimiçi deneyin!

HODOR , 40 bayt ( yarışmaz )

Bu muhtemelen Hodor'un şimdiye kadar yazdığı en kısa program!

2 haftalık bir okul tatili için yapacak bir şeyiniz olmadığında olan şey budur: kesinlikle hiçbir şey yapmayan bir sürü gerçekten kolay kodlanmış şaka dili oluşturun. Okul tatilleri için Yay !!!

Walder
Hodor?!
Hodor?!
Hodor HODOR!
HODOR!!!

Walder Hodor'un asıl adıydı ve programa başlamak için de gerekiyor.

Hodor?! STDIN'den bir sayı veya tek bir karakter alır ve akümülatörü girişe ayarlar.

Hodor aküye 1 ekleyin

HODOR! akümülatörü sayı olarak verir

HODOR!!!Hodor'u öldürdü! Noooooo!

Bu sahte kod:

Take input
Take input
Add 1 to sum(inputs)
Output value

SmileBASIC, 4 bayt

!A+B

olup, (A) + B
1+1=2 -> !1+1 -> 0+1=1
0+1=1 -> !0+1 -> 1+1=2

R, 13 bayt

sum(scan()+1)

Girişlerinden dolayı Jonathan Allan'a teşekkürler!

05AB1E , 1 bayt

Q

Cevapla aynı şekilde çalışır RProgN.

Çekler eğer ave baynıdır. Eğer öyleyse, yazdırın 1. Aksi takdirde, yazdır0

Çevrimiçi deneyin!

C 26 24 19 bayt

f(c,d){return!c+d;}

Ungolfed versiyonu:

int f(int c,int d)
{
   return !c+d; 
}

Umarım şartnameyi doğru anlamışımdır. Kesinlikle kısaltılabilir!

@Pavel 2 bayt kaydettiğiniz için teşekkür ederiz

@Neil Girişiniz için teşekkürler.

MATLAB / Octave, 3 bayt

@eq

İki girdiyi kabul eder ve eşitliği kontrol eder ve 1eşit olup olmadıklarını verir 0.

Çevrimiçi Demo

brainfuck, 12 bayt

Çıktıları basit bir çözüm A+B+1.

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

Çevrimiçi deneyin

dc , 5 bayt

?1n+n

Çevrimiçi deneyin!

Giriş: stdin'deki boşlukla ayrılmış iki doğal sayı.

Çıktı: Hemen 1 rakamı ve ardından iki sayının toplamından sonra iki rakamın toplamından sonra gelen rakam.

Örnek:

Giriş: 222 333

Çıktı: 1555

PHP, 13 bayt; (17 REPL-az)

!max($argv)+0

Örnekler

[0,0] -> 1
[0,1] -> 0
[1,0] -> 0

REPL kullanımı olmayanlar için

<?=!max($argv)+0;

ve kullanarak koş

echo '<?=!max($argv)+0;' | php -- 0 0

Cubix, 9 8 bayt

u-~OII/@

açıklama

Genişletilmiş, bu cevap şöyle görünür:

    u -
    ~ O
I I / @ . . . .
. . . . . . . .
    . .
    . .

Yürütülen talimatların sırası II~-O@

II~-O@
I      # First input
   -   # Minus
 I~    # NOT(second input)
    O  # Output as integer
     @ # End program

Her ikisinin de aralığında bulunan tüm giriş kombinasyonları için test edilmiştir 0-100.

Burada dene .

APL - 4 Bayt

1++/

Dizi alır, elemanlarını toplar ve bir tane ekler. Ölçek:

 1++/1 2  
4
 1++/1 0
2

¥ å ı ¥ ® Ï Ø ¿ , 4 bayt

II1_

II   Take 2 inputs and push to the stack
  1  Push 1 to the stack
   _ Push the sum of the stack

Çıktı oiçin sonuna ekleyin .

Altıgen , 7 bayt

?<.!?)@

Çevrimiçi deneyin!

Veya daha okunabilir biçimde,

 ? <
. ! ?
 ) @

Bu, 11 baytın mevcut Hexagony çözümünü yener.

Açıklama:

İlk sayı 0 değilse, program aşağıdaki yolu izler:

Bu ilk sayıyı okur ve dallar doğru. Sonra ikinci sayıyı okur, ardından üçte birini okumaya ve okumaya çalışır, ancak bu 0 olur. Öyle olmaz. Bu yazdırılır ve program sonlandırılır (a> 0 ise b negatif olmadığından + b> 0).

İlk sayı 0 ise, program başlamak için aşağıdaki yolu izler:

Bu, ilk sayıyı ve kalan dalları okur. Köşeye çarpar, rotayı kuzey-batı kenarı boyunca çeker, çünkü sayı 0'dır ve ikinci sayıyı okur. Kaydırır, sonra ikinci sayıyı artırır ve yazdırır.

Bu karşı sıçrar <tekrar artırılır ikinci girdi yazdırma. Değeri arttırır ve kuzey-doğu kenarını tekrar alır, ancak bu kez mevcut kenar kesinlikle pozitif olan iki kat arttırılmış negatif olmayan bir değerdir. Daha sonra üçüncü bir girdi elde etmeye çalışır, ancak bunun yerine 0 alır.

Sonunda okla sarılır ve yönlendirilir, sonra dördüncü bir girişi okumaya çalışır ve tekrar 0 alır. Beşinci bir girişi sarar ve okur ve son kez 0 alır. Bu yazdırır ve sarar @ve çıkar.

B * (10 ^ k + 1) * 10> 0 + b = b burada k rakamının b uzunluğu kadardır, bu nedenle işe yarar.

Bilardo , 11 karakter = 17 bayt

⇲
⇲
+
1
+
↥

Uygular x + y + 1. Oldukça basit. Girişleri iki ayrı satırda alır. (Bu arada, dil zorlu görevden biraz sonra değiştirildi, ancak sadece istemin girilmesini engellemek için bu cevabın hala geçerli olup olmadığından emin değilsin).

7 karakter = 11 bayt, rakipsiz

Bu daha kısadır, ancak yeni bir dil güncellemesinden sonra mümkündür:

⇲
⇲
=
$

x == y@ ATaco'nun RProgN çözümünden utanmadan çalınan bu kullanımlar [umursamıyorum (:]. $Çıkışta, kaç tane top üzerinden geçtiğini gösterir.