Cho một số nguyên Nlàm đầu vào, xuất ra Nsố permutapalindromic thứ.

Một số permutapalindromic là một số nguyên dương hoàn toàn sao cho có ít nhất một hoán vị các chữ số của nó dẫn đến một palindrom (tức là một số ngược lại với chính nó).

Ví dụ, 117là một số permutapalindromic vì các chữ số của nó có thể được hoán vị vào 171, đó là một bảng màu.

Chúng tôi xem xét rằng các số như 10không phải là số permutapalindromic, mặc dù 01 = 1là một palindrom. Chúng tôi áp đặt rằng hoán vị palindromic không được có số 0 đứng đầu (như vậy, 0bản thân nó không phải là permutapalindromic).

Các số đã là palindromes cũng là permutapalindromic, vì hoán vị không có gì là hợp lệ.

Đầu vào và đầu ra

• Ncó thể là 0 chỉ mục hoặc 1 chỉ mục. Vui lòng cho biết câu trả lời nào trong hai câu trả lời của bạn.
• Đầu vào có thể được thực hiện thông qua STDIN, như là một đối số chức năng hoặc bất cứ điều gì tương tự trong ngôn ngữ bạn chọn. Đầu ra có thể được ghi vào STDOUT, trả về từ một hàm hoặc bất cứ thứ gì tương tự trong ngôn ngữ bạn chọn.
• Đầu vào và đầu ra phải ở trong cơ sở thập phân.

Các trường hợp thử nghiệm

Các trường hợp kiểm tra sau đây là 1 chỉ mục. Chương trình của bạn phải có thể vượt qua bất kỳ trường hợp thử nghiệm nào được trình bày ở đây trong tối đa 1 phút.

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

Chấm điểm

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng.

05AB1E , 15 14 13 byte

Đã lưu một byte nhờ Emigna ! Mã số:

µNœvyJÂïÊP}_½

Giải trình:

µ               # 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.

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! .

Brachylog, 19 byte

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

Hãy thử trực tuyến!

Mất khoảng 17 giây cho N = 270.

Giải trình

• Vị ngữ chính:

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

• Vị ngữ 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 byte

1 byte nhờ Fatalize.

Bạn đã thiết kế thử thách cho Brachylog?

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

Hãy thử trực tuyến!

270 mất khoảng nửa phút ở đây.

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

Exit code:     0

Vị ngữ 0 (vị ngữ chính)

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

Vị ngữ 1 (vị ngữ phụ)

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.

Bình thường, 14

e.ff&_ITshT.p`

Dùng thử tại đây hoặc chạy Test Suite

Sự bành trướng:

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 byte

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

Giải trình:

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 byte

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}

vô dụng

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
}

Về cơ bản - một chức năng kiểm tra tư cách thành viên trong tập permutapalindromic và tăng vòng lặp while cho đến khi tìm thấy thành viên thứ n.

Python 2.7, 163 154 byte:

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]

Đủ đơn giản. Về cơ bản sử dụng một whilevòng lặp để liên tục tạo các mảng chứa các số permutapalindromic phạm vi [1,Q)cho đến khi Qđủ lớn để mảng chứa Inputsố lượng mục. Sau đó nó xuất ra phần tử cuối cùng trong mảng đó.

Dùng thử trực tuyến! (Ý)

Perl 6 , 66 byte

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

0 dựa

Giải trình:

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

Kiểm tra:

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

APL Dyalog , 51 byte

Một chỉ mục.

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

{ một hàm trong đó đại diện cho đối số

⍵⊃{ sử dụng đối số để chọn từ kết quả của hàm

⍵/⍨{ lọc đối số với kết quả của hàm

(⍵≤9)∨ đối số nhỏ hơn hoặc bằng 9, HOẶC

(1<≢c~'0')∧ vẫn còn hơn một chữ số khi các số 0 được loại bỏ VÀ

1≥+/ 0 hoặc 1 là tổng của

2| sự kỳ quặc của

+⌿ tổng số cột của

c∘.=∪cbảng so sánh của c và các phần tử duy nhất của c , trong đó c ...

←⍕⍵ là biểu diễn chuỗi của đối số

}¨⍵ áp dụng cho từng đối số

}⍳5×⍵ áp dụng cho {1, 2, 3, ..., 5 lần đối số}

} [kết thúc chức năng]

Kết thúc tất cả các trường hợp thử nghiệm ngay lập tức trên TryAPL

JavaScript (ES6), 92

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

Ít chơi gôn

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

Kiểm tra

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 (sử dụng thư viện bên ngoài - Có thể đếm được) (142 byte)

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

Liên kết đến lib: https://github.com/mvegh1/Enumerable/

Giải thích mã: _.Sequence tạo ra vô số cho một số phần tử "n", dựa trên vị từ của chữ ký ("i " teration "," mảng được tích lũy ). Truyền phép lặp hiện tại vào một chuỗi và tạo ra vô số các hoán vị từ nó. Kiểm tra xem có bất kỳ hoán vị nào thỏa mãn phép thử không bắt đầu bằng "0" hay không và sự đảo ngược của hoán vị bằng với hoán vị. Trả về phần tử cuối cùng trong chuỗi vì đó là đầu ra mong muốn theo OP

Python 2, 93 byte

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 chỉ mục. Tùy thuộc vào hệ thống của bạn, trường hợp thử nghiệm cuối cùng có thể vượt quá độ sâu đệ quy được phép.

Không tính toán hoán vị. Thay vào đó, sử dụng thực tế là hai chuỗi là hoán vị nếu chúng bằng nhau khi được sắp xếp. Để kiểm tra xem một số có phải là permutapalindromic hay không, hãy kiểm tra xem các chữ số được sắp xếp của nó có bằng các chữ số được sắp xếp của bất kỳ palindrom nào với một ràng buộc không.

96 byte:

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 chỉ mục. Tùy thuộc vào hệ thống của bạn, trường hợp thử nghiệm cuối cùng có thể vượt quá độ sâu đệ quy được phép.

Điều này không nhìn vào hoán vị và thay vào đó sử dụng đặc tính sau:

Một số là permutapalindromic chính xác khi

• Nhiều nhất một chữ số của nó xuất hiện một số lần lẻ và
• Nó không có dạng d00 ... 00 với một hoặc nhiều số không.

Điều này đúng bởi vì một palindrom phải ghép các chữ số từ đầu và cuối, ngoại trừ một chữ số trung tâm có thể. Ngoại lệ xuất phát từ yêu cầu rằng chữ số hàng đầu phải là số khác, và do đó, một số chữ số khác phải xuất hiện hai lần trừ khi số đó là một chữ số.

Haskell, 89 87 byte

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

C, 254 byte

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