Bu zorluk, PPCG kullanıcısı Dennis'in soyguncuların Programlama Dili Sınavının bir bölümünü kazanmasından dolayı bir hediyedir .

Baktığımızda Dennis'in PPCG profil sayfasında bazı oldukça etkileyici şeyler görebilirsiniz:

Halen altmış sekiz binin üzerinde itibara sahip olup, genel olarak ikinci sıfatıyla neredeyse otuz bin ile üçüncü sırayı aştı. Geçenlerde kazandı yeni moderatör için bizim seçim ve var onun adının yanında yepyeni elmas. Ancak şahsen Dennis hakkındaki en ilginç bölüm PPCG kullanıcı kimliği: 12012'dir.

İlk bakışta 12012neredeyse bir palindrom gibi görünüyor , ters çevrildiğinde aynı okuyan bir sayı, ancak biraz kapalı. Bu palindrom haline gelebilir 21012biz ilk konumları takas 1ve 2ve bu palindrom haline gelebilir 12021biz geçen takas eğer 1ve 2. Ayrıca, bir sayının başındaki sıfırların yazılmadığı sözleşmesini takiben, birinciyi 1ve 0sonuçları başka bir palindrom olan 02112veya yerine 2112koymak.

Dennis sayısını palindromik olmayan pozitif bir tamsayı olarak tanımlayalım , ancak iki basamaktan en az bir çiftinin pozisyonunu değiştirerek bir palindrom haline getirelim. Sipariş Dennis sayısının (mutlaka farklı olan) palindrom yapmak için takas olabilir basamak farklı çiftlerinin sayısıdır.

Bu nedenle sırası 12012olan basamak 3 3 itibaren belirgin çifttir ( 12012, , ) palindrom üretmek üzere birbiriyle değiştirilebilir. En küçük emir 3 Dennis sayıları olur.120121201212012

10en küçük Dennis sayısıdır ve 1. sıraya sahiptir, çünkü etrafında geçiş yapmak 1ve bir palindrom olan aka 0verir .011

Bir sayının hayali baştaki sıfırları, değiştirilebilir basamaklar olarak sayılmaz. Örneğin, değişen 8908etmek 08908ve palindrom almak için ilk iki basamak takas 80908geçersiz. 8908Dennis numarası değil.

Dennis olmayan numaraların 0 sırasına sahip olduğu söylenebilir.

Meydan okuma

Olumlu bir tamsayı alan ve N. En küçük Dennis sayısını sıra ile birlikte12012 3 veya gibi makul bir formatta basan veya veren bir program veya fonksiyon yazın (12012, 3).

Örneğin 12012, 774. Dennis numarasıdır, bu nedenle 774programınıza giriş yapıldıysa , çıktı bunun gibi olmalıdır 12012 3. (Merakla 774, başka bir Dennis sayısıdır.)

Bayt cinsinden en kısa kod kazanır.

İşte ilk 20 Dennis sayıları ve referansları:

N       Dennis  Order
1       10      1
2       20      1
3       30      1
4       40      1
5       50      1
6       60      1
7       70      1
8       80      1
9       90      1
10      100     1
11      110     2
12      112     1
13      113     1
14      114     1
15      115     1
16      116     1
17      117     1
18      118     1
19      119     1
20      122     1

İşte aynı liste N = 1000'e kadar.

Pyth, 44 bayt

L/lf_ITs.e.e`sXXNkZYbN=N`b2,Je.f&!_I`ZyZQ0yJ

Çevrimiçi deneyin: Gösteri veya Test Paketi

Pyth'taki aptal bir küçük böcek (?) 41 baytlık bir çözümü mahvetti.

Açıklama:

L/lf_ITs.e.e`sXXNkZYbN=N`b2
L                             define a function y(b), which returns:
                      =N`b       assign the string representation of b to N
        .e             N         map each (k=Index, b=Value) of N to:
          .e         N             map each (Y=Index, Z=Value) of N to:
              XXNkZbN                switch the kth and Yth value in N
            `s                       get rid of leading zeros
       s                         combine these lists
   f_IT                          filter for palindromes
  l                              length
 /                        2      and divide by 2

,Je.f&!_I`ZyZQ0yJ
   .f        Q0     find the first input() numbers Z >= 0, which satisfy
      !_I`Z            Z is not a palindrom
     &                 and 
           yZ          y(Z) != 0
  e                 get the last number
 J                  and store in J
,J             yJ   print the pair [J, y(J)]

CJam, 45 bayt

0{{)_s:C,2m*{~Ce\is_W%=},,2/:O!CCW%=|}g}ri*SO

Çevrimiçi deneyin!

Nasıl çalışır

0          e# Push 0 (candidate).
{          e# Loop:
  {        e#   Loop:
    )_     e#     Increment the candidate and push a copy.
    s:C    e#     Cast to string and save in C.
    ,      e#     Get the length of C, i.e., the number of digits.
    2m*    e#     Push all pairs [i j] where 0 ≤ i,j < length(C).
    {      e#     Filter:
      ~    e#       Unwrap, pushing i and j on the stack.
      Ce\  e#       Swap the elements of C at those indices.
      is   e#       Cast to int, then to string, removing leading zeroes.
      _W%= e#       Copy, reverse and compare.
    },     e#     Keep the pairs for which = returned 1, i.e., palindromes.
    ,2/    e#     Count them and divide the count by 2 ([i j] ~ [j i]).
    :O     e#     Save the result (the order) in O.
    !      e#     Negate logically, so 0 -> 1.
    CCW%=  e#     Compare C with C reversed.
    |      e#     Compute the bitwise NOT of both Booleans.
           e#     This gives 0 iff O is 0 or C is a palindrome.
  }g       e#   Repeat the loop while the result is non-zero.
}ri*       e# Repeat the loop n times, where n is an integer read from STDIN.
           e# This leaves the last candidate (the n-th Dennis number) on the stack.
SO         e# Push a space and the order.

Haskell, 174 bayt

import Data.List
p x=x==reverse x
x!y=sum[1|(a,b)<-zip x y,a/=b]==2
o n|x<-show n=sum[1|v<-nub$permutations x,x!v,p$snd$span(<'1')v,not$p x]
f=([(x,o x)|x<-[-10..],o x>0]!!)

p Bir listenin bir palindrome olup olmadığını kontrol eder.

x!yolduğu Truelisteleri IFF xve y(aynı uzunluğa sahip olmalıdır) tam olarak iki yerde farklıdır. Spesifik olarak, eğer xbir permütasyon ise y, x!ybunun bir "takas" olup olmadığını belirler.

o nDennis'in sırasını bulur n. Bu, permütasyonları arasında takasları filtreler x = show nve bu takasların kaçının palindrom olduğunu sayar. Bu sayımı yapan liste kavrayışının ekstra bir koruması var not (p x), yani başlangıçta bir palindrom 0olsaydı geri dönecek n.

snd (span (<'1') v)Biraz adildir dropWhileama bir byte daha kısa; o döner "01221"içine "1221".

flistesinden endeksleri (i, o i)nerede o i > 0(yani inormalde var gibi burada bir kapalı-birer hata olurdu Dennis sayıdır.) (!!)0'dan sayımları ancak sorun 1'den sayar ben aramayı başlayarak bu sorunu başardı -10(ki programım tarafından Dennis sayısı olarak kabul edildi!) böylece tüm sayıları doğru noktalara itti.

f 774olduğunu (12012,3).

Python 2, 176

i=input()
n=9
c=lambda p:`p`[::-1]==`p`
while i:n+=1;x=`n`;R=range(len(x));r=[c(int(x[:s]+x[t]+x[s+1:t]+x[s]+x[t+1:]))for s in R for t in R[s+1:]];i-=any(r)^c(n)
print n,sum(r)

Takas kodumun özellikle uygun olduğunu hayal edemiyorum, ancak elde edebileceğimin en iyisi bu. Ayrıca, string ile integer arasında ne sıklıkla dönüşüm yaptığımı da sevmiyorum.

Her sayı için, iki basamaklı takasların hepsinin palindrom olup olmadığına dair bir liste oluşturur. Bu değerlerden en az biri doğru olduğunda sayacı azaltır ve orijinal sayı bir palindrom olmadığında. Yana 0+TruePython olarak değerlendirilirse 1son listenin toplamı Dennis numarasının sipariş için çalışır.

Pas, 390 bayt

fn d(mut i:u64)->(u64,i32){for n in 1..{let mut o=0;if n.to_string()==n.to_string().chars().rev().collect::<String>(){continue}let mut s=n.to_string().into_bytes();for a in 0..s.len(){for b in a+1..s.len(){s.swap(a,b);{let t=s.iter().skip_while(|&x|*x==48).collect::<Vec<&u8>>();if t.iter().cloned().rev().collect::<Vec<&u8>>()==t{o+=1}}s.swap(a,b);}}if o>0{i-=1;if i<1{return(n,o)}}}(0,0)}

Yeni Java? : /

Ungolfed ve yorumladı:

fn main() {
    let (num, order) = dennis_ungolfed(774);
    println!("{} {}", num, order);  //=> 12012 3
}

fn dennis_ungolfed(mut i: u64) -> (u64, i32) {
    for n in 1.. {
        let mut o = 0;  // the order of the Dennis number
        if n.to_string() == n.to_string().chars().rev().collect::<String>() {
            // already a palindrome
            continue
        }
        let mut s = n.to_string().into_bytes();  // so we can use swap()
        for a in 0..s.len() {  // iterate over every combination of (i, j)
            for b in a+1..s.len() {
                s.swap(a, b);
                // need to start a new block because we're borrowing s
                {
                    let t = s.iter().skip_while(|&x| *x == 48).collect::<Vec<&u8>>();
                    if t.iter().cloned().rev().collect::<Vec<&u8>>() == t { o += 1 }
                }
                s.swap(a, b);
            }
        }
        // is this a Dennis number (order at least 1)?
        if o > 0 {
            // if this is the i'th Dennis number, return
            i -= 1;
            if i == 0 { return (n, o) }
        }
    }
    (0, 0)  // grr this is necessary
}

Jöle , 33 bayt (yarışmaz)

ṚḌ=
=ċ0^2°;ḌÇ
DŒ!Qç@ÐfDL©Ṡ>ѵ#Ṫ,®

Çevrimiçi deneyin!

Nasıl çalışır

DŒ!Qç@ÐfDL©Ṡ>ѵ#Ṫ,®  Main link. No arguments.

              µ      Combine the chain to the left into a link.
               #     Find; execute the chain with arguments k = 0, 1, 2, ...
                     until n values of k result in a truthy value, where n is an
                     integer read implicitly from STDIN. Return those n values.

D                      Decimal; convert k to the list of its digits in base 10.
 Œ!                    Generate all permutations of the digits.
   Q                   Unique; deduplicate the list of permutations.
      Ðf               Filter:
    ç@  D                Call the helper link on the second line with the
                         unpermuted digits (D) as left argument, and each
                         permutation as the right one.
                       Keep permutations for which ç returns a truthy value.
         L©            Compute the length (amount of kept permutations) and save
                       it in the register.
           Ṡ           Sign; yield 1 if the length is positive, and 0 otherwise.
            >Ṅ         Compare the sign with the result from the helper link on
                       the first line. This will return 1 if and only if the
                       length is positive and Ñ returns 0.
                Ṫ      Tail; extract the last value of k.
                 ,®    Pair it with the value in the register.


=ċ0^2°;ḌÇ              Helper link. Arguments: A, B (lists of digits)

=                      Compare the corresponding integers in A and B.
 ċ0                    Count the zeroes, i.e., the non-matching integers.
   ^2                  Bitwise XOR the amount with 2.
     °                 Convert to radians. This will yield 0 if exactly two
                       corresponding items of A and B are different ,and a
                       non-integral number otherwise.
      ;                Prepend the result to B.
       Ḍ               Convert the result from decimal to integer. Note that
                       leading zeroes in the argument won't alter the outcome.
        Ç              Call the helper link on the first line.


ṚḌ=                    Helper link. Argument: m (integer)

Ṛ                      Convert m to decimal and reverse the digits.
 Ḍ                     Convert back to integer.
  =                    Compare the result with m.

APL, 87

2↓⎕{⍺(2⊃⍵+K⌊~A∧.=⌽A)X,K←+/{⍵∧.=⌽⍵}¨1↓∪,{⍕⍎Y⊣Y[⌽⍵]←⍵⊃¨⊂Y←A}¨∘.,⍨⍳⍴A←⍕X←1+3⊃⍵}⍣{=/2↑⍺}3⍴0

Döngünün gövdesi 4 sayılık bir vektör döndürür: 1) ⍺girdiden okunan sol argümanı , 2) şimdiye kadar Dennis sayılarının sayısı, 3) akım değeri X- döngü sayacı ve 4) sıralarının Kpalindromların toplamı olarak hesaplanması 1 swap permütasyonları içinde. İlk iki eleman eşitlendiğinde ve son iki sonuçta iade edildiğinde sona erer.

JavaScript (ES6), 229

Her zamanki gibi, JavaScript kombinatoriklere karşı beceriksizliği için parlar (veya belki de benim beceriksizliğim ...). Burada, verilen uzunluktaki tüm ikili sayıları ve sadece 2 tanesini ayarlayan tüm olası takas pozisyonlarını alıyorum.

Aşağıdaki kod parçasını Firefox'ta çalıştırma testi (MSIE EcmaScript 6 ile uyumlu olmadığından ve Chrome hala varsayılan parametreleri eksikse)

F=c=>(P=>{for(a=9;c;o&&--c)if(P(n=++a+'',o=0))for(i=1<<n.length;k=--i;[x,y,z]=q,u=n[x],v=n[y],!z&&u-v&&(m=[...n],m[x]=v,m[y]=u,P(+(m.join``))||++o))for(j=0,q=[];k&1?q.push(j):k;k>>=1)++j;})(x=>x-[...x+''].reverse().join``)||[a,o]

// TEST

function go(){ O.innerHTML=F(I.value)}


// Less Golfed
U=c=>{
  P=x=>x-[...x+''].reverse().join``; // return 0 if palindrome 
  
  for(a = 9; // start at 9 to get the first that is known == 10
      c; // loop while counter > 0
      o && --c // decrement only if a Dennis number found
      )
  {  
    o = 0; // reset order count
    ++a;
    if (P(a)) // if not palindrome
    {  
      n = a+''; // convert a to string
      for(i = 1 << n.length; --i; ) 
      {
        j = 0;
        q = [];
        for(k = i; k; k >>= 1)
        {
          if (k & 1) q.push(j); // if bit set, add bit position to q
          ++j;
        } 
        [x,y,z] = q; // position of first,second and third '1' (x,y must be present, z must be undefined)
        u = n[x], v = n[y]; // digits to swap (not valid if they are equal)
        if (!z && u - v) // fails if z>0 and if u==v or u or v are undefined
        {
          m=[...n]; // convert to array
          m[x] = v, m[y] = u; // swap digits
          m = +(m.join``); // from array to number (evenutally losing leading zeroes)
          if (!P(m)) // If palindrome ...
            ++o; // increase order count 
        }  
      }
    }
  }  
  return [a,o];
}

//////
go()

<input id=I value=774><button onclick="go()">-></button> <span id=O></span>

awk, 199

{for(;++i&&d<$0;d+=o>0)for(o=j=_;j++<l=length(i);)for(k=j;k++<l;o+=v!=i&&+r~s){split(t=i,c,v=s=r=_);c[j]+=c[k]-(c[k]=c[j]);for(e in c){r=r c[e];s=s||c[e]?c[e]s:s;v=t?v t%10:v;t=int(t/10)}}print--i,o}

yapı

{
    for(;++i&&d<$0;d+=o>0)
        for(o=j=_;j++<l=length(i);)
            for(k=j;k++<l;o+=v!=i&&+r~s)
            {
                split(t=i,c,v=s=r=_);
                c[j]+=c[k]-(c[k]=c[j]);
                for(e in c)
                {
                    r=r c[e];
                    s=s||c[e]?c[e]s:s;
                    v=t?v t%10:v;
                    t=int(t/10)
                }
            }
    print--i,o
}

kullanım

Bunu konsolunuza yapıştırın ve sonra echoistediğiniz numarayı değiştirin.

echo 20 | awk '{for(;++i&&d<$0;d+=o>0)for(o=j=_;j++<l=length(i);)for(k=j;k++<l;o+=v!=i&&+r~s){split(t=i,c,v=s=r=_);c[j]+=c[k]-(c[k]=c[j]);for(e in c){r=r c[e];s=s||c[e]?c[e]s:s;v=t?v t%10:v;t=int(t/10)}}print--i,o}'

Daha yüksek sayılarda yavaşlar;)

Ungolfed yeniden kullanılabilir versiyonu

{
    dennisFound=0

    for(i=0; dennisFound<$0; )
    {
        i++
        order=0

        for(j=0; j++<length(i); )
        {
            for(k=j; k++<length(i); )
            {
                split(i, digit, "")
                digit[j]+=digit[k]-(digit[k]=digit[j]) # swap digits

                tmp=i
                iRev=iFlip=iFlipRev=""

                for(e in digit)
                {
                    if(tmp>0)                        # assemble reversed i
                        iRev=iRev tmp%10
                    tmp = int( tmp/10 )

                    iFlip=iFlip digit[e]             # assemble flipped i

                    if(iFlipRev>0 || digit[e]>0)     # assemble reversed flipped i
                        iFlipRev=digit[e] iFlipRev   # without leading zeros
                }
                if(iRev!=i && 0+iFlip==iFlipRev) order++  # i is not a palindrome,
            }                                             # but flipped i is
        }
        if(order>0) dennisFound++
    }
    print i, order
}

Ruby, 156

->i{s=?9
(o=0;(a=0...s.size).map{|x|a.map{|y|j=s+'';j[x],j[y]=j[y],j[x];x>y&&j[/[^0].*/]==$&.reverse&&o+=1}}
o<1||s==s.reverse||i-=1)while i>0&&s.next!;[s,o]}

Türleri ileri geri dönüştürmek zorunda kalmamak için çağrının "19".next!geri döndüğü Ruby özelliğini kullanır "20"; liderliği görmezden gelmek için yalnızca bir regex kullanıyoruz 0s. Palindromik anahtarları kontrol etmek için tüm tel dizileri çiftlerini tekrar eder. Ben başlangıçta bu özyinelemeli bir işlev yazdım ama yığını istila etti.

774 için çıktı ["12012", 3](tırnak işaretlerinin kaldırılması 4 bayta daha mal olur, ancak teknik özellik onlara izin verir).