पर्मुपटालिंड्रोमिक संख्या

Question

Nइनपुट के रूप में एक पूर्णांक को देखते हुए , Nवें permutapalindromic संख्या को आउटपुट करता है ।

एक पर्मुपटालिंड्रोमिक संख्या एक पूर्णतया धनात्मक पूर्णांक होती है जैसे कि इसके अंको का कम से कम एक क्रमपरिवर्तन होता है जिसके परिणामस्वरूप एक पैलिंड्रोम (यानी एक संख्या जो कि स्वयं रिवर्स होती है) होती है।

उदाहरण के लिए, 117एक permutapalindromic संख्या है, क्योंकि इसके अंकों को अनुमति दी जा सकती है 171, जो कि एक ताल है।

हम मानते हैं कि जैसे संख्याएं 10क्रमपरिवर्तन नहीं हैं, भले ही 01 = 1एक पल्मिड्रोम हो । हम लगाते हैं कि 0पैलिंड्रोमिक क्रमचय में एक अग्रणी शून्य नहीं होना चाहिए (जैसे कि, स्वयं पर्मुपटालिंड्रोमोमन नहीं है)।

नंबर जो पहले से ही palindromes हैं, वे भी permutapalindromic हैं, क्योंकि कुछ भी मान्य नहीं है।

इनपुट और आउटपुट

• Nया तो 0-अनुक्रमित या 1-अनुक्रमित हो सकता है। कृपया बताएं कि आपके उत्तर में से कौन सा दो का उपयोग करता है।
• इनपुट को STDINफ़ंक्शन तर्क के रूप में, या अपनी पसंद की भाषा में समान कुछ भी लिया जा सकता है । आउटपुट को लिखा जा सकता है STDOUT, किसी फ़ंक्शन से लौटाया जा सकता है , या अपनी पसंद की भाषा में समान।
• इनपुट और आउटपुट दशमलव बेस में होना चाहिए।

परीक्षण के मामलों

निम्नलिखित परीक्षण मामले 1-अनुक्रमित हैं। आपका कार्यक्रम यहां प्रस्तुत किए गए किसी भी परीक्षण मामले को अधिकतम 1 मिनट में पारित करने में सक्षम होना चाहिए।

N      Output

1      1
2      2
3      3
4      4
5      5
6      6
7      7
8      8
9      9
10     11
42     181
100    404
128    511
256    994
270    1166

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम उत्तर जीतता है।

Comments

अंतिम टेस्टकेस को एक मिनट में पास नहीं करना काफी असंभव है ...

— लीक

OEIS A084050 (जैसे अतिरिक्त मामले होते हैं 10)

— लीक

सबसे बड़ा इनपुट क्या है?

— अड्म

@ अपने कार्यक्रम को सैद्धांतिक रूप से किसी भी संख्या के लिए काम करना चाहिए, चाहे कितना भी बड़ा हो।

— 9

@ Adám यह एक बहुत ही मनमानी सीमा है जो प्रयुक्त भाषा पर निर्भर है। मान लीजिए कि यह सैद्धांतिक रूप से सबसे बड़े पूर्णांक के लिए काम करना चाहिए, आपकी भाषा डिफ़ॉल्ट रूप से प्रतिनिधित्व कर सकती है (इसलिए सभी पूर्णांक यदि आपकी भाषा में डिफ़ॉल्ट हैं)।

— 9

Answer 1

05AB1E , 15 14 13 बाइट्स

Emigna के लिए एक बाइट धन्यवाद ! कोड:

µNœvyJÂïÊP}_½

स्पष्टीकरण:

µ               # c = 0, when c is equal to the input, print N.
 N              # Push N, the iteration variable.
  œ             # Push all permutations of N.
   vyJ    }     # For each permutation...
      Â         #   Bifurcate, which is short for duplicate and reverse.
       ï        #   Convert the seconds one to int, removing leading zeros.
        Q       #   Check if they are not equal.
         P      #   Product of the stack.
           _    # Logical not.
            ½   # Pop a value, if 1 then increase c by 1.

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

Comments

µNœvyJÂïQ}O__½14. के लिए

— एमिगा

@Emigna धन्यवाद! मैंने ऐसा नहीं सोचा था।

— अदनान

Answer 2

ब्रेकीलॉग, 19 बाइट्स

~l<:1at.
.=pPrPl~l?

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

के बारे में 17 सेकंड लेता है N = 270।

व्याख्या

• मुख्य विधेय:

  ~l            Create a list whose length is Input.
    <           The list is strictly increasing.
     :1a        Apply predicate 1 to each element of the list.
        t.      Output is the last element of the list.
  

• 1 समर्पित करें:

  .=            Input = Output = an integer
    pPrP        A permutation P of the Output is its own reverse
        l~l?    The length of P is equal to the length of the Input
  

Answer 3

ब्रेजलॉग , २१ 20 बाइट्स

1 बाइट थैंक्स टू फेटलाइज़।

क्या आपने ब्राचीलॉग के लिए चुनौती डिजाइन की?

:1yt.
0<.={@epcPrP!}

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

270 यहाँ लगभग आधा मिनट लगते हैं।

Z = 1166
real    0m27.066s
user    0m26.983s
sys     0m0.030s

Exit code:     0

विधेय 0 (मुख्य विधेय)

:1yt.
:1y    find the first Input solutions to predicate 1
   t.  unify the output with the last element

1 समर्पित करें (सहायक विधेय)

0<.={@epcPrP!}
0<.              0 < Output
  .=             Assign a value to Output (choice point)
    {        }   Inline predicate:
     @e              Digits of the Output
       p             A permutation (choice point)
        c            Concatenate (fails if leading zero present)
         P           store as P
          rP         assert that P reversed is still P
            !        remove the choice point in this predicate, so
                     that it will not return twice for the same number.

Answer 4

अजगर, १४

e.ff&_ITshT.p`

इसे यहां आज़माएं या टेस्ट सूट चलाएं

विस्तार:

e.ff&_ITshT.p`ZQ   # Auto-fill variables
 .f            Q   # Find the first input number of numbers that give truthy on ...
           .p`Z    # Take all the permutations of the current number
   f&              # Keep those that give a truthy value for both:
     _IT           # Invariance on reversing (is a palindrome)
        shT        # The integer value of the first digit (doesn't start with zero)
                   # A list with any values in it it truthy, so if any permutation matches
                   # these conditions, the number was a permutapalindrome
e                  # Take only the last number

Answer 5

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

f=(n,i=1)=>(n-=/^.0+$/.test(i)</^((.),\2,)*(.)(,\3)?(,(.),\6)*$/.test([...i+''].sort()))?f(n,i+1):i

स्पष्टीकरण:

f=(n,i=1)=>             look for n numbers starting at 1
 (n-=                   test whether current guess is
  /^.0+$/.test(i)<      not a round number and
  /^((.),\2,)*          pairs of comma-separated digits
   (.)(,\3)?            possible single digit
   (,(.),\6)*$/         pairs of comma-separated digits
   .test(               matches the comma-joined
    [...i+''].sort()))  digits in ascending order
 ?f(n,i+1)              if not n numbers found try next number
 :i                     found it!

Comments

1100 एक गोल पर्मुपटालिंड्रोमिक संख्या है।

— आदम

@ Adám यह गोल नहीं है, इसमें कम से कम दो गैर-अक्ष अंक हैं।

— नील

@ नील: +2 बाइट्स - आप वास्तव में f=जब आप इसे बाद में संदर्भित करने के लिए गिनना चाहते हैं

— चार्ली

@charlie क्षमा करें, मैं हमेशा ऐसा करना भूल जाता हूं।

— नील

Answer 6

आर, 145 बाइट्स

g=function(n){d=b=0 
while(d<n){b=b+1
if(sum(a<-table(strsplit(n<-as.character(b),""))%%2)==nchar(n)%%2&(!names(a)[1]==0|a[1]|sum(!a)>1))d=d+1}
b}

ungolfed

f=function(b){
    a<-table(strsplit(n<-as.character(b),""))%%2
    sum(a)==nchar(n)%%2&(!names(a)[1]==0|a[1]|sum(!a)>1)
}
g=function(n){
    d=b=0
    while(d<n){
         b=b+a
         if(f(b)) d=d+1
    }
    b
}

अनिवार्य रूप से - एक फ़ंक्शन जो क्रमपरिवर्तन की अनुमति देता है permutapalindromic सेट में, और जब तक कि यह nth सदस्य नहीं मिल जाता है।

Answer 7

पायथन 2.7, 163 154 बाइट्स:

from itertools import*;I,F,Q=input(),[],2
while len(F)<I:F=[g for g in range(1,Q)if any(i==i[::-1]*(i[0]>'0')for i in permutations(`g`))];Q+=1
print F[-1]

काफी सरल। मूल रूप से whileक्रमपरिवर्तन को बार-बार बनाने के लिए एक लूप का उपयोग करता है [1,Q)जब तक कि क्रम संख्या Qबड़ी नहीं होती है, जैसे कि सरणी में Inputआइटम की संख्या होती है। यह तब उस सरणी में अंतिम तत्व आउटपुट करता है।

यह ऑनलाइन की कोशिश करो! (Ideone)

Answer 8

पर्ल 6 , 66 बाइट्स

{(1..*).grep(*.comb.permutations.grep({+.join.flip eq.join}))[$_]}

0 आधारित

स्पष्टीकरण:

# bare block lambda which takes an implicit parameter ｢$_｣
{
  # all numbers greater than 0
  (1..*)\

  # remove any which aren't permutapalindromic
  .grep(

    # ｢*｣ here starts a Whatever lambda
    *\
    # split into list of digits
    .comb\
    # get all of the permutations of the digits
    .permutations\
    # find out if there are any palindromes
    .grep(

      # another bare block lambda taking ｢$_｣ as implicit parameter
      {
        # compare the current permutation with its reverse stringwise
        # numify only one side to get rid of leading ｢0｣
        +$_.join.flip eq $_.join
      }
    )

  # get the value at the index
  )[$_]
}

परीक्षा:

#! /usr/bin/env perl6
use v6.c;
use Test;

my &permutapalindromic = {(1..*).grep(*.comb.permutations.grep({+.join.flip eq.join}))[$_]}

my @tests = (
  1   => 1,
  2   => 2,
  3   => 3,
  4   => 4,
  5   => 5,
  6   => 6,
  7   => 7,
  8   => 8,
  9   => 9,
  10  => 11,
  42  => 181,
  100 => 404,
  128 => 511,
  256 => 994,
  270 => 1166,
);

plan +@tests + 1;

my $start-time = now;
for @tests -> $_ ( :key($input), :value($expected) ) {
  # zero based instead of one based, so subtract 1
  is-deeply permutapalindromic( $input - 1 ), $expected, .gist;
}
my $finish-time = now;

my $total-time = $finish-time - $start-time;

cmp-ok $total-time, &[<], 60, 'Less than 60 seconds for the tests';
diag "$total-time seconds";

Answer 9

द्यलोग एपीएल , 51 बाइट्स

एक-अनुक्रमित।

{⍵⊃{⍵/⍨{(⍵≤9)∨(1<≢c~'0')∧1≥+/2|+⌿c∘.=∪c←⍕⍵}¨⍵}⍳5×⍵}

{ एक फ़ंक्शन जहां ⍵ तर्क का प्रतिनिधित्व करता है

⍵⊃{ फ़ंक्शन के परिणाम से लेने के लिए तर्क का उपयोग करें

⍵/⍨{ फ़ंक्शन के परिणाम के साथ तर्क को फ़िल्टर करें

(⍵≤9)∨ तर्क कम या 9 के बराबर है, या

(1<≢c~'0')∧ शून्य हटाए जाने पर एक से अधिक अंक बने रहते हैं

1≥+/ 0 या 1 का योग है

2| की विषमताएं

+⌿ के कॉलम के

c∘.=∪cकी तुलना तालिका ग और का अद्वितीय तत्व ग , जहां ग ...

←⍕⍵ तर्क का स्ट्रिंग प्रतिनिधित्व है

}¨⍵ प्रत्येक तर्क पर लागू किया गया

}⍳5×⍵ {1, 2, 3, ..., 5 बार तर्क} पर लागू

} [समारोह का अंत]

सभी परीक्षण मामलों को तुरंत TryAPL पर समाप्त करता है

Comments

क्या आप यह साबित कर सकते हैं a(n) <= 5n?

— लीक नून

दूसरा समाधान गलत परिणाम उत्पन्न करता है।

— लीक नून

पहला समाधान भी गलत परिणाम उत्पन्न करता है।

— लीक

@LeakyNun कौन से गलत हैं? और अगर 5 × पर्याप्त नहीं है, तो 9 × के लिए जगह है ...

— एडम

@ लीककॉन राइट, मैं 100 आदि को शामिल करता हूं, जिसकी अनुमति नहीं है।

— अड्म

Answer 10

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

n=>eval("for(a=0;n-=(a++<9||(b=[...a+``].sort().join``)>9&!b.replace(/(.)\\1/g,``)[1]););a")

कम गोल्फ वाला

n=>{
  for( a = 0;
       n -= // decrement n (and exit when 0) if the check below is true == a is permutapalindromic
            (a ++ < 9 // single digit (meanwhile, increment a)
             || // or...
             ( b=[...a+``].sort().join`` )// build a string with the digits sorted
               > 9 // required at least 2 non zero digits
             & ! b.replace(/(.)\1/g,``)[1] // removed all digits pair, there must be just 1 or no single digits remaining
            );
     );
   return a;
}

परीक्षा

f=n=>eval("for(a=0;n-=(a++<9||(b=[...a+``].sort().join``)>9&!b.replace(/(.)\\1/g,``)[1]););a")

function update() {
  O.textContent=f(+I.value)
}

update()

<input id=I oninput=update() type=number value=100>
<pre id=O></pre>

Answer 11

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करना - असंख्य) (142 बाइट्स)

   n=>_.Sequence(n,i=>{l=i+"";p=_.Permutations(_.From(l),l.length).Any(y=>y.First()!="0"&&y.SequenceEqual(y.Reverse()));if(p){return i;}}).Last()

लिंक से संबंधित: https://github.com/mvegh1/Enumerable/

कोड स्पष्टीकरण: _। साक्षरता "एन" तत्वों की एक गणना के लिए एक गणना योग्य बनाता है, जो हस्ताक्षर की विधेय पर आधारित है ("i" teration , "a" ccumulated array )। एक स्ट्रिंग के लिए वर्तमान पुनरावृत्ति कास्ट करें, और इससे सभी क्रमपरिवर्तन की गणना करें। यदि कोई भी क्रमपरिवर्तन "0" से शुरू न होने की कसौटी पर खरा उतरता है और क्रमपरिवर्तन के क्रम को क्रमपरिवर्तन के बराबर करता है तो परीक्षण करें। अनुक्रम में अंतिम तत्व लौटें क्योंकि ओपी के अनुसार वांछित आउटपुट है

Answer 12

पायथन 2, 93 बाइट्स

S=sorted
f=lambda n,i=1:n and-~f(n-(S(`i`)in[S(`k`)for k in range(9*i)if`k`==`k`[::-1]]),i+1)

1 अनुक्रमित। आपके सिस्टम के आधार पर, अंतिम परीक्षण का मामला अनुमत पुनरावृत्ति गहराई से अधिक हो सकता है।

क्रमपरिवर्तन की गणना नहीं करता है। इसके बजाय, इस तथ्य का उपयोग करता है कि दो तार क्रमपरिवर्तन हैं यदि वे क्रमबद्ध होने पर समान होते हैं। यह जांचने के लिए कि क्या कोई संख्या क्रमपरिवर्तन है, यह जांचें कि क्या उसके छंटे हुए अंक किसी पलिंद्रा के छंटे हुए अंकों को एक सीमा तक बराबर करते हैं।

---

96 बाइट्स:

f=lambda n,i=1:n and-~f(n-(sum(`i`.count(`d`)%2for d in range(10))<2*(set(`i`[1:])!={'0'})),i+1)

1 अनुक्रमित। आपके सिस्टम के आधार पर, अंतिम परीक्षण का मामला अनुमत पुनरावृत्ति गहराई से अधिक हो सकता है।

यह क्रमपरिवर्तन को नहीं देखता है और इसके बजाय निम्नलिखित लक्षण वर्णन का उपयोग करता है:

एक संख्या बिल्कुल जब permutapalindromic है

• इसके अधिकांश अंकों में एक विषम संख्या कई बार दिखाई देती है, और
• इसका फॉर्म d00 नहीं है ... 00 एक या अधिक शून्य के साथ।

यह सच है क्योंकि एक संभावित केंद्र अंक को छोड़कर, एक palindrome को शुरू और अंत से अंकों को जोड़ देना चाहिए। अपवाद इस आवश्यकता से आता है कि अग्रणी अंक नॉनजेरो होना चाहिए, और इसलिए कुछ गैर-अंकीय अंक दो बार दिखाई देने चाहिए जब तक कि संख्या एकल-अंक न हो।

Answer 13

हास्केल, 89 87 बाइट्स

import Data.List
(filter(any(show.floor.read.reverse>>=(==)).permutations.show)[0..]!!)

Answer 14

सी, 254 बाइट्स

#define W while
#define R return
f(j){int c=0,a[16]={0};do++a[j%10],++c;W(j/=10);if(c>1&&a[0]>=c-1)R 0;c%=2;W(j<10)if(a[j++]%2&&(!c||++c>2))R 0;R 1;}g(n){int k=0,i=1;W(k<n)if(f(i++))++k;R i-1;}main(a){printf("N>");scanf("%d",&a);printf("%d\n",g(a));}