डेनिस नंबर जनरेट करें

Question

यह चुनौती पीपीसीजी उपयोगकर्ता डेनिस को लुटेरों के प्रोग्रामिंग भाषा क्विज़ के हिस्से को जीतने के लिए एक श्रद्धांजलि है ।

को देखते हुए डेनिस के PPCG प्रोफाइल पेज हम कुछ बहुत प्रभावशाली सामान देख सकते हैं:

वर्तमान में उनकी साठ-अस्सी हजार से अधिक प्रतिष्ठा है, जिससे वह कुल मिलाकर दूसरे स्थान पर हैं, लगभग तीस हजार से तीसरे स्थान पर। उन्होंने हाल ही में एक नए मॉडरेटर के लिए हमारा चुनाव जीता और उनके नाम के आगे एक चमकदार नया हीरा मिला । लेकिन मुझे व्यक्तिगत रूप से लगता है कि डेनिस के बारे में सबसे दिलचस्प हिस्सा उसका पीपीसीजी उपयोगकर्ता आईडी नंबर: 12012 है।

पहली नज़र में 12012लगभग एक पैलिंड्रोम की तरह दिखता है , एक संख्या जो उलट जाने पर समान पढ़ती है, लेकिन यह थोड़ा बंद है। यह विलोमपद बन सकता है 21012अगर हम पहले की स्थिति स्वैप 1और 2, और यह विलोमपद बन सकता है 12021अगर हम पिछले स्वैप 1और 2। इसके अलावा, इस कन्वेंशन के बाद कि किसी संख्या में अग्रणी शून्य नहीं लिखे जाते हैं, पहले 1और 0परिणाम को स्वैप करते हैं 02112या इसके बजाय 2112जो एक और palindrome है।

आइए एक डेनिस संख्या को एक सकारात्मक पूर्णांक के रूप में परिभाषित करें जो कि स्वयं पेलिंड्रोमिक नहीं है, लेकिन किसी भी दो अंकों के कम से कम एक जोड़े के पदों की अदला-बदली करके इसे एक पैलिंड्रोम में बनाया जा सकता है। आदेश एक डेनिस संख्या के अंकों के विशिष्ट जोड़े है कि एक (जरूरी अलग नहीं) विलोमपद बनाने के लिए बदली जा सकती है, की संख्या है।

तो के आदेश 12012अपने अंकों की 3 3 के बाद से अलग जोड़े है ( 12012, , ) के आसपास खोल देना निर्माण करने के लिए बदली जा सकती है। सबसे छोटा क्रम 3 डेनिस नंबर होता है।120121201212012

10सबसे छोटा डेनिस नंबर है और 1 का ऑर्डर देता है क्योंकि चारों ओर स्विच करता है 1और उर्फ 0देता है जो एक पैलिंड्रोम है।011

किसी संख्या के काल्पनिक प्रमुख शून्य को स्विचेबल अंकों के रूप में नहीं गिना जाता है। उदाहरण के लिए, पहले दो अंकों को बदलने और बदलने के 8908लिए 08908तालमेल 80908अमान्य है। 8908डेनिस नंबर नहीं है।

गैर-डेनिस संख्याओं को आदेश 0 कहा जा सकता है।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सकारात्मक पूर्णांक एन में लेता है और कुछ उचित प्रारूप जैसे या में अपने आदेश के साथ एनटीटी सबसे छोटा डेनिस नंबर देता है ।12012 3(12012, 3)

उदाहरण के लिए, 12012774 वाँ डेनिस नंबर है इसलिए यदि 774आपके प्रोग्राम में इनपुट है, तो आउटपुट कुछ होना चाहिए 12012 3। (उत्सुकता से, 774 एक और डेनिस नंबर है।)

बाइट्स में सबसे छोटा कोड जीतता है।

यहां पहले 20 डेनिस नंबर और संदर्भ के लिए उनके आदेश दिए गए हैं:

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

यहाँ N = 1000 तक एक ही सूची है।

Comments

इसे OEIS

— क्लाउडी

@ कोलियु को यह OEIS में जोड़ा गया है।

— 15:

Answer 1

पायथ, 44 बाइट्स

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

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

पाइथ में एक बेवकूफ छोटी बग (?) ने 41 बाइट समाधान को बर्बाद कर दिया।

स्पष्टीकरण:

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)]

Comments

और यह क्या है 'बेवकूफ छोटी बग (?)'

— कैलक्यूलेटरफलाइन

@CatsAreFluffy को गितुब इतिहास देखना था। यह चिंता है .f। इस प्रश्न के कारण मैंने जो अनुरोध किया है, वह यहां है: github.com/isaacg1/pyth/pull/151

— Jakube

Answer 2

सीजेएम, 45 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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.

Comments

मैंने पहले ही रेप कैप को हिट कर दिया है, लेकिन मुझे पहला उत्तर पोस्ट करना था ।

— डेनिस

ओह। मैं अपने आप को 42 upvotes के साथ टिप्पणी करने के लिए कैसे मजबूर करूं?

— NieDzejkob

मुझे 42 वां

— उत्थान

Answer 3

हास्केल, 174 बाइट्स

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 जाँचता है कि कोई सूची एक palindrome है या नहीं।

x!yहै Trueसूचियों iff xऔर y(जो एक ही लंबाई होना चाहिए) वास्तव में दो स्थानों पर भिन्न होते हैं। विशेष रूप से, यदि xका क्रमपरिवर्तन है y, x!yनिर्धारित करता है कि यह एक "स्वैप" है।

o nका डेनिस-ऑर्डर पाता है n। यह के क्रमपरिवर्तन के बीच स्वैप के लिए फ़िल्टर करता है x = show n, और फिर गिनता है कि उन स्वैप में से कितने palindromes हैं। इस गणना को करने वाले सूची बोध में एक अतिरिक्त गार्ड होता है not (p x), जिसका अर्थ है कि 0अगर nयह एक शुरुआत के साथ शुरू हुआ तो वापस आ जाएगा ।

snd (span (<'1') v)बिट बस है dropWhileलेकिन एक बाइट कम; यह बदल जाता "01221"है "1221"।

f(i, o i)जहां o i > 0(यानी iडेनिस नंबर है।) की एक सूची से अनुक्रमणिका सामान्य रूप से एक ऑफ-बाय-वन त्रुटि होगी, जैसा (!!)कि 0 से गिना जाता है, लेकिन समस्या 1 से गिना जाता है। मैं खोज शुरू करने से इसका उपाय करने में कामयाब रहा -10(जो मेरे कार्यक्रम द्वारा एक डेनिस नंबर माना जाता है!) जिससे सभी नंबर सही स्थानों में धकेल दिए गए।

f 774है (12012,3)।

Answer 4

अजगर 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)

मैं कल्पना नहीं कर सकता कि मेरा स्वैपिंग कोड विशेष रूप से इष्टतम है, लेकिन यह सबसे अच्छा है जिसे मैं प्राप्त करने में सक्षम हूं। मुझे यह भी पसंद नहीं है कि मैं कितनी बार स्ट्रिंग और पूर्णांक के बीच परिवर्तित होता हूं ...

प्रत्येक संख्या के लिए, यह एक सूची बनाता है कि क्या दो अंकों के स्वैप में से सभी palindromes हैं। यह काउंटर को तब घटाता है जब इनमें से कम से कम एक मान सत्य होता है, और मूल संख्या कोई तालमेल नहीं है। चूंकि 0+Trueअजगर 1डेनिस संख्या के क्रम के लिए अंतिम सूची कार्यों के योग का मूल्यांकन करता है।

Answer 5

जंग, 390 बाइट्स

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)}

नया जावा? : /

असंबद्ध और टिप्पणी:

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
}

Answer 6

जेली , 33 बाइट्स (गैर-प्रतिस्पर्धात्मक)

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

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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.

Answer 7

एपीएल, 87

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

लूप का शरीर 4 संख्याओं का एक वेक्टर देता है: 1) ⍺इनपुट से पढ़े गए उसके बाएं तर्क , 2) डेनिस संख्याओं की अब तक की गणना, 3) वर्तमान मूल्य X- लूप काउंटर, और 4) इसके क्रम की Kगणना पैलिंड्रोम्स के योग के रूप में की जाती है। 1-स्वैप क्रमपरिवर्तन के भीतर। यह समाप्त हो जाता है जब पहले दो तत्व बराबर हो जाते हैं और अंतिम दो तब परिणाम के रूप में वापस आ जाते हैं।

Answer 8

जावास्क्रिप्ट (ईएस 6), 229

हमेशा की तरह, जावास्क्रिप्ट ने कॉम्बिनेटरिक्स के लिए अपनी अयोग्यता के लिए चमकता है (या, शायद यह मेरी अयोग्यता है ...)। यहाँ मुझे दिए गए लम्बाई के सभी बाइनरी नंबरों को खोजने के लिए सभी कब्ज़े वाली अदला-बदली की स्थिति मिलती है और बस 2 सेट होते हैं।

फ़ायरफ़ॉक्स में नीचे स्निपेट का परीक्षण करना (जैसा कि MSIE EcmaScript 6 के अनुरूप है और क्रोम अभी भी डिफ़ॉल्ट पैरामीटर गायब है)

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>

Answer 9

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}

संरचना

{
    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
}

प्रयोग

अपने कंसोल पर चिपकाएँ और बाद में नंबर बदलें echo, यदि आप चाहें

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}'

यह उच्च संख्या में धीमा हो जाता है;)

Ungolfed पुन: प्रयोज्य संस्करण

{
    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
}

Answer 10

रूबी, 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]}

रूबी फ़ीचर का उपयोग करता है, जहाँ "19".next!रिटर्न "20"टाइप करने से बचने के लिए कॉलिंग को आगे-पीछे करना; हम सिर्फ लीड को अनदेखा करने के लिए एक रेगेक्स का उपयोग करते हैं 0s। पैलंड्रोमिक स्विच की जांच करने के लिए स्ट्रिंग पोजिशन के सभी जोड़े पर Iterates। मैंने मूल रूप से इसे एक पुनरावर्ती फ़ंक्शन लिखा था लेकिन यह स्टैक का पर्दाफाश करता है।

774 के लिए आउटपुट है ["12012", 3](उद्धरण चिह्नों को हटाने से 4 और बाइट्स खर्च होंगे लेकिन मुझे लगता है कि कल्पना उन्हें अनुमति देती है)।