NGiriş olarak bir tamsayı verildiğinde , Npermutapalindromik sayıyı çıktılayın.

Bir permutapalindromik sayı, bir palindromla sonuçlanan basamaklarının en az bir permütasyonu (yani kendi tersi olan bir sayı) olacak şekilde kesinlikle pozitif bir tamsayıdır.

Örneğin , bir palindrom olan 117basamaklarına izin verilebildiğinden permutapalindromik bir sayıdır 171.

Palindrom 10olmasına rağmen 01 = 1, gibi sayıların permutapalindromik sayılar olmadığını düşünüyoruz . Palindromik permütasyonun önde gelen sıfıra sahip olmaması gerektiğini kabul ediyoruz (bu nedenle, 0kendisi permutapalindromik değildir).

Zaten palindrom olan sayılar da permutapalindromiktir, çünkü hiçbir şeye izin vermek geçerli değildir.

Girdiler ve çıktılar

• N0-indeksli veya 1-indeksli olabilir. Lütfen yanıtınızın ikisinden hangisini kullandığını belirtin.
• Giriş, STDINbir işlev bağımsız değişkeni olarak veya kendi dilinizde benzer bir şeyle alınabilir . Çıktı STDOUTbir işleve yazılabilir , bir işlevden döndürülebilir veya kendi dilinizde benzer bir şey olabilir.
• Giriş ve çıkış ondalık tabanda olmalıdır.

Test senaryoları

Aşağıdaki test senaryoları 1 dizinlidir. Programınız burada sunulan test durumlarından herhangi birini en fazla 1 dakika içinde geçebilmelidir.

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

puanlama

Bu kod golf , bu yüzden bayttaki en kısa cevap kazanır.

05AB1E , 15 14 13 bayt

Emigna sayesinde bir bayt kurtardı ! Kod:

µNœvyJÂïÊP}_½

Açıklama:

µ               # 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 kodlamasını kullanır . Çevrimiçi deneyin! .

Brachylog, 19 bayt

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

Çevrimiçi deneyin!

Yaklaşık 17 saniye sürer N = 270.

açıklama

• Ana yüklem:

  ~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.
  

• Tahmin 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
  

Brachylog , 21 20 bayt

Fatalize sayesinde 1 bayt.

Brachylog için meydan okumayı tasarladınız mı?

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

Çevrimiçi deneyin!

270 burada yaklaşık yarım dakika sürüyor.

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

Exit code:     0

Tahmin 0 (ana yüklem)

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

Tahmin 1 (yardımcı yüklem)

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.

Pyth, 14

e.ff&_ITshT.p`

Buradan deneyin veya Test Paketi çalıştırın

Genişleme:

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

JavaScript (ES6), 99 bayt

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

Açıklama:

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!

R, 145 bayt

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
}

Esasen - permutapalindromik sette üyeliği kontrol eden bir fonksiyon ve n. Elemanı bulana kadar bir while döngüsü artar.

Python 2.7, 163156 bayt:

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]

Yeterince basit. Temelde, whiledizi içerecek [1,Q)kadar Qgeniş olan aralıktaki permutapalindromik sayıları içeren dizileri tekrar tekrar oluşturmak için bir döngü kullanırInput . Daha sonra bu dizideki son öğeyi çıktılar.

Çevrimiçi Deneyin! (Ideone)

Perl 6 , 66 bayt

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

0 tabanlı

Açıklama:

# 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
  )[$_]
}

Ölçek:

#! /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";

Dyalog APL , 51 bayt

Tek endekslendi.

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

{ ⍵ argümanı temsil eden bir işlev

⍵⊃{ fonksiyonun sonucundan seçim yapmak için argümanı kullanın

⍵/⍨{ argümanı işlevin sonucuyla filtreleme

(⍵≤9)∨ argüman 9'a eşit veya daha az, VEYA

(1<≢c~'0')∧ sıfırlar kaldırıldığında birden fazla basamak kalır VE

1≥+/ 0 veya 1 toplamıdır

2| tuhaflıkları

+⌿ sütun toplamlarının

c∘.=∪ckarşılaştırılması tablo c ve benzersiz öğeleri c , c ...

←⍕⍵ argümanın dize temsilidir

}¨⍵ argümanların her birine uygulandı

}⍳5×⍵ {1, 2, 3, ..., argümanın 5 katına uygulandı}

} [işlev sonu]

TryAPL'de tüm test senaryolarını anında bitirir

JavaScript (ES6), 92

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

Daha az golf

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

Ölçek

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>

Javascript (harici kitaplık kullanarak - Numaralandırılabilir) (142 bayt)

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

Lib bağlantısı: https://github.com/mvegh1/Enumerable/

Kod açıklaması: _.Sequence, imza yüklemine ("i " teration, "a" kümülatif dizi ) dayalı olarak "n" element sayısı için numaralandırılabilir bir sayı oluşturur . Geçerli yinelemeyi bir dizeye yayınlar ve ondan tüm permütasyonlardan bir numara oluşturur. Permütasyonlardan herhangi birinin "0" ile başlamama testini karşılayıp karşılamadığını ve permütasyonun geri dönüşünün permütasyona eşit olup olmadığını test edin. OP'ye göre istenen çıkış olduğu için dizideki son elemanı döndürün

Python 2, 93 bayt

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 endeksli. Sisteminize bağlı olarak, son test durumu izin verilen yineleme derinliğini aşabilir.

Permütasyonları hesaplamaz. Bunun yerine, iki dizenin, sıralandığında eşit oldukları takdirde permütasyon olduğu gerçeğini kullanır. Bir sayının permutpalindromik olup olmadığını test etmek için, sıralı basamaklarının herhangi bir palindromun sıralı basamaklarına bir sınırla eşit olup olmadığını kontrol eder.

96 bayt:

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 endeksli. Sisteminize bağlı olarak, son test durumu izin verilen yineleme derinliğini aşabilir.

Bu permütasyonlara bakmaz ve bunun yerine aşağıdaki karakterizasyonu kullanır:

Bir sayı tam olarak ne zaman permutapalindromiktir

• Rakamlarından en fazla biri tek sayıda görünüyor ve
• Bir veya daha fazla sıfır içeren d00 ... 00 biçimine sahip değildir.

Bu doğrudur, çünkü bir palindrom, olası bir orta basamak hariç, başlangıç ​​ve bitiş rakamlarını eşleştirmelidir. İstisna, öndeki basamağın sıfırdan farklı olması gerekliliğinden gelir ve bu nedenle, sayı tek basamak olmadıkça sıfır olmayan bir basamağın iki kez görünmesi gerekir.

Haskell, 89 87 bayt

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

C, 254 bayt

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