Dado un número entero Ncomo entrada, Ngenera el número permutapalindrómico.

Un número permutapalindrómico es un entero estrictamente positivo de tal manera que hay al menos una permutación de sus dígitos que da como resultado un palíndromo (es decir, un número que es su propio reverso).

Por ejemplo, 117es un número permutapalindrómico ya que sus dígitos se pueden permutar 171, que es un palíndromo.

Consideramos que los números como 10no son números permutapalindrómicos, aunque 01 = 1sea ​​un palíndromo. Imponemos que la permutación palindrómica no debe tener un cero 0inicial (como tal, en sí mismo no es permutapalindrómico).

Los números que ya son palíndromos también son permutapalindrómicos, ya que permutar nada es válido.

Entradas y salidas

• Npuede ser 0 indexado o 1 indexado. Indique cuál de los dos utiliza su respuesta.
• La entrada puede tomarse STDIN, como un argumento de función, o cualquier cosa similar en el idioma de su elección. El resultado puede escribirse STDOUT, devolverse desde una función o cualquier cosa similar en el idioma que elija.
• La entrada y la salida deben estar en la base decimal.

Casos de prueba

Los siguientes casos de prueba están indexados en 1. Su programa debe poder pasar cualquiera de los casos de prueba presentados aquí en un máximo de 1 minuto.

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

Puntuación

Este es el código de golf , por lo que gana la respuesta más corta en bytes.

05AB1E , 15 14 13 bytes

¡ Ahorré un byte gracias a Emigna ! Código:

µNœvyJÂïÊP}_½

Explicación:

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

Utiliza la codificación CP-1252 . Pruébalo en línea! .

Brachylog, 19 bytes

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

Pruébalo en línea!

Toma alrededor de 17 segundos para N = 270.

Explicación

• Predicado principal:

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

• Predicado 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 bytes

1 byte gracias a Fatalize.

¿Diseñaste el desafío para Brachylog?

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

Pruébalo en línea!

270 toma alrededor de medio minuto aquí.

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

Exit code:     0

Predicado 0 (predicado principal)

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

Predicado 1 (predicado auxiliar)

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`

Pruébelo aquí o ejecute un Test Suite

Expansión:

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 bytes

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

Explicación:

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 bytes

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}

sin golf

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
}

Básicamente: una función que verifica la pertenencia al conjunto permutapalindrómico y un ciclo while que se incrementa hasta encontrar el enésimo miembro.

Python 2.7, 163 154 bytes:

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]

Suficientemente simple. Básicamente usa un whilebucle para crear repetidamente matrices que contienen números permutapalindrómicos en el rango [1,Q)hasta que Qsea ​​lo suficientemente grande como para que la matriz contenga Inputvarios elementos. Luego genera el último elemento en esa matriz.

¡Pruébelo en línea! (Ideone)

Perl 6 , 66 bytes

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

0 basado

Explicación:

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

Prueba:

#! /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 bytes

Un índice.

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

{ una función donde ⍵ representa el argumento

⍵⊃{ usa el argumento para elegir el resultado de la función

⍵/⍨{ filtrar el argumento con el resultado de la función

(⍵≤9)∨ el argumento es menor o igual a 9, O

(1<≢c~'0')∧ queda más de un dígito cuando se eliminan los ceros Y

1≥+/ 0 o 1 es la suma de

2| las rarezas de

+⌿ de las sumas de columnas de

c∘.=∪cla tabla de comparación de c y los elementos únicos de c , donde c ...

←⍕⍵ es la representación de cadena del argumento

}¨⍵ aplicado a cada uno de los argumentos

}⍳5×⍵ aplicado a {1, 2, 3, ..., 5 veces el argumento}

} [fin de la función]

Termina todos los casos de prueba al instante en TryAPL

JavaScript (ES6), 92

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

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

Prueba

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 (usando una biblioteca externa - Enumerable) (142 bytes)

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

Enlace a lib: https://github.com/mvegh1/Enumerable/

Explicación del código: _.Secuencia crea un enumerable para un recuento de elementos "n", basado en el predicado de la firma ("i" teration , "una" matriz acumulada ). Convierta la iteración actual en una cadena y cree una enumerable de todas las permutaciones a partir de ella. Pruebe si alguna de las permutaciones satisface la prueba de no comenzar con "0" y si la inversión de la permutación es igual a la permutación. Devuelve el último elemento de la secuencia porque esa es la salida deseada según OP

Python 2, 93 bytes

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 indexado. Dependiendo de su sistema, el último caso de prueba puede exceder la profundidad de recursión permitida.

No calcula permutaciones. En cambio, utiliza el hecho de que dos cadenas son permutaciones si son iguales cuando se ordenan. Para probar si un número es permutapalindrómico, verifica si sus dígitos ordenados son iguales a los dígitos ordenados de cualquier palíndromo hasta un límite.

96 bytes:

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 indexado. Dependiendo de su sistema, el último caso de prueba puede exceder la profundidad de recursión permitida.

Esto no mira las permutaciones y en su lugar usa la siguiente caracterización:

Un número es permutapalindrómico exactamente cuando

• Como máximo, uno de sus dígitos aparece un número impar de veces, y
• No tiene la forma d00 ... 00 con uno o más ceros.

Esto es cierto porque un palíndromo debe emparejar dígitos desde el inicio y el final, excepto por un posible dígito central. La excepción proviene del requisito de que el dígito inicial sea distinto de cero, por lo que algunos dígitos distintos de cero deben aparecer dos veces a menos que el número sea de un solo dígito.

Haskell, 89 87 bytes

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

C, 254 bytes

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