Dato un numero intero Ncome input, emette il fileN emette il numero permutapalindromico.

Un numero permutapalindromico è un numero intero strettamente positivo in modo che vi sia almeno una permutazione delle sue cifre che si traduce in un palindromo (cioè un numero che è il suo contrario).

Ad esempio, 117è un numero permutapalindromico poiché le sue cifre possono essere permutate in 171, che è un palindromo.

Consideriamo che numeri come 10non sono numeri permutapalindromici, anche se 01 = 1è un palindromo. Imponiamo che la permutazione palindromica non debba avere uno zero iniziale (come tale, di per 0sé non è permutapalindromica).

Anche i numeri che sono già palindromi sono permutapalindromici, poiché non è valido nulla.

Ingressi e uscite

• Npuò essere 0 indicizzato o 1 indicizzato. Indica quale delle due risposte utilizza.
• L'input può essere preso in considerazione STDIN, come argomento di funzione, o qualcosa di simile nella tua lingua preferita. L'output può essere scritto STDOUT, restituito da una funzione o qualcosa di simile nella tua lingua preferita.
• L'input e l'output devono essere nella base decimale.

Casi test

I seguenti casi di test sono 1 indicizzati. Il tuo programma deve essere in grado di superare uno qualsiasi dei casi di test qui presentati al massimo entro 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

punteggio

Questo è code-golf , quindi vince la risposta più breve in byte.

05AB1E , 15 14 13 byte

Salvataggio di un byte grazie a Emigna ! Codice:

µNœvyJÂïÊP}_½

Spiegazione:

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

Utilizza la codifica CP-1252 . Provalo online! .

Brachylog, 19 byte

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

Provalo online!

Dura circa 17 secondi per N = 270.

Spiegazione

• Predicato principale:

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

• Predicato 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 grazie a Fatalize.

Hai progettato la sfida per Brachylog?

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

Provalo online!

270 impiega circa mezzo minuto qui.

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

Exit code:     0

Predicato 0 (predicato principale)

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

Predicato 1 (predicato ausiliario)

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`

Provalo qui o esegui una Test Suite

Espansione:

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

Spiegazione:

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}

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
}

Essenzialmente - una funzione che controlla l'appartenenza all'insieme permutapalindromic e un ciclo while che aumenta fino a trovare l'ennesimo membro.

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]

Abbastanza semplice. Fondamentalmente utilizza un whileloop per creare ripetutamente array contenenti numeri permutapalindromici dell'intervallo [1,Q)fino a quando non Qè sufficientemente grande in modo tale che l'array contenga il Inputnumero di elementi. Quindi genera l'ultimo elemento in quell'array.

Provalo online! (Ideone)

Perl 6 , 66 byte

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

Basato su 0

Spiegazione:

# 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 byte

One-indicizzato.

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

{ una funzione in cui ⍵ rappresenta l'argomento

⍵⊃{ usa l'argomento per scegliere dal risultato della funzione

⍵/⍨{ filtra l'argomento con il risultato della funzione

(⍵≤9)∨ l'argomento è minore o uguale a 9, OR

(1<≢c~'0')∧ rimane più di una cifra quando gli zeri vengono rimossi AND

1≥+/ 0 o 1 è la somma di

2| le stranezze di

+⌿ della colonna somma di

c∘.=∪cla tabella comparativa di c e gli elementi unici di c , dove c ...

←⍕⍵ è la rappresentazione in formato stringa dell'argomento

}¨⍵ applicato a ciascuno degli argomenti

}⍳5×⍵ applicato a {1, 2, 3, ..., 5 volte l'argomento}

} [fine della funzione]

Termina immediatamente tutti i casi di test su TryAPL

JavaScript (ES6), 92

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

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

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 (utilizzando una libreria esterna - Enumerabile) (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()

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

Spiegazione del codice: _.Sequence crea un enumerabile per un conteggio di "n" elementi, basato sul predicato della firma ("i " teration ", un" array accumulato ). Trasmetti l'attuale iterazione a una stringa e crea un elenco di tutte le permutazioni da essa. Verifica se una qualsiasi delle permutazioni soddisfa la prova di non iniziare con "0" e che l'inversione della permutazione è uguale alla permutazione. Restituisce l'ultimo elemento della sequenza perché quello è l'output desiderato secondo 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-indicizzati. A seconda del sistema in uso, l'ultimo caso di test può superare la profondità di ricorsione consentita.

Non calcola le permutazioni. Invece, usa il fatto che due stringhe sono permutazioni se sono uguali quando ordinate. Per verificare se un numero è permutapalindromico, controlla se le sue cifre ordinate equivalgono alle cifre ordinate di qualsiasi palindromo fino a un limite.

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-indicizzati. A seconda del sistema in uso, l'ultimo caso di test può superare la profondità di ricorsione consentita.

Questo non esamina le permutazioni e utilizza invece la seguente caratterizzazione:

Un numero è permutapalindromico esattamente quando

• Al massimo una delle sue cifre appare un numero dispari di volte e
• Non ha la forma d00 ... 00 con uno o più zeri.

Questo è vero perché un palindromo deve accoppiare le cifre all'inizio e alla fine, tranne una possibile cifra centrale. L'eccezione deriva dal requisito secondo cui la cifra iniziale deve essere diversa da zero e quindi una cifra diversa da zero deve apparire due volte, a meno che il numero non sia una cifra singola.

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