Meydan okuma:

Okur sosyal ağlarda dolaşan aptalca bir bulmaca var:

8 + 2 = 16106
5 + 4 = 2091
9 + 6 = ?

Bir fonksiyon veya operatör uygulanması iki pozitif tam sayı verildiğinde, bu xve ybu şekilde x > y > 0, bir şekilde doğru yanıt veren tamsayı cevabım hane basamak vardır, x * ybasamak ardından x + ybasamak takip x - y. Çok basit.

Kurallar:

• Standart boşluklara izin verilmez.
• Bu kod-golf yani bayt cinsinden en kısa kod kazanır.
• Giriş verisi doğrulama gerekli değildir . Bu program geçersiz girdi verildiğinde çökebilir veya geri dönebilir.
• Sayısal işlevler ve işleçler kullanmanıza izin verilir (tam sayı ve kayan nokta, matematik kitaplığı işlevleri ve sayıları kabul edip döndüren diğer işlevler dahil).
• Varsa, bir sayının basamağını döndüren bir işlev kullanmanıza izin verilir.
• Sen ediyoruz değil dizeleri veya kodunuzda birleştirme her yerde her türlü kullanmasına izin.
• Sonuç, hangi dilde geçerli olursa, yığına iade edilebilir veya itilebilir. Sonuç bir dize değil tam sayı olmalıdır.

Basit kod:

Dyalog APL :

Aşağıdaki kod adında bir dyadic işleci oluşturur X.

X ← {(⍺-⍵) + ((⍺ + ⍵) x 10 x 1 + ⌊10⍟⍺-⍵) + ⍺ x ⍵ * 10 * (2 + ⌊10⍟⍺ + ⍵) + ⌊10⍟⍺- ⍵}

Açıklama:

• APL'de sağdan sola doğru değerlendirirsiniz.

• ⍺ and ⍵ sırasıyla sol ve sağ işlenen

• ⌊10⍟⍺-⍵okur: floor of log10(⍺-⍵). İlk önce çıkarma işlemi, ardından logaritma sonra döşeme. Sağdan sola doğru. log10, rakamlarını saymak için yapılır ⍺-⍵(daha sonra 1 toplamalısınız).

• ⍺×⍵×10*(...) okur: 10 to the (...)th power, multiplied by ⍵, multiplied by ⍺

• Bu nedenle, ⍺×⍵×10*(2+⌊10⍟⍺+⍵)+⌊10⍟⍺-⍵toplam sayı ve fark sayısının toplamı ile sola kaydırılan üründür. 10'luk bir güçle çarpmak bir tamsayı sola kaydırır.

• ((⍺+⍵)×10*1+⌊10⍟⍺-⍵) farkın basamak sayısı ile sola kayan toplamdır.

• (⍺-⍵)fark. Burada kaydırma gerekmez.

• X←{...} APL'de bir işleci nasıl tanımladığınızdır.

Örnekler:

      8 X 2
16106
      5 X 4
2091
      9 X 6
54153

GNU dc:

Aşağıdaki kod adlı bir makro oluşturur a:

[sysx10lxly-dseZdsclxly+dsd+Z1+^lxly**10lc^ld*+le+]sa

Açıklama:

• sxve sybir öğeyi yığından çıkarın ve kayıtlara xve ysırasıyla kaydedin .

• lxve lybir elemanı kayıt defterlerinden yükleyin xve ysırasıyla istifin üzerine itin.

• d yığındaki son öğeyi çoğaltır.

• ^ İki sayının gücünü hesaplar.

• ZBir sayı açar ve sayı sayısını döndürür. Bu yapılır çünkü dclogaritma fonksiyonu yoktur.

• [...]saMakroyu kayıt defterinde saklar a. layükler. xMakroyu yığının en üstünde yürütür.

Örnekler:

8 2 laxn
16106
5 4 laxn
2091
9 6 laxn
54153

JavaScript (ES7), 63 61 59 bayt

Neil sayesinde 4 byte kurtarıldı .

(a,b)=>[a*b,a+b,a-b].reduce((p,c)=>p*10**-~Math.log10(c)+c)

<input id=a type=number oninput="c.innerText=((a,b)=>[a*b,a+b,a-b].reduce((p,c)=>p*10**-~Math.log10(c)+c))(+a.value,+b.value)">
<input id=b type=number oninput="c.innerText=((a,b)=>[a*b,a+b,a-b].reduce((p,c)=>p*10**-!Math.log10(c)+c))(+a.value,+b.value)">
<p id=c>

C, 79 75 bayt

4 byte kaydettiğiniz için @GB!

#define X for(c=1;(c*=10)<=a
c,d;f(a,b){X+b;);d=c*a*b+a+b;X-b;);a=d*c+a-b;}

Çevrimiçi deneyin!

Bash, 66

• @Chepner sayesinde 2 bayt kaydedildi.

f()(s=$[$1+$2]
d=$[$1-$2]
echo $[($1*$2*10**${#s}+s)*10**${#d}+d])

Çevrimiçi deneyin .

EXCEL, 61 Bayt

=A1-B1+(A1+B1)*10^LEN(A1-B1)+A1*B1*10^(LEN(A1-B1)+LEN(A1+B1))

Excel, 18 Bayt geçerli değil

=A1*B1&A1+B1&A1-B1

Yığılmış , 36 bayt

,@A$(*+-){!A...n!}"!{%y#'10\^x*y+}#\

Çevrimiçi deneyin!

Önceden: ,@A$(-+*){!A...n!}"!:inits$#'"!$summap:pop@.10\^1\,\*sum

Bir açıklama yazmadan önce bir veya iki byte sıkmaya çalışacağım. ( #'= büyüklüğü ve ""her biri üzerinde", burada ekli dizeler yok.)

26 bayt rakip olmayan: $(*+-)#!!:{%y#'10\^x*y+}#\.

TI-Basic, 34 33 bayt

Prompt A,B
A-B+(A+B)10^(1+int(log(A-B
Ans+AB10^(1+int(log(Ans

GNU dc, 36

mYığının en üstteki iki üyesini alan bir makro tanımlar, makroyu uygular ve sonucu yığına bırakır (söz konusu örnekte olduğu gibi):

[sadsbla-dZAr^lalb+*+dZAr^lalb**+]sm

Çevrimiçi deneyin .

Perl 6 ,  81 61  58 bayt

->\x,\y{($/=($/=x- y)+(x+y)*({10**$++}...*>$/).tail)+x*y*({10**$++}...*>$/).tail}

Dene

->\x,\y{(x*y,x+y,x- y).reduce:{$^a*10**Int(1+log10($^b))+$b}}

Dene

->\x,\y{[[&({$^a*10**Int(1+$^b.log10)+$b})]] x*y,x+y,x- y}

Dene

Jöle , 27 bayt

+,ạ,.1Fl⁵Ḟ‘€Ṛ+\⁵*
ạ,+,×Fæ.ç

İle çağrılabilir bir ikili bağlantı / işlev tanımlar ç. Giriş olarak iki tamsayı alır ve bir tamsayı döndürür. Mutlak fark kullanarak x <y ya da x >y alabilen ek bir avantaja sahiptir .

Çevrimiçi deneyin!

Açıklama:

+,ạ,.1Fl⁵Ḟ‘€Ṛ+\⁵* -- Create link which computes what order of magnitude
                        to multiply the difference, sum, and product by
ạ,+,×Fæ.ç         -- Main link, applies this using dot product

Detaylar:

+,ạ,.1Fl⁵Ḟ‘€Ṛ+\⁵* -- Create dyadic like which does the following:
       l⁵Ḟ‘       -- Create operation which computes number of digits
                       (log base 10 (⁵ is the literal 10), floored, incremented)
           €      -- Apply this to each element in
+,ạ,.1F           -- ... the list [sum,difference,.1]
            R     -- Reverse the list
             +\   -- Add up first n elements to get list.
               ⁵* -- Raise 10 (⁵ is literal 10) to the power of each element

ạ,+,×Fæ.ç         -- Main link, applies above link
ạ,+,×F            -- The list [difference, sum, product]
      æ.          -- Dot product (multiply corresponding elements) with
        ç         -- The above link.

PHP, 79 75 bayt

iki versiyon:

[,$a,$b]=$argv;echo(10**strlen($s=$a+$b)*$a*$b+$s)*10**strlen($d=$a-$b)+$d;
[,$a,$b]=$argv;echo(10**strlen($a+$b)*$a*$b+$a+$b)*10**strlen($a-$b)+$a-$b;

komut satırı argümanlarından girdi alır; ile koş -r.

Sanırım strlen, "basamak sayısını döndürür fonksiyonu" olarak bunun yeterli olduğunu
, bir dize olarak numarasını kullanır rağmen. Olmazsa haberim olsun.

C (gcc) , 70 bayt

#define _ for(c=1;a+b>=(c*=10););d=c*d+a-(b=-b);
c,d;f(a,b){d=a*b;_ _}

Çevrimiçi deneyin!

Steadybox cevabını temel alan , biraz daha golf oynamak için her şeyi bir makroya koyarak.

(Not: sonucu işler dyerine abeklenmedik bir şekilde atama . Oluşturulan derleme koduna baktım ve sorun yok gibi görünüyor.)

Haskell, 54 bayt

a%0=a
a%b=10*a%div b 10+mod b 10
a#b=(a*b)%(a+b)%(a-b)

Bulmacanın bir ekleme işlevi aracılığıyla uygulandığı #, örneğin 8#2 = 16106. Diğer fonksiyon, %baz-10 birleştirmeyi tanımlar (RHS'nin 0'dan büyük olduğu varsayılarak).

Dyalog APL, 31 bayt

{a⊥⍨10*1+⌊10⍟a←(⍺×⍵)(⍺+⍵)(⍺-⍵)}

problem beyanındaki örnek APL kodunu temel alarak

PHP, 87 Bayt

[,$a,$b]=$argv;echo($s=$a-$b)+($t=$a+$b)*10**($l=strlen($s))+$a*$b*10**($l+strlen($t));

ve 37 Bayt için geçerli olmayan bir çözüm

[,$a,$b]=$argv;echo$a*$b,$a+$b,$a-$b;

Ruby, 61 bayt

->a,b{[a*b,a+b,a-b].reduce{|x,y|z=y;x*=10while(z>z/=10);x+y}}

Şüpheli bir şekilde bu Javascript cevap gibi görünüyor , ancak bir logaritma kullanmadan.

Python, 92 91 Karakter

def g(x,y):
    l=lambda x,i=0:l(x/10,i+1)if x else 10**i
    a=x-y
    a+=(x+y)*l(a)
    return x*y*l(a)+a

Sihirbazlar önerisi sayesinde;)

R (3.3.1), 104 bayt

function(x,y)Reduce(function(p,q)p*10^(floor(log10(q)+1))+q,lapply(c(`*`,`+`,`-`),function(z)z(x,y)),0)

isimsiz bir işlev döndürür.

Bu benim ilk golf denemem, bu yüzden herhangi bir geri bildirim için teşekkür ederiz.

REXX, 70 bayt

f:arg a b
c=a-b
c=(a+b)*10**length(c)+c
c=a*b*10**length(c)+c
return c

Tabii ki, doğal yol çok daha kısa olurdu:

f:arg a b
return a*b||a+b||a-b

PowerShell, 88 Bayt

param($x,$y)$l=2;if(($a=$x+$y)-gt9){$l++};($x*$y)*[math]::Pow(10,$l)+$a*10+$x-$y

PowerShell, yardımcı olmayan bir operatöre sahip değildir. Ayrıca yapamadığımız bir dize olarak sayılmazsanız, bir tamsayının uzunluğunu sayamazsınız, bu yüzden -gtuzunluğu öğrenmek için 9 olup olmadığını kontrol ederim . Muhtemelen daha özlü olabilirdi ama işe geri dönmem gerekiyor.

Python 2.7, 109 96 bayt

import math
a=lambda n:10**int(math.log10(10*n))
b,c=input()
d=b-c+(b+c)*a(b-c)
print d+b*c*a(d)

Yarışma kurallarına uyarak düzeltildi. Kodu 109 bayttan 96 bayta indiren mbomb007 için krediler

J , 25 bayt

X=.10#.[:;10#.inv&.>*;+;-

1. *;+;- Her işlemin sonuçlarını kutulayın.
2. 10#.inv&.>Her sonucu bir 10 basamaklık basamak dizisine dönüştürün. ( involup^:_1 )
3. [:; Kutuyu kaldırın ve dizilere katılın.
4. 10#. Temel 10 basamak dizisini bir tamsayıya dönüştürün.
5. X=. yukarıdakileri operatör olarak tanımlayın X .

Sonuçlar:

   8 X 2
16106
   5 X 4
2091
   9 X 6
54153

Mathematica, 67 bayt

c=Ceiling;l=Log10;#-#2+(#+#2)10^(c@l[#-#2]/. 0->1)+10^c@l[2#]10#2#&

Alır x-y, daha sonra log'unu alır10 x-y, onu yuvarlar, gücünü 10 ile hesaplar ve sonra ile çarpar x+y. Ama aynı zamanda log10(x-y)0 olmayı da düşünmeliyiz , bu yüzden 0'ı 1 ile değiştirelim. Daha sonra log10'u 2x, yuvarlatılmış, artı 1'i alırız ve bunun gücüne 10 buluruz. Şununla çarpın xyve ekleyin.

05AB1E , 23 22 16 bayt

-Dg°¹²+*Dg°¹²**O

Çevrimiçi deneyin!

"-+*"Her işlem için gerçekleştirilen kod aynı olduğundan, işlemleri içeren bir dize üzerinde döngü kullanarak programda (ancak hesaplamalarda değil) dizeleri kullanmamıza izin verilirse, birkaç bayt tasarruf edebilirdik .
Elbette, birleştirme kullanmamıza izin verilirse, çok daha fazla tasarruf elde ederiz.

R, 64 bayt

x=scan();(b=(a=diff(-x))+10^nchar(a)*sum(x))+10^nchar(b)*prod(x)

Kullanımı:

> x=scan();(b=(a=diff(-x))+10^nchar(a)*sum(x))+10^nchar(b)*prod(x)
1: 8 2
3: 
Read 2 items
[1] 16106