Sorun:

Amacınız aşağıdaki matematik operatörlerin herhangi kullanmadan iki giriş numaralarını eklemektir: +,-,*,/.

Ek olarak, bu matematik operatörlerini değiştirmek için tasarlanan yerleşik işlevleri kullanamazsınız.

puanlama:

En küçük kod (bayt sayısı ile) kazanır.

Güncelleme

Gördüğüm programların çoğu ya sayılarını içeren iki diziyi birleştiriyor ya da first numberkarakter yapıyor, second numberkarakter ekliyor , sonra hepsini sayıyor.

En kısa dizi sayacı: 8 karakterli APL, Tobia tarafından

En kısa dizi birleştirme: 4 karakterli Golfscript, Doorknob

En kısa logaritmik çözüm: 19 karakterli TI-89 Basic, Quincunx

Entegrasyon çözümü: Michael Stern tarafından 45 karakterli Mathematica

Havalı, benim görüşüme göre: javascript bitwise operatörleri, dave tarafından

Smalltalk, 21 13

Aşağıdakilerin tümü yalnızca pozitif tamsayılar üzerinde çalışır. Ciddi bir cevap için diğer Smalltalk cevabına bakınız .

versiyon 1

büyük bir tamsayıya geçip yüksek bit dizini için sorma (hatalı, ST dizini 1 tabanlı, bu yüzden ek bir sağa kaymaya ihtiyacım var):

(((1<<a)<<b)>>1)highBit

versiyon 2

benzer ve hatta biraz daha kısa (Smalltalk öncelik kuralları nedeniyle ve doğru bir kaymaya gerek yok):

1<<a<<b log:2 

Sürüm 3

a ve b iki sayıları verilen “koleksiyon-birleştirici-talep edici boyut” temasının bir başka çeşidi ,

((Array new:a),(Array new:b)) size

Intervals'ı koleksiyon olarak kullanarak daha hafıza dostu bir sürüm elde ettik ;-) 21 karakter:

((1to:a),(1to:b))size

Ancak, yoğun sayıdaki çatırtı için önerilmez.

version4

Eğlenceniz için, hafıza için zaman ayırmak istiyorsanız, şunu deneyin:

Time secondsToRun:[
   Delay waitForSeconds:a.
   Delay waitForSeconds:b.
]

hangi genellikle yeterince doğru (ancak hiçbir garanti ;-)))

version5

bir dosyaya yaz ve boyutunu sor

(
    [
        't' asFilename 
            writingFileDo:[:s |
                a timesRepeat:[ 'x' printOn:s ].
                b timesRepeat:[ 'x' printOn:s ]];
            fileSize 
    ] ensure:[
        't' asFilename delete
    ]
) print

Javascript (25)

while(y)x^=y,y=(y&x^y)<<1

Bu, yalnızca bitsel işlemleri kullanarak iki değişken x ve y ekler ve sonucu x olarak saklar.

Bu da negatif sayılarla çalışır.

C - 38 bayt

main(){return printf("%*c%*c",3,0,4);}

Burada biraz hile yapıyorum, OP herhangi bir matematik operatörü kullanmadığını söyledi .

*İçinde printf()karakter yazdırmak için kullanılan genişliği alan bir değişken alınan bu biçim araçlarının printf(), bu durumda, 3 ve 4 bir dönüş değeri printf()baskılı karakterleri sayısıdır. Bu yüzden ' 'alan genişliği 3 olan, alan genişliği 4 olan toplam 3 + 4 karakter yazıyor.

Dönüş değeri, printf()çağrıya eklenen numaralardır .

Python - 49 bayt

Değişkenler konulmak suretiyle giriş varsayarsak xve y.

from math import*
print log(log((e**e**x)**e**y))

Bu 61 baytlık çözüm tam bir programdır:

from math import*
print log(log((e**e**input())**e**input()))

Üskü yasaklamadığınız göz önüne alındığında, bunu göndermek zorunda kaldım. Logaritma özelliklerini kullanarak ifadeyi basitleştirdiğinizde, basitçe elde edersiniz print input() + input().

Bu hem negatif hem de kayan nokta sayılarını destekler.

Not: Gnibbler'in tavsiyelerine uydum ve bu cevabı üçe böldüm . Bu Mathematica çözümü ve bu da TI-89 Temel çözüm .

JavaScript [25 bayt]

~eval([1,~x,~y].join(''))

Mathematica, 21 bayt

Bunu Mathematica'da yapmanın birkaç yolu var. Birincisi, Biriktirme işlevini kullanın ve çıktıdaki son sayı dışında her şeyi atın. Aşağıda benim diğer çözüm seçildiğinde, ben girdi numaraları değişkenler içindedir farz ave b. 21 bayt.

Last@Accumulate@{a, b}

Daha eğlenceli, 45 karakter olmasına rağmen, bir çizgiyi tanımlamak ve onun altına entegre etmek için sayıları kullanın.

Integrate[Fit[{{0, a}, {2, b}}, {x, 1}, x], {x, 0, 2}]

Bir bonus olarak, her iki çözüm de tüm karmaşık sayılar için işe yarar, burada sadece başka bazı çözümler için olduğu gibi sadece pozitif tamsayılar değil.

GolfScript, 6 4 karakter / bayt

10, 5(=> 15) Şeklinde giriniz .

~,+,

+Dizi birleştirme değil, bir yer.

Nasıl çalıştığı, ,sayının ( 0,1,...,n-2,n-1) olduğu uzunlukta bir dizi oluşturmak için kullanılır . Bu her iki sayı için de yapılır, ardından diziler birleştirilir. ,elde edilen dizinin uzunluğunu bulmak için tekrar farklı bir amaç için kullanılır.

Şimdi, işte hile . Bunu gerçekten seviyorum çünkü giriş formatını kötüye kullanıyor. O görünüyor bu giriş GolfScript kodu olarak yürütülmektedir beri sadece, gerçekten ama, bir dizi giren ilk defa karşılaştığımız gibi ,zaten benim için yapılır! (Eski 6 karakterlik sürüm, (takas dizisini) ortadan kaldırarak 2 karakteri tıraşladığım ~,\,+,giriş biçimindeydi ).10 5\,

Eski versiyon (12) :

Bir fonksiyon yaratır f.

{n*\n*+,}:f;

*Ve +sırasıyla dize tekrarı ve birleştirme değil, aritmetik fonksiyonlar bulunmaktadır.

Açıklama: nbir karakterli bir karakter dizisi (yeni satır) oluşturur. Bu daha sonra tekrarlanır a, sonra aynı şey yapılır b. Dizeler birleştirilir ve ,dize uzunluğu için kullanılır.

C, 29 27 Bayt

İşaretçi aritmetiğini kullanarak:

f(x,y)char*x;{return&x[y];}

x işaretçi olarak tanımlanır, ancak arayan bir tamsayı geçmelidir.

Anonim bir kullanıcı şunu önerdi - ayrıca 27 bayt, ancak parametreler tamsayılar:

f(x,y){return&x[(char*)y];}

Brainf * ck, 9 36

,>,[-<+>]

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

Bu basit bir ekleme kullanmadan çalışır; geçer ve 1'lerin izini bırakır ve sonra onları sayar

Not: Yalnızca tek artışlar +ve -bunlar sadece beyninde * ck olmadan bunlar yapılamaz. Gerçekten toplama / çıkarma değil, bu yüzden hala önemli olduğuna inanıyorum.

J (6)

Succ işlevini kullanamadığımızı söylemediniz:

>:@[&0

Kullanımı:

   9>:@[&0(8)
17

Sadece >:8 üzerinden 9 tekrar yapar .

Liste birleştirme yaklaşımı da çalışır: #@,&(#&0). Ve - kurallara aykırı olduğunu biliyorum - bu cevabın en J-ish çözümü olmadan gitmesine izin veremem: *&.^(üstelleştirme altında çarpma).

Postscript, 41

Fonksiyonu, 41 baytlık bir ifade ile tanımlarız:

/a{0 moveto 0 rmoveto currentpoint pop}def

Sonra buna örneğin diyoruz:

gs -q -dBATCH -c '/a{0 moveto 0 rmoveto currentpoint pop}def' -c '10 15 a ='

Hangi verir

25.0

Çoğu rakiplerin aksine, negatifleri ve yüzmeleri kolayca idare eder :-)

bash, 20 karakter

(seq 10;seq 4)|wc -l

Küçük konuşma (şimdi ciddi), 123 118 105 (*)

İki kere cevap verdiğim için üzgünüm, fakat bunu ciddi bir cevap olarak kabul ederken, diğeri daha çok mizah gibiydi. Aşağıdakiler aslında şu anda tam şu anda tüm makinelerimizde (donanımda olsa da) yürütülmektedir. Başka kimsenin aklına gelmemiş olması garip ...

İki yarım eklentiyi birleştirerek ve kelimelerin tüm bitlerini paralel olarak yaparak, (a, b; s cinsinden girişler) girişleri okunabilir versiyonunu alıyoruz:

  s := a bitXor: b.            
  c := (a & b)<<1.             

  [c ~= 0] whileTrue:[        
     cn := s & c.
     s := s bitXor: c.
     c := cn<<1.
     c := c & 16rFFFFFFFF.
     s := s & 16rFFFFFFFF.
  ].
  s           

Döngü taşıma yayılımı içindir. Maskeler, imzalanmış tam sayıların kullanılmasını sağlar (onlarsız, yalnızca imzasız numaralar bulunur). Ayrıca, uzunluğu 32bit işlemi için olan kelime uzunluğunu da tanımlarlar. 68bit ilaveyi tercih ediyorsanız, 16rFFFFFFFFFFFFFFFFFFF olarak değiştirin.

golf versiyonu (123 karakter) (m tuşunu kullanarak yeniden uzun maskeyi önler):

[:a :b||s c n m|s:=a bitXor:b.c:=(a&b)<<1.[c~=0]whileTrue:[n:=s&c.s:=s bitXor:c.c:=n<<1.c:=c&m:=16rFFFFFFFF.s:=s&m].s]

(*) 16rFFFFFFFF yerine -1 kullanarak, daha iyi golf oynayabiliriz, ancak kod artık yalnızca kesinti numaraları için değil, yalnızca makine kelimesi boyutunda smallIntegers için çalışır (largeIntegers temsili Ansi standardında tanımlanmamıştır):

[:a :b||s c n|s:=a bitXor:b.c:=(a&b)<<1.[c~=0]whileTrue:[n:=s&c.s:=s bitXor:c.c:=n<<1.c:=c&-1.s:=s&-1].s]

Bu, kod boyutunu 105 karaktere indirir.

APL, 8 ve 12

Burada yeni bir şey yok, dizi sayma versiyonu:

{≢∊⍳¨⍺⍵}

ve log ○ log versiyonu:

{⍟⍟(**⍺)**⍵}

Sadece APL’de harika göründüklerini düşündüm!

{≢     }       count
  ∊            all the elements in
   ⍳¨          the (two) sequences of naturals from 1 up to
     ⍺⍵        both arguments

{⍟⍟        }   the double logarithm of
   (**⍺)       the double exponential of ⍺
        *      raised to
         *⍵    the exponential of ⍵

sed, 359 bayt (süslü biçimlendirme olmadan)

Geç cevap için özür dilerim ve muhtemelen buradaki en uzun cevap. Ama bunun sed ile mümkün olup olmadığını görmek istedim:

                       s/([^ ]+) ([^ ]+)/\1:0::\2:/
                       :d /^([^:]+):\1::([^:]+):/tx
                       s/(:[^:]*)9([_:])/\1_\2/g;td
s/(:[^:]*)8(_*:)/\19\2/g;s/(:[^:]*)7(_*:)/\18\2/g;s/(:[^:]*)6(_*:)/\17\2/g
s/(:[^:]*)5(_*:)/\16\2/g;s/(:[^:]*)4(_*:)/\15\2/g;s/(:[^:]*)3(_*:)/\14\2/g
s/(:[^:]*)2(_*:)/\13\2/g;s/(:[^:]*)1(_*:)/\12\2/g;s/(:[^:]*)0(_*:)/\11\2/g
                       s/:(_+:)/:1\1/g; y/_/0/; # #
                       bd;  :x  s/.*::([^:]+):/\1/;
                       # # # # # # #  # # # # # # #

Bu, sadece bir dizgede sayıları artıran https://codegolf.stackexchange.com/a/38087/11259 e benzer . Ancak bunun yerine, bir döngü içinde artış işlemlerini yapar.

Giriş, STDIN'den "x y" biçiminde alınmıştır. İlk önce "x: 0 :: y:" e dönüştürülür. Sonra ":" karakterinden sonra gelen tüm sayıları "x: x: :( x + y):" olana kadar arttırırız. Sonra nihayet döndük (x + y).

Çıktı

$ printf "%s\n" "0 0" "0 1" "1 0" "9 999" "999 9" "12345 67890" "123 1000000000000000000000"  | sed -rf add.sed
0
1
1
1008
1008
80235
1000000000000000000123
$

Bunun yalnızca doğal sayılar için işe yaradığını unutmayın. Ancak (en azından teoride) keyfi olarak büyük tamsayılar için çalışıyor. Y'de x artış işlemleri yaptığımız için, sipariş verme hızı hızlandırmak için büyük bir fark yaratabilir: x <y, x> y'den daha hızlı olacaktır.

Çizgi , 18 bayt

time -f%e sleep $@

GNU süresi 1.7 veya üstü gerektirir. Çıkış STDERR'ye.

Çevrimiçi deneyin!

Bunun yerleşik kül komutunun GNU zamanından farklı olması nedeniyle B külünde çalışmayacağını unutmayın .

Bir ek bayt pahasına, Bash'i harici komutu kullanmaya zorlamak \timeyerine kullanılabilir time.

Javascript (67)

Muhtemelen çok daha iyi var

a=Array;p=Number;r=prompt;alert(a(p(r())).concat(a(p(r()))).length)

Yakut, 18 karakter

a.times{b=b.next}

Ve iki daha ayrıntılı değişken, 29 karakter

[*1..a].concat([*1..b]).size

Başka bir sürüm, 32 karakter

(''.rjust(a)<<''.rjust(b)).size

Sinek kodu oluşturmada

Evet, aslında orada bir eklenti var, ama + operatörü değil ve ekleyen bir çerçeve fonksiyonu bile değil, bunun yerine anında ekleme işlemini yapan bir yöntem üretiyoruz.

public static int Add(int i1, int i2)
{
    var dm = new DynamicMethod("add", typeof(int), new[] { typeof(int), typeof(int) });
    var ilg = dm.GetILGenerator();
    ilg.Emit(OpCodes.Ldarg_0);
    ilg.Emit(OpCodes.Ldarg_1);
    ilg.Emit(OpCodes.Add);
    ilg.Emit(OpCodes.Ret);
    var del = (Func<int, int, int>)dm.CreateDelegate(typeof(Func<int, int, int>));
    return del(i1, i2);
}

Yakut 39

f=->a,b{[*1..a].concat([*1..b]).length}

R 36

function(x,y)length(rep(1:2,c(x,y)))

burada ikiler tarafından izlenenlerin repbir vektörünü oluşturur .xy

TI Basic 89 - 19 bayt

Bunu TI-89'unuzda çalıştırın (Ana ekran veya programlama uygulaması):

ln(ln((e^e^x)^e^y))

Bu, bu çözümdex+y olduğu gibi, hesaplama yapmak için günlük kurallarını kullanır . Bir bonus olarak, ondalık ve tam sayı için çalışır. Tüm gerçek sayılar için çalışır. Logaritma kuralları karmaşık üslerle hala geçerliyse, bu da karmaşık sayılar için de geçerlidir. Ancak, karmaşık üsler eklemeyi denediğimde hesap makinem gereksiz yere tükeniyor.

Bana Mathematica notasyonu yazdığı için Michael Stern'e teşekkür ederim .

Mathematica - 21 20 bayt

Log@Log[(E^E^x)^E^y]

Bu, bu çözümle aynı yaklaşımı kullanır , ancak kısaltmak için Mathematica'dadır. Bu, negatif ve kayan nokta sayıları ile xve içindeki tamsayılar için çalışır y.

Günlük kurallarını kullanarak ifadeyi basitleştirmek x+y, ancak bu 4 temel işleçten birini değil, üstellemeyi kullandığı için geçerlidir.

Dize aritmetik

Her iki sayıyı da dizgelere dönüştürürüz, dize kesme ile ekleriz (carry ve her şeyi biliyorsunuz), sonra tamsayıya geri ayrıştırırız. 0,100 i1, i2 ile test edilmiş, bir cazibe gibi çalışır. Bunda bir ilave bul!

public static int Add(int i1, int i2)
{
    var s1 = new string(i1.ToString().Reverse().ToArray());
    var s2 = new string(i2.ToString().Reverse().ToArray());
    var nums = "01234567890123456789";
    var c = '0';
    var ret = new StringBuilder();
    while (s1.Length > 0 || s2.Length > 0 || c != '0')
    {
        var c1 = s1.Length > 0 ? s1[0] : '0';
        var c2 = s2.Length > 0 ? s2[0] : '0';
        var s = nums;
        s = s.Substring(int.Parse(c1.ToString()));
        s = s.Substring(int.Parse(c2.ToString()));
        s = s.Substring(int.Parse(c.ToString()));
        ret.Append(s[0]);
        if (s1.Length > 0)
            s1 = s1.Substring(1);
        if (s2.Length > 0)
            s2 = s2.Substring(1);
        c = s.Length <= 10 ? '1' : '0';
    }
    return int.Parse(new string(ret.ToString().ToCharArray().Reverse().ToArray()));
}

C (79)

void main(){int a,b;scanf("%d%d",&a,&b);printf("%d",printf("%*c%*c",a,0,b,0));}

Python - 22 karakter

len(range(x)+range(y))

APL: 2

1⊥

Bu sayıları taban 1'den dönüştürür, yani (n * 1 ^ 1) + (m * 1 ^ 2) tam olarak n + m olur.

Yargılanacaklar Can TryApl.org

TI-BASIC, 10

Ekler XveY

ln(ln(e^(e^(X))^e^(Y

K, 2 bayt

#&

Kullanım örneği:

  #&7 212
219

"Where" işlecini (monadik &) bir giriş listesindeki numaralara uygulayın ( giriş biçimiyle ilgili özgürlük alarak). Bu, ilk sıfır sayısını ve ardından ikinci sayısını içeren bir liste üretecektir:

  &3 2
0 0 0 1 1

Normalde bu operatör, bir boole listesinin sıfır olmayan elemanlarının indekslerinin bir listesini üretmek için "topla" olarak kullanılır, ancak genelleştirilmiş form ara sıra kullanışlı olur.

O zaman sadece bu listenin sayısını (monadik #) alın.

Giriş gereklilikleri yorumum kabul edilemez ise, aşağıdaki biraz daha uzun çözüm aynı hile yapar:

{#&x,y}

Pyth , 29 bayt

AQW!qG0=k.&GH=HxGH=k.<k1=Gk)H

Çevrimiçi deneyin!

Buraya ilk gönderimim!

Bu derler:

assign('Q',eval_input())     # Q
assign('[G,H]',Q)            #A
while Pnot(equal(G,0)):      #  W!qG0
  assign('k',bitand(G,H))    #       =k.&GH
  assign('H',index(G,H))     #             =HxGH  (index in this case is XOR)
  assign('k',leftshift(k,1)) #                  =k.<k1
  assign('G',k)              #                        =Gk)
imp_print(H)                 #                            H