Giriş

Bu mücadelede, pozitif tamsayıların belirli bir sıralamasıyla ilgileneceğiz. Sipariş şu şekilde gider:

   3,    5,    7,    9,    11, ...
 2*3,  2*5,  2*7,  2*9,  2*11, ...
 4*3,  4*5,  4*7,  4*9,  4*11, ...
 8*3,  8*5,  8*7,  8*9,  8*11, ...
16*3, 16*5, 16*7, 16*9, 16*11, ...
 ...
... 64, 32, 16, 8, 4, 2, 1

İlk önce 1'den büyük tüm tuhaf tamsayıları artan düzende sıralıyoruz. Daha sonra 1'den büyük iki tam sayı, daha sonra 4 kat, sonra 8 kat vb. Listeleriz : tüm k için , artan sırayla 2 ^k kat tek tamsayıları 1'den büyük olarak listeleriz . Son olarak, ikisinin güçlerini azalan düzende sıralayarak, 1'den bitiyoruz. Her pozitif tamsayı tam olarak bir kez bu "listede" meydana geliyor.

Daha açık bir şekilde, A = n · 2 ^p ve B = m · 2 ^q olan iki ayrı pozitif tamsayıyı düşünün , burada n, m ≥ 1 tek ve p, q ≥ 0 olur . Ardından , aşağıdaki koşullardan birinin geçerli olması durumunda, sipariş sırasında A , B'den önce gelir :

• n> 1 , m> 1 ve p <q
• 1 <n <m ve p = q
• n> m = 1
• n = m = 1 ve p> q

Bu sıralama , dinamik sistemlerin periyodik noktalarını ilgilendiren Sharkovskii teoremi olarak bilinen şaşırtıcı matematiksel sonuçta ortaya çıkıyor . Buradaki ayrıntılara girmeyeceğim.

Görev

Bu zorluktaki göreviniz yukarıdaki sıralamayı hesaplamak. Girişleriniz, eşit olabilen iki pozitif ve A ve B tamsayılarıdır . Eğer siparişte A , B den önce gelirse , aksi takdirde sahte bir değer gelirse, çıktınız bir gerçek değerdir. Eğer A = B , çıktı truthy olmalıdır. Tutarlı olduğunuz sürece A ve B'yi her iki sırada da alabilirsiniz .

Tamsayı taşması konusunda endişelenmenize gerek yoktur, ancak algoritmanızın keyfi olarak büyük girdiler için teorik olarak çalışması gerekir.

Test durumları

Truthy örnekleri

3 11
9 6
48 112
49 112
158 158
36 24
14 28
144 32
32 32
32 8
3 1
1 1

Sahte örnekler

1 2
1 5
11 5
20 25
2 8
256 255
256 257
72 52
2176 1216
2176 2496

Python 2, 87 71 bayt

k=lambda n:[n&~-n<1,(n&-n)*cmp(n&~-n,1),n/(n&-n)]
lambda a,b:k(a)<=k(b)

Bu muhtemelen herhangi bir boyut ödülü kazanmayacak, ancak bu cevap, sözlüksel olarak sıralandığında doğru sıralamaya yol açacak bir tamsayıdan 3 ifade kullanarak 3 tuple oluşturarak çalışır.

Okunabilir terimlerle, demet A = n · 2 ^{p içindir} :

[n == 0, p * (1 - 2*(n == 0)), n]

JavaScript (ES6), 53 49 bayt

f=(a,b)=>b<2||a>1&&(a&b&1?a<=b:a&1|~b&f(a/2,b/2))

Açıklama:

• B 1 ise, o zaman bir eşittir (veya eşittir) b
• Aksi takdirde, a 1 ise, a b'den önce gelmez.
• Aksi takdirde, hem a hem de b garipse, düzenli eşitsizlik kontrolünü kullanın
• Aksi takdirde, eğer a tuhafsa, b'den önce gelir.
• Aksi takdirde, eğer b garip ise, o durumda b, b'den önce gelmez.
• Aksi takdirde, hem a hem de b'yi 2'ye bölün ve tekrar deneyin.

Düzenleme: @Arnauld sayesinde 2 bayt kaydedildi.

Python 2,50 bayt

lambda*l:cmp(*[([-n][n&n-1:],n&-n,n)for n in l])<1

Her sayı, sıralama sırası istenen sıraya göre üçlü olarak eşleştirilir.

• Birincil değer, [-n][n&n-1:]sonunda 2'nin gücünü kullanan değerdir . Bitsel "ve" gücü n&n-1tam olarak ne zaman sıfırdır . Eğer öyleyse, listeyi ve aksi takdirde boş listeyi alırız . Bu, emrin sonundaki 2'nin tüm güçlerini azalan düzende verir.n2[-n][]
• İkincil değer n&-n2 gücünün faktörünü çıkarır n.
• Nihai değer ntiebrea, daha büyük sayılar lehine 2 eşit güç sağlar.

Bu cmpkarşılaştırmanın yapılıp yapılmadığını görmek için ilgili tupllere geçilir <=0. Python 3 (n&n-1<1)/n, üçlü değerdeki ilk değer için kayan bölmeli bir baytı korur, ancak yoksundur cmp.

JavaScript (ES6), 70 64 bayt

Muhtemelen biraz daha golf oynayabilir, ancak ilk girişim olarak:

x=>y=>(a=x&-x,x/=a,b=y&-y,y/=b,y<2?x>1|b<=a:x>1&(b>a|b==a&y>=x))

Karıştırma sözdizimi ile girdi alır (x)(y). Döndürür 0/ 1.

Test durumları

let f =

x=>y=>(a=x&-x,x/=a,b=y&-y,y/=b,y<2?x>1|b<=a:x>1&(b>a|b==a&y>=x))

console.log('Testing truthy instances ...');
console.log(f(3)(11));
console.log(f(9)(6));
console.log(f(48)(112));
console.log(f(49)(112));
console.log(f(158)(158));
console.log(f(36)(24));
console.log(f(14)(28));
console.log(f(144)(32));
console.log(f(32)(32));
console.log(f(32)(8));
console.log(f(3)(1));
console.log(f(1)(1));

console.log('Testing falsy instances ...');
console.log(f(1)(2));
console.log(f(1)(5));
console.log(f(11)(5));
console.log(f(20)(25));
console.log(f(2)(8));
console.log(f(256)(255));
console.log(f(256)(257));
console.log(f(72)(52));
console.log(f(2176)(1216));
console.log(f(2176)(2496));

Perl 6 , 89 84 bayt

->\a,\b{my \u=*>max a,b;a==first a|b,flat [1,2,4...u].&{(3*$_,5*$_...u for $_),.reverse}}

{my \u=*>@_.max;@_[0]==first @_.any,flat [1,2,4...u].&{.map(*X*(3,5...u)),.reverse}}

( Çevrimiçi deneyin. )

Tam olarak kısa değil, ancak sipariş sırasını oluşturan her bir çözümün yazılmasının ilginç olacağını düşündüm (her alt dizi için güvenli bir üst sınıra kadar) ve sonra içinde hangi girişin göründüğünü kontrol eder.

Örneğin:

• Giriş 2, 3için üretir:

  3 5
  6
  12
  4 2 1

  ... ve daha 3önce göründüğü gözlemleri 2.

• Giriş 9, 6için üretir:

  3 5 7 9 11
  6 10
  12
  24
  48
  16 8 4 2 1

  ... ve daha 9önce göründüğü gözlemleri 6.

Daha akıllı olabilir ve dizilimden daha az üretebilir, ancak bu daha fazla kod baytı alır.

Python 2, 54 bayt

f=lambda a,b:b<2or[f(a/2,b/2),a>1,0,1<a<=b][a%2+b%2*2]

Neil'inkine benzer özyinelemeli bir çözüm.

Mathematica, 65 bayt

OrderedQ[{1,#}&/@#//.{a_,b_/;EvenQ@b}->{2a,b/2}/.{a_,1}->{∞,-a}]&

Adsız işlev, pozitif tamsayıların bir listesini alarak ve liste TrueSharkovskii sırasına göre artan bir sekans oluşturuyorsa döner False. (Özellikle, giriş listesinin yalnızca iki öğeye sahip olması gerekmez; ek işlevsellikten ücretsiz yararlanırız.)

Algoritma, kalp fonksiyonu olan {1,#}&/@#//.{a_,b_/;EvenQ@b}->{2a,b/2}sürekli biçimde bir tamsayı dönüştürmek için yaklaşık 2 faktörlerini taşır, m*2^kile, msipariş çift, tek {2^k,m}(ve giriş listesinin her elemanına yapar). OrderedQsonra sıralanan çiftlerin sonuç listesinin sıralanıp sıralanmadığına karar verir; Bu, varsayılan olarak, ilk eleman tarafından sıranın arttırılması, ardından ikinci eleman tarafından sıranın arttırılması anlamına gelir.

Tam olarak istediğimiz bu, ancak ikisinin gücü olan sayılar farklı kuralları izler. Bu nedenle OrderingQ, kontrol etmeden önce /.{a_,1}->{∞,-a}, (örneğin) ' {64,1}a {∞,-64}; bu da 2'nin yetkilerini siparişte doğru noktaya yerleştiriyor.

Haskell, 143 138 bayt

Temelde kriterlerin nispeten basit bir uygulaması:

e n=head[k-1|k<-[0..],n`mod`(2^k)>0]   -- exponent of 2
f n=n`div`2^e n                        -- odd part
a#b|n<-f a,p<-e a,m<-f b,q<-e b=n>1&&(m>1&&p<q||n<m&&p==q||m<2)||n<2&&m<2&&p>q||a==b  

Çevrimiçi deneyin!

Python, 159 158 153 144 142 141 bayt

Kaydedilen bir 2 Kritixi Lithos sayesinde bayt!

Bu sadece Python'umda golf oynamak için.
Tüm akıllıca cevapların yollarından ziyade OP tarafından verilen formülü kullandı

f=lambda a,p=0:(a&1)*(a,p)or f(a>>1,p+1)
t=lambda(n,p),(m,q):(n==1)*(m==1)&(p>=q)or (m>1)&(p<=q)|(n<=m)&(p==q)or m==1
lambda a,b:t(f(a),f(b))