Biorąc pod uwagę liczbę całkowitą Njako dane wejściowe, Nwypisz th permutapalindromic number.

Liczba permutapalindromowa jest ściśle dodatnią liczbą całkowitą, tak że istnieje co najmniej jedna permutacja jej cyfr, która powoduje palindrom (tj. Liczba, która jest własną odwrotnością).

Na przykład 117jest liczbą permutapalindromiczną, ponieważ jej cyfry mogą być permutowane 171, co jest palindromem.

Uważamy, że liczby podobne 10nie są liczbami permutapalindromicznymi, nawet jeśli 01 = 1są palindromem. Narzucamy, że permutacja palindromiczna nie może mieć wiodącego zera (jako taka 0sama w sobie nie jest permutapalindromiczna).

Liczby, które są już palindromami, są również permutapalindromiczne, ponieważ dopuszczanie niczego nie jest poprawne.

Wejścia i wyjścia

• Nmoże być indeksowany 0 lub indeksowany 1. Wskaż, którego z nich używa Twoja odpowiedź.
• Dane wejściowe można przejrzeć STDINjako argument funkcji lub dowolną podobną rzecz w wybranym języku. Dane wyjściowe mogą być zapisywane STDOUT, zwracane z funkcji lub z dowolnego podobnego elementu w wybranym języku.
• Dane wejściowe i wyjściowe muszą być w systemie dziesiętnym.

Przypadki testowe

Następujące przypadki testowe mają indeks 1. Twój program musi być w stanie przejść dowolny z przedstawionych tutaj przypadków testowych w ciągu 1 minuty.

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

Punktacja

To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.

05AB1E , 15 14 13 bajtów

Oszczędność bajtu dzięki Emignie ! Kod:

µNœvyJÂïÊP}_½

Wyjaśnienie:

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

Wykorzystuje kodowanie CP-1252 . Wypróbuj online! .

Brachylog, 19 bajtów

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

Wypróbuj online!

Trwa około 17 sekund N = 270.

Wyjaśnienie

• Główny predykat:

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

• Predykat 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 bajtów

1 bajt dzięki Fatalize.

Czy zaprojektowałeś wyzwanie dla Brachylog?

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

Wypróbuj online!

270 zajmuje tutaj około pół minuty.

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

Exit code:     0

Predykat 0 (główny predykat)

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

Predykat 1 (predykat pomocniczy)

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 lat

e.ff&_ITshT.p`

Wypróbuj tutaj lub uruchom pakiet testowy

Ekspansja:

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 bajtów

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

Wyjaśnienie:

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 bajtów

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}

bez golfa

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
}

Zasadniczo - funkcja sprawdzająca członkostwo w zestawie permutapalindromic i zwiększająca się pętla while, aż znajdzie n-ty element.

Python 2.7, 163 154 bajty:

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]

Wystarczająco proste. Zasadniczo używa whilepętli do wielokrotnego tworzenia tablic zawierających liczby permutapalindromiczne zakresu, [1,Q)aż Qbędzie wystarczająco duży, aby tablica zawierała Inputliczbę elementów. Następnie wyprowadza ostatni element w tej tablicy.

Wypróbuj online! (Ideone)

Perl 6 , 66 bajtów

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

W oparciu o 0

Wyjaśnienie:

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

Test:

#! /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 bajtów

Jeden indeksowany.

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

{ funkcja, w której ⍵ reprezentuje argument

⍵⊃{ użyj argumentu, aby wybrać wynik funkcji

⍵/⍨{ odfiltruj argument z wynikiem funkcji

(⍵≤9)∨ argument jest mniejszy lub równy 9, LUB

(1<≢c~'0')∧ po usunięciu zer ORAZ pozostaje więcej niż jedna cyfra

1≥+/ 0 lub 1 to suma

2| osobliwości

+⌿ sumy kolumn

c∘.=∪ctabela porównawcza c i unikalne elementy c , gdzie c ...

←⍕⍵ jest reprezentacją ciągu argumentu

}¨⍵ zastosowane do każdego z argumentów

}⍳5×⍵ zastosowane do {1, 2, 3, ..., 5 razy argumentu}

} [koniec funkcji]

Kończy wszystkie przypadki testowe natychmiast na TryAPL

JavaScript (ES6), 92

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

Mniej golfa

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

Test

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 (przy użyciu zewnętrznej biblioteki - Enumerable) (142 bajty)

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

Link do lib: https://github.com/mvegh1/Enumerable/

Wyjaśnienie kodu: _.Sequence tworzy wyliczenie dla liczby elementów „n”, na podstawie predykatu podpisu („i” teration , „a” ccumulated array ). Rzuć bieżącą iterację na ciąg i utwórz z niej wyliczenie wszystkich permutacji. Sprawdź, czy którakolwiek z permutacji spełnia test polegający na tym, że nie zaczyna się od „0” i czy odwrócenie permutacji jest równe permutacji. Zwraca ostatni element w sekwencji, ponieważ jest to pożądany wynik według OP

Python 2, 93 bajty

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-indeksowany. W zależności od systemu ostatni przypadek testowy może przekroczyć dozwoloną głębokość rekurencji.

Nie oblicza permutacji. Zamiast tego wykorzystuje fakt, że dwa ciągi są permutacjami, jeśli są one równe podczas sortowania. Aby sprawdzić, czy liczba jest permutapalindromiczna, sprawdź, czy jej posortowane cyfry są równe posortowanym cyfrom dowolnego palindromu do granicy.

96 bajtów:

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-indeksowany. W zależności od systemu ostatni przypadek testowy może przekroczyć dozwoloną głębokość rekurencji.

To nie patrzy na permutacje, a zamiast tego wykorzystuje następującą charakterystykę:

Liczba jest permutapalindromiczna dokładnie wtedy, gdy

• Co najwyżej jedna z jej cyfr pojawia się nieparzystą liczbę razy, i
• Nie ma postaci d00 ... 00 z jednym lub więcej zerami.

Dzieje się tak, ponieważ palindrom musi sparować cyfry od początku i na końcu, z wyjątkiem możliwej cyfry środkowej. Wyjątek wynika z wymogu, aby cyfra wiodąca była niezerowa, dlatego niektóre cyfry niezerowe muszą pojawiać się dwukrotnie, chyba że liczba jest jednocyfrowa.

Haskell, 89 87 bajtów

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

C, 254 bajty

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