Étant donné un entier Nen entrée, Nsortez le numéro permutapalindromique.

Un nombre permutapalindromique est un entier strictement positif tel qu'il y a au moins une permutation de ses chiffres qui se traduit par un palindrome (c'est-à-dire un nombre qui est son propre inverse).

Par exemple, 117est un nombre permutapalindromique puisque ses chiffres peuvent être permutés en 171, qui est un palindrome.

Nous considérons que les nombres comme 10ne sont pas des nombres permutapalindromiques, même s'il 01 = 1s'agit d'un palindrome. Nous imposons que la permutation palindromique ne doit pas avoir de zéro de tête (en tant que telle, 0elle-même n'est pas permutapalindromique).

Les nombres qui sont déjà des palindromes sont également permutapalindromiques, car rien ne permet de permuter.

Entrées et sorties

• Npeut être indexé 0 ou indexé 1. Veuillez indiquer laquelle des deux réponses votre réponse utilise.
• L'entrée peut être prise en compte STDIN, en tant qu'argument de fonction, ou tout autre élément similaire dans la langue de votre choix. La sortie peut être écrite STDOUT, renvoyée par une fonction ou quelque chose de similaire dans la langue de votre choix.
• L'entrée et la sortie doivent être dans la base décimale.

Cas de test

Les cas de test suivants sont indexés 1. Votre programme doit être en mesure de réussir l'un des cas de test présentés ici en au plus 1 minute.

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

Notation

Il s'agit de code-golf , donc la réponse la plus courte en octets l'emporte.

05AB1E , 15 14 13 octets

Un octet enregistré grâce à Emigna ! Code:

µNœvyJÂïÊP}_½

Explication:

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

Utilise l' encodage CP-1252 . Essayez-le en ligne! .

Brachylog, 19 octets

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

Essayez-le en ligne!

Prend environ 17 secondes N = 270.

Explication

• Prédicat 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.
  

• Prédicat 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 octets

1 octet grâce à Fatalize.

Avez-vous conçu le défi pour Brachylog?

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

Essayez-le en ligne!

270 prend environ une demi-minute ici.

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

Exit code:     0

Prédicat 0 (prédicat principal)

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

Prédicat 1 (prédicat auxiliaire)

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`

Essayez-le ici ou exécutez une suite de tests

Expansion:

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 octets

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

Explication:

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 octets

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}

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

Essentiellement - une fonction vérifiant l'appartenance à l'ensemble permutapalindromique, et une boucle while incrémentant jusqu'à ce qu'il trouve le nième membre.

Python 2.7, 163 154 octets:

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]

Assez simple. Utilise essentiellement unwhile boucle pour créer de manière répétée des tableaux contenant des nombres permutapalindromiques [1,Q)jusqu'à Qce que la plage soit suffisamment grande pour que le tableau contienne un Inputcertain nombre d'éléments. Il sort ensuite le dernier élément de ce tableau.

Essayez-le en ligne! (Ideone)

Perl 6 , 66 octets

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

0 basé

Explication:

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

Tester:

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

Un index.

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

{ une fonction où ⍵ représente l'argument

⍵⊃{ utiliser l'argument pour choisir dans le résultat de la fonction

⍵/⍨{ filtrer l'argument avec le résultat de la fonction

(⍵≤9)∨ l'argument est inférieur ou égal à 9, OU

(1<≢c~'0')∧ il reste plus d'un chiffre lorsque les zéros sont supprimés ET

1≥+/ 0 ou 1 est la somme de

2| les bizarreries de

+⌿ des sommes de colonne de

c∘.=∪cle tableau de comparaison de c et les éléments uniques de c , où c ...

←⍕⍵ est la représentation sous forme de chaîne de l'argument

}¨⍵ appliqué à chacun des arguments

}⍳5×⍵ appliqué à {1, 2, 3, ..., 5 fois l'argument}

} [fin de fonction]

Termine tous les cas de test instantanément sur TryAPL

JavaScript (ES6), 92

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

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

Tester

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 (en utilisant une bibliothèque externe - énumérable) (142 octets)

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

Lien vers la bibliothèque: https://github.com/mvegh1/Enumerable/

Explication du code: _.Sequence crée un énumérable pour un nombre d'éléments "n", basé sur le prédicat de signature (teration "i" , "un" tableau cumulé ). Convertissez l'itération actuelle en chaîne et créez-en un énumérable de toutes les permutations. Testez si l'une des permutations satisfait au test de ne pas commencer par "0" et que l'inversion de la permutation est égale à la permutation. Renvoie le dernier élément de la séquence car c'est la sortie souhaitée selon OP

Python 2, 93 octets

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 indexé. Selon votre système, le dernier scénario de test peut dépasser la profondeur de récursivité autorisée.

Ne calcule pas les permutations. À la place, utilise le fait que deux chaînes sont des permutations si elles sont égales lors du tri. Pour tester si un nombre est permutapalindromique, vérifie si ses chiffres triés sont égaux aux chiffres triés de tout palindrome jusqu'à une limite.

96 octets:

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 indexé. Selon votre système, le dernier scénario de test peut dépasser la profondeur de récursivité autorisée.

Cela ne regarde pas les permutations et utilise à la place la caractérisation suivante:

Un nombre est permutapalindromique exactement quand

• Au plus un de ses chiffres apparaît un nombre impair de fois, et
• Il n'a pas la forme d00 ... 00 avec un ou plusieurs zéros.

Cela est vrai car un palindrome doit associer des chiffres du début et de la fin, à l'exception d'un chiffre central possible. L'exception vient de l'exigence que le premier chiffre soit différent de zéro, et donc un chiffre différent de zéro doit apparaître deux fois sauf si le nombre est à un chiffre.

Haskell, 89 87 octets

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

C, 254 octets

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