Eldeki görev, bir sayı verildiğinde , sayının başlangıcında sayının AT LEASTn ile başlayan en küçük üssü bulmaktır . Bu, OEIS'de bulduğum bir dizi ( A068103 ). n2

Dizideki ilk 17 sayı aşağıda verilmiştir, eğer daha fazlasını istiyorsanız, gerçekten yapmamın sakıncası olmayan diziyi uygulamam gerekecek.

0  = 2
1  = 2
2  = 223
3  = 2221
4  = 22229
5  = 2222203
6  = 22222223                # Notice how 6 and 7 are the same! 
7  = 22222223                # It must be **AT LEAST** 6, but no more than necessary.
8  = 222222227
9  = 22222222223             # Notice how 9 and 10 are the same!
10 = 22222222223             # It must be **AT LEAST** 9, but no more than necessary.
11 = 2222222222243
12 = 22222222222201
13 = 22222222222229
14 = 222222222222227
15 = 222222222222222043
16 = 222222222222222221

Bunun dizge manipülasyonu, asal algılama ve sekansın harika bir kombinasyonu olacağını düşündüm. Bu kod golf , en düşük bayt sayısı muhtemelen ay sonunda kazanan ilan edilecek.

Brachylog , 12 11 bayt

:2rj:Acb#p=

Çevrimiçi deneyin!

Bu, şaşırtıcı bir şekilde doğrudan Brachylog'a çevrilir. Bu tam bir program değil bir fonksiyondur (tercümana Zbir komut satırı argümanı olarak verilmesi , fonksiyonun bir program haline getirilmesi için uygun sargının eklenmesine neden olur; TIO bağlantısının çalışmasını sağlamak için yaptım). Ayrıca j-1 indekslenmiş gibi görünen ve buna izin verecek bir düzeltmeye ihtiyaç duyan oldukça talihsiz bir durumdur.

Gerekmediğine dair makul bir argüman yapabilirsiniz =, ancak sorunun nasıl ifade edildiğine bakıldığında; fonksiyon Belirli sayıda başlayan tüm asal sayıların kümesini tanımladığı olmadan 2s ve program gerektiğini bazı açık ifadeye olmadan yapmak (ilk değer üreten, bu durumda) bu bilgi ile bir şey, muhtemelen değil şartnameye uymak.

açıklama

:2rjbAcb#p=
:2rj         2 repeated a number of times equal to the input plus one
    :Ac      with something appended to it
       b     minus the first element
        #p   is prime;
          =  figure out what the resulting values are and return them

Bir tamsayı döndüren bir işlev olarak kullanıldığında, hiçbir şey birinciden önce değer istemez, bu nedenle ilki endişelenmemiz gereken şeydir.

Bir incelik (yorumlarda belirtildiği gibi): :Acbve b:Acmatematiksel olarak eşdeğerdir (biri en baştan kaldırılır, diğeri ise sonuna kadar üst üste binen bölgeler arasında olacak şekilde); Önceden b:Ac, daha doğal bir şey vardı , ancak girdi c0'ını keser (sanırım boş bir listeyi herhangi bir şeye eklemeyi reddettiği için; birçok Brachylog yerleşkesi bir sebepten dolayı boş listeleri kırma eğilimindedir). boş bir liste görmek :Acbzorunda colmadığından emin olmanızı sağlar, bu da 0 girişinin de geçerli olabileceği anlamına gelir.

Java (OpenJDK 8) , 164 110 bayt

a->{int i=0;for(;!(i+"").matches("2{"+a+"}.*")|new String(new char[i]).matches(".?|(..+)\\1+");i++);return i;}

@FryAmTheEggman'a bir sürü bayt için teşekkürler!

Çevrimiçi deneyin!

Pyth, 12 bayt

f&!x`T*Q\2P_

Sözde kodda:

f                key_of_first_truthy_value( lambda T:
  !                  not (
   x`T*Q\2               repr(T).index(input()*'2')
                     )
 &                   and
          P_T        is_prime(T)
                 )

Koşulu yerine getirene kadar lambdabaşlangıcı döngüler T=11 ile artar. 2S dizesi dizgenin başından itibaren bir alt dize olmalıdır, yani indeks yönteminin geri dönmesi gerekir 0. -1Subring bulunmazsa, uygun olanın aynı zamanda kaba olduğu gibi döner , bu nedenle istisnai bir durum yoktur.

Burada çevrimiçi deneyebilirsiniz , ancak sunucu yalnızca bir girişe izin verir 4.

Perl, 50 bayt

49 bayt kodu + -pbayrak.

++$\=~/^2{$_}/&&(1x$\)!~/^1?$|^(11+)\1+$/||redo}{

Son satırsonu olmadan girişi sağlayın. Örneğin:

echo -n 4 | perl -pE '++$\=~/^2{$_}/&&(1x$\)!~/^1?$|^(11+)\1+$/||redo}{'

Bu, her sayıyı sınamak için 4'ten büyük sayıları çalıştırmak için biraz zaman alır (2 sınama vardır: birincisi /^2{$_}/, başlangıçta yeterli 2 olup olmadığını denetler ve ikincisi (1x$\)!~/^1?$|^(11+)\1+$/ilkellik için sınanır (çok kötü performanslarla).

Haskell, 73 bayt

f n=[x|x<-[2..],all((>0).mod x)[3..x-1],take n(show x)==([1..n]>>"2")]!!0

Kullanım örneği: f 3-> 2221.

Kaba kuvvet. Geçerli asalın dize gösterimindeki ilk karakterlerle karşılaştırılan bir s [1..n]>>"2"listesi oluşturur .n 2n

Mathematica, 103 bayt

ReplaceRepeated[0,i_/;!IntegerDigits@i~MatchQ~{2~Repeated~{#},___}||!PrimeQ@i:>i+1,MaxIterations->∞]&

Adsız işlev, negatif olmayan bir tamsayı argümanı alarak #ve bir tamsayı döndürür. Kelimenin tam anlamıyla hem pozitif hem de #asal olan bir tane bulana kadar tüm pozitif tamsayıları test eder . 5'in üzerindeki girişler için çok yavaş.

önceki sonuç: Mathematica, 155 bayt

Çok sert yazılmış olmasaydı, Mathematica golf oynamak için daha iyi olurdu; açıkça integer / list / string türleri arasında ileri geri geçiş yapmak zorundayız.

(d=FromDigits)[2&~Array~#~Join~{1}//.{j___,k_}/;!PrimeQ@d@{j,k}:>({j,k+1}//.{a__,b_,10,c___}->{a,b+1,0,c}/.{a:Repeated[2,#-1],3,b:0..}->{a,2,0,b})]/. 23->2&

Bu algoritma , garip bir şekilde, basamağı olan basamak listeleri üzerinde çalışır {2,...,2,1}. Bunlar asal sayının rakamı olmadığı sürece, son kurala bir tane ekler, kuralı kullanarak {j___,k_}/;!PrimeQ@d@{j,k}:>({j,k+1}... ve daha sonra herhangi bir süre için bir rakamı bir sonraki basamağa manuel olarak uygular. basamağı 10'a eşit, kuralı kullanarak {a__,b_,10,c___}->{a,b+1,0,c}... ve sonra, baştakilerin sonunun a'ya 2döndüğü kadar ileri gidersek 3, kuralı kullanarak sondaki başka bir rakamla baştan başlar {a,b+1,0,c}/.{a:Repeated[2,#-1],3,b:0..}->{a,2,0,b}. /. 23->2Sonunda sadece girişidir özel durum düzeltir 1çoğu asal bitemez: 2ama 2yapamam. (Birkaç hatalar girdilere tükürdü edilir 0ve 1ancak işlev doğru cevaba yolunu bulur.)

Bu algoritma oldukça hızlı: Örneğin, dizüstü bilgisayarımda 1000 2s ile başlayan ilk primin olduğunu hesaplamak 3 saniyeden az sürüyor 22...220521.

Pyth, 17 bayt

f&q\2{<`T|Q1}TPTh

n = 4İnternet üzerinden çözülemiyor gibi görünüyor , ancak teoride doğru.

açıklama

               Th    Starting from (input)+1, 
f                    find the first T so that
      <              the first
          Q          (input) characters
         | 1         or 1 character, if (input) == 0
       `T            of T's string representation
     {               with duplicates removed
  q\2                equal "2", 
 &                   and
            }T       T is found in
              PT     the list of T's prime factors.

Perl 6 , 53 bayt

{($/=2 x$^n-1)~first {+($/~$_) .is-prime&&/^2/},0..*}

Dene

Expanded:

{
  ( $/ = 2 x $^n-1 )       # add n-1 '2's to the front (cache in ｢$/｣)
  ~
  first {
    +( $/ ~ $_ ) .is-prime # find the first that when combined with ｢$/｣ is prime
    &&
    /^2/                   # that starts with a 2 (the rest are in ｢$/｣)
  },
  0..*
}

Jöle , 14 bayt

D=2×\S:³aÆPµ1#

Çok verimsiz. Çevrimiçi deneyin!

Pyke, 14 bayt

.fj`Q\2*.^j_P&

Burada dene!

.fj            - first number (asj)
   `    .^     -   str(i).startswith(V)
    Q\2*       -    input*"2"
             & -  ^ & V
          j_P  -   is_prime(j)

Hata düzeltmesinden sonra 12 bayt ve yeni bir özellik

~p#`Q\2*.^)h

Burada dene!

~p           - all the primes
  #       )h - get the first where...
   `    .^   - str(i).startswith(V)
    Q\2*     -  input*"2"

Adaçayı, 69 68 bayt

lambda n:(x for x in Primes()if '2'*len(`x`)=>'2'*n==`x`[:n]).next()

Sınırsız sayıda terimin ilkini (dolayısıyla en küçük) bulmak için bir jeneratör kullanır.

Japt, 20 bayt

L²o@'2pU +Xs s1)nÃæj

Çevrimiçi test edin! Makinemde 14 saniyeye kadar olan tüm girişler için iki saniye içinde bitiyor ve bundan sonra doğal olarak hassasiyeti kaybediyor (JavaScript sadece 2 ^53'e kadar tamsayı hassasiyetine sahip ).

@Obarakon'a bu :-) üzerinde çalıştığı için çok teşekkürler

açıklama

                       // Implicit: U = input integer, L = 100
L²o                    // Generate the range [0...100²).
   @             Ã     // Map each item X through the following function:
    '2pU               //   Take a string of U "2"s.
         +Xs s1)n      //   Append all but the first digit of X, and cast to a number.
                       // If U = 3, we now have the list [222, 222, ..., 2220, 2221, ..., 222999].
                  æ    // Take the first item that returns a truthy value when:
                   j   //   it is checked for primality.
                       // This returns the first prime in the forementioned list.
                       // Implicit: output result of last expression

Japt'un en son sürümünde bu, 12 bayt olabilir:

_n j}b!+'2pU   // Implicit: U = input integer
_   }b         // Return the first non-negative bijective base-10 integer that returns
               // a truthy value when run through this function, but first,
      !+       //   prepend to each integer
        '2pU   //   a string of U '2's.
               // Now back to the filter function:
 n j           //   Cast to a number and check for primality.
               // Implicit: output result of last expression

Çevrimiçi test edin! Makineme 14 saniye içinde girilen tüm girişler için yarım saniye içinde bitiyor.

PHP, 76 bayt

for($h=str_pad(2,$i=$argv[1],2);$i>1;)for($i=$p=$h.++$n;$p%--$i;);echo$p?:2;

komut satırı argümanından girdi alır. İle koş -r.

Yıkmak

for($h=str_pad(2,$i=$argv[1],2) # init $h to required head
    ;$i>1;                      # start loop if $p>2; continue while $p is not prime
)
    for($i=$p=$h.++$n               # 1. $p = next number starting with $h
                                    #    (first iteration: $p is even and >2 => no prime)
    ;$p%--$i;);                     # 2. loop until $i<$p and $p%$i==0 ($i=1 for primes)
echo$p?:2;                      # print result; `2` if $p is unset (= loop not started)

Bash (+ coreutils), 53 bayt

Kadar çalışır 2 ^ 63-1 (9223372036854775807) , N> 8 için bitirmek için hatırı sayılır bir zaman alır.

golfed

seq $[2**63-1]|factor|grep -Pom1 "^2{$1}.*(?=: \S*$)"

Ölçek

>seq 0 7|xargs -L1 ./twist

2
2
223
2221
22229
2222203
22222223
22222223

Python 3, 406 bayt

w=2,3,5,7,11,13,17,19,23,29,31,37,41
def p(n):
 for q in w:
  if n%q<1:return n==q
  if q*q>n:return 1
 m=n-1;s,d=-1,m
 while d%2==0:s,d=s+1,d//2
 for a in w:
  x=pow(a,d,n)
  if x in(1,m):continue
  for _ in range(s):
   x=x*x%n
   if x==1:return 0
   if x==m:break
  else:return 0
 return 1
def f(i):
 if i<2:return 2
 k=1
 while k:
  k*=10;l=int('2'*i)*k
  for n in range(l+1,l+k,2):
   if p(n):return n

test kodu

for i in range(31):
    print('{:2} = {}'.format(i, f(i)))

test çıkışı

 0 = 2
 1 = 2
 2 = 223
 3 = 2221
 4 = 22229
 5 = 2222203
 6 = 22222223
 7 = 22222223
 8 = 222222227
 9 = 22222222223
10 = 22222222223
11 = 2222222222243
12 = 22222222222201
13 = 22222222222229
14 = 222222222222227
15 = 222222222222222043
16 = 222222222222222221
17 = 222222222222222221
18 = 22222222222222222253
19 = 222222222222222222277
20 = 2222222222222222222239
21 = 22222222222222222222201
22 = 222222222222222222222283
23 = 2222222222222222222222237
24 = 22222222222222222222222219
25 = 222222222222222222222222239
26 = 2222222222222222222222222209
27 = 2222222222222222222222222227
28 = 222222222222222222222222222269
29 = 2222222222222222222222222222201
30 = 222222222222222222222222222222053

Bayt büyüklüğünden ziyade oldukça geniş bir aralıkta hıza gitmeye karar verdim. :) Bu tanık setiyle 3317044064679887385961981'e kadar garantili bir deterministik Miller-Rabin primallik testi kullanıyorum. Daha büyük primerler testi her zaman başarılı bir şekilde geçecektir, ancak olasılık aşırı derecede düşük olmasına rağmen bazı kompozitler de geçebilir . Ancak, i> 22 için çıkış numaralarını pyecm Elliptic Curve factorization programı kullanarak test ettim ve asal görünüyorlar.

Python 3, 132 bayt

def f(x):
 k=10;p=2*(k**x//9)
 while x>1:
  for n in range(p*k,p*k+k):
   if all(n%q for q in range(2,n)):return n
  k*=10
 return 2

Daha küçük bir bayt sayısı için herhangi bir performans umudu feda edilmiştir.

Java, 163 bayt

BigInteger f(int a){for(int x=1;x>0;x+=2){BigInteger b=new BigInteger(new String(new char[a]).replace("\0","2")+x);if(b.isProbablePrime(99))return b;}return null;}

test kodu

    public static void main(String[] args) {
    for(int i = 2; i < 65; i++)
        System.out.println(i + " " + new Test20170105().f(i));
    }

çıktı:

2 223
3 2221
4 22229
5 2222219
6 22222223
7 22222223
8 222222227
9 22222222223
10 22222222223
11 2222222222243
12 22222222222229
13 22222222222229
14 222222222222227
15 222222222222222143
16 222222222222222221
17 222222222222222221
18 22222222222222222253
19 222222222222222222277
20 2222222222222222222239
21 22222222222222222222261
22 222222222222222222222283
23 2222222222222222222222237
24 22222222222222222222222219
25 222222222222222222222222239
26 2222222222222222222222222213
27 2222222222222222222222222227
28 222222222222222222222222222269
29 22222222222222222222222222222133
30 222222222222222222222222222222113
31 222222222222222222222222222222257
32 2222222222222222222222222222222243
33 22222222222222222222222222222222261
34 222222222222222222222222222222222223
35 222222222222222222222222222222222223
36 22222222222222222222222222222222222273
37 222222222222222222222222222222222222241
38 2222222222222222222222222222222222222287
39 22222222222222222222222222222222222222271
40 2222222222222222222222222222222222222222357
41 22222222222222222222222222222222222222222339
42 222222222222222222222222222222222222222222109
43 222222222222222222222222222222222222222222281
44 2222222222222222222222222222222222222222222297
45 22222222222222222222222222222222222222222222273
46 222222222222222222222222222222222222222222222253
47 2222222222222222222222222222222222222222222222219
48 22222222222222222222222222222222222222222222222219
49 2222222222222222222222222222222222222222222222222113
50 2222222222222222222222222222222222222222222222222279
51 22222222222222222222222222222222222222222222222222289
52 2222222222222222222222222222222222222222222222222222449
53 22222222222222222222222222222222222222222222222222222169
54 222222222222222222222222222222222222222222222222222222251
55 222222222222222222222222222222222222222222222222222222251
56 2222222222222222222222222222222222222222222222222222222213
57 222222222222222222222222222222222222222222222222222222222449
58 2222222222222222222222222222222222222222222222222222222222137
59 22222222222222222222222222222222222222222222222222222222222373
60 222222222222222222222222222222222222222222222222222222222222563
61 2222222222222222222222222222222222222222222222222222222222222129
62 2222222222222222222222222222222222222222222222222222222222222227
63 2222222222222222222222222222222222222222222222222222222222222227
64 2222222222222222222222222222222222222222222222222222222222222222203

582.5858 milisaniye

Açıklama: tamsayılar üzerinde döngü yapar ve bunları verilen "2" dizesi olan kök dizgisine dizeler olarak ekler ve asal olup olmadığını doğrular.