Kendim tarafından icat edilen bir sayının kare sayı basamak yoğunluğu (SNDD), art arda basamaklarda bulunan kare sayılarının sayısının sayının uzunluğuna oranıdır. Örneğin 169, 4 kare sayısı - 1, 9, 16, 169 - içeren 3 basamaklı bir sayıdır ve bu nedenle kare sayısı basamak yoğunluğu 4/3 veya 1,33'tür. 4 haneli 1444 sayısı 6 kareye - 1, 4, 4, 4, 144, 1444 - ve dolayısıyla 6/4 veya 1.5 oranına sahiptir. Önceki örnekte, karelerin tekrarlanmasına izin verildiğine dikkat edin. Ayrıca, 441'e izin verilmez, çünkü 1444 sayısının içinde art arda bulunamaz.

Göreviniz, en yüksek kare sayısı basamak yoğunluğuna sahip sayı için belirli bir A - B aralığını (dahil) araştıran bir program yazmaktır. Programınız aşağıdaki özelliklere uymalıdır:

• A, B girişini 1 ila 1.000.000.000 (1 milyar) aralığında alın. Misal:sndd 50 1000
• Sonuç olarak en büyük SNDD'ye sahip sayıyı döndürün. Beraberlik durumunda, en küçük sayıyı döndürün.
• 0, 0, 00, 000 vb. Şeklinde herhangi bir kare olarak sayılmaz. 0 ile başlayan, 049 veya 0049 gibi kareler de yoktur.
• Sayının tamamının kare sayı olması gerekmediğini unutmayın.

Örnekler:

sndd 14000 15000
Output: 14441

sndd 300 500
Output: 441

Bonus: 1 ile 1.000.000.000 arasında en büyük SNDD'ye sahip sayı nedir? Bunun mümkün olan en büyük olup olmadığını veya daha yüksek bir aralıkta daha büyük bir tane olduğunu kanıtlayabilir misiniz?

Güncel Skorlar:

1. Yakut: 142
2. Windows PowerShell: 153
3. Scala: 222
4. Python: 245

Bir yanıt seçildiğine göre, JavaScript'teki (ungolfed) referans uygulamam: http://jsfiddle.net/ywc25/2/

Yakut 1.9, 142 karakter

$><<($*[0]..$*[1]).map{|a|n=0.0;(1..s=a.size).map{|i|n+=a.chars.each_cons(i).count{|x|x[0]>?0&&(r=x.join.to_i**0.5)==r.to_i}};[-n/s,a]}.min[1]

• (139 -> 143): Beraberlik durumunda sabit çıkış.

Bonusu cevaplamak için: <1e9 rakamları için en iyi puan 144411449 (ve belki de diğerleri?) Tarafından oluşturulan 5/3 = 1.666 ... 'dır.

Ancak daha büyük sayılarla daha iyisini yapabilirsiniz. Genellikle n'nin x puanı varsa, n'nin iki kopyasını birleştirebilir ve aynı puanı x elde edebilirsiniz. Eğer şanslıysanız ve n aynı ilk ve son basamağa sahipse, bu basamaklardan birini birleştirme içinde bırakabilir ve puanınızı hafifçe artırabilirsiniz (karelerin sayısının iki katından az ve basamak sayısının iki katından az). .

n = 11449441, 1.625 puanına sahiptir ve aynı ilk ve son basamağa sahiptir. Bu gerçeği kullanarak, aşağıdaki puan dizisini elde ederiz:

1.625 for 11449441
1.666 for 114494411449441
1.682 for 1144944114494411449441
1.690 for 11449441144944114494411449441
1.694 for 114494411449441144944114494411449441

bu da önceki sayılardan kesinlikle (azalan olmasına rağmen) daha iyi olan ve ilk 2 hariç tümü <1e9 sayıları için en iyi puandan daha iyi olan sonsuz bir sayı dizisi verir.

Bununla birlikte, bu dizi genel olarak en iyi olmayabilir. Sonlu bir puana yaklaşır (12/7 = 1.714) ve limitten daha iyi skorlara sahip başka sayılar olabilir.

Düzenleme : daha iyi bir sıra, 1,75'e yakınsar

1.600 14441
1.667 144414441
1.692 1444144414441
1.706 14441444144414441
1.714 144414441444144414441

Windows PowerShell, 153 154 155 164 174

$a,$b=$args
@($a..$b|sort{-(0..($l=($s="$_").length)|%{($c=$_)..$l|%{-join$s[$c..$_]}}|?{$_[0]-48-and($x=[math]::sqrt($_))-eq[int]$x}).Count/$l},{$_})[0]

Ventero sayesinde bir baytlık bir azalma için kendimi bulamayacak kadar aptaldım.

154 baytlık sürüm açıkladı:

$a,$b=$args   # get the two numbers. We expect only two arguments, so that
              # assignment will neither assign $null nor an array to $b.

@(   # @() here since we might iterate over a single number as well
    $a..$b |  # iterate over the range
        sort {   # sort
            (   # figure out all substrings of the number
                0..($l=($s="$_").length) | %{  # iterate to the length of the
                                               # string – this will run off
                                               # end, but that doesn't matter

                    ($c=$_)..$l | %{       # iterate from the current position
                                           # to the end

                        -join$s[$c..$_]    # grab a range of characters and
                                           # make them into a string again
                    }
                } | ?{                     # filter the list
                    $_[0]-48 -and          # must not begin with 0
                    ($x=[math]::sqrt($_))-eq[int]$x  # and the square root
                                                     # must be an integer
                }

            ).Count `  # we're only interested in the count of square numbers
            / $l       # divided by the length of the number
        },
        {-$_}  # tie-breaker
)[-1]  # select the last element which is the smallest number with the
       # largest SNDD

Piton, 245 , 256

import sys
def t(n,l):return sum(map(lambda x:int(x**0.5+0.5)**2==x,[int(n[i:j+1])for i in range(l)for j in range(i,l)if n[i]!='0']))/float(l)
print max(map(lambda x:(x,t(str(x),len(str(x)))),range(*map(int,sys.argv[1:]))),key=lambda y:y[1])[0]

• 256 → 245: Keith Randall'ın bir ipucu sayesinde argüman ayrıştırma kodu temizlendi .

Aralık stdin, komut satırı bağımsız değişkenlerinin aksine okunduysa bu çok daha kısa olabilir .

Düzenle:

Bonus ile ilgili olarak, deneylerim şunları önermektedir:

Konjektif 1 . Her n ∈ ℕ için , en büyük SNDD'ye sahip ℕ _{≤ n} rakamı yalnızca 1, 4 ve 9 rakamlarını içermelidir.

Sanısı 2. ∃ n ∈ ℕ ∀ i ℕ ∈ _{≥ N} : SNDD ( n ) ≥ SNDD ( i ).

Kanıt kroki . 1, 4 ve 9 basamaklı kareler kümesi muhtemelen sonludur . ∎

Scala, 222

object O extends App{def q(i: Int)={val x=math.sqrt(i).toInt;x*x==i}
println((args(0).toInt to args(1).toInt).maxBy(n=>{val s=n+""
s.tails.flatMap(_.inits).filter(x=>x.size>0&&x(0)!='0'&&q(x.toInt)).size.toFloat/s.size}))}

(Scala 2.9 gerekir.)

Bonus sorusu göz önüne alındığında: Aralık dışında mümkün olan en yüksek SNDD sınırsızdır.

En azından soruyu doğru okursam 100 (10 * 10) gibi bir kare sayılır.

275625 sayısını düşünürseniz, skor 5/6'dır, çünkü 25, 625, 5625, 75625 ve 275625'in hepsi karedir.

2 sıfır eklenmesi: 27562500, puanı 10/8. Bu dizinin sınırı 5/2 = 2,5'tir.

Aynı çizgiler boyunca, istediğiniz sayıda daha küçük kareyle sonuçlanan kareler bulabilirsiniz. Bunu kanıtlayabilirim, ama muhtemelen fikri anlarsın.

Kuşkusuz, bu çok hoş bir çözüm değil, ancak SNDD'nin üst sınırı olmadığını kanıtlıyor.

Clojure - 185 karakter

Muhtemelen daha da optimize edilebilir, ancak işte gidiyor:

(fn[A,B]((first(sort(for[r[range]n(r A(inc B))s[(str n)]l[(count s)]][(/(count(filter #(=(int%)(max 1%))(for[b(r(inc l))a(r b)](Math/sqrt(Integer/parseInt(subs s a b))))))(- l))n])))1))

İki parametreli bir işlev olarak kullanılır:

(crazy-function-as-above 14000 15000)
=> 14441

Jelly , 21 bayt, dil postdates zorluğu

DµẆ1ị$ÐfḌƲS÷L
rµÇÐṀḢ

Çevrimiçi deneyin!

açıklama

Yardımcı işlevi (girişinin basamak yoğunluğunu hesaplar):

DµẆ1ị$ÐfḌƲS÷L
Dµ              Default argument: the input's decimal representation
  Ẇ             All substrings of {the decimal representation}
      Ðf        Keep only those where
   1ị$          the first digit is truthy (i.e. not 0)
        Ḍ       Convert from decimal back to an integer
         Ʋ     Check each of those integers to see if it's square
           S    Sum (i.e. add 1 for each square, 0 for each nonsquare)
            ÷L  Divide by the length of {the decimal representation}

Ana program:

rµÇÐṀḢ
rµ              Range from the first input to the second input
  ÇÐṀ           Find values that maximize the helper function
     Ḣ          Choose the first (i.e. smallest)

Program tartışmasız daha ilginç olmadan Ḣ- bu şekilde, sadece bir değil, tüm maksimum yoğunluklu sayıları döndürür - ancak spesifikasyona uymak için ekledim.