Учитывая целое число в Nкачестве входных данных, выведите Nпермутапалиндромное число.

Пермутапалиндромное число - это строго положительное целое число, так что существует хотя бы одна перестановка его цифр, которая приводит к палиндрому (то есть число, которое является его собственной обратной).

Например, 117это пермутапалиндромное число, так как его цифры могут быть переставлены в 171палиндром.

Мы считаем, что числа как 10не являются permutapalindromic числа, хотя 01 = 1это палиндром. Мы навязываем, что палиндромная перестановка не должна иметь ведущего нуля (как таковая, 0сама по себе не является пермутапалиндромной).

Числа, которые уже являются палиндромами, также являются пермутапалиндромными, поскольку перестановка ничего не действительна.

Входы и выходы

• Nможет быть 0-индексирован или 1-индексирован. Пожалуйста, укажите, какой из двух ваших ответов используется.
• Ввод может быть получен STDINв качестве аргумента функции или чего-либо подобного на выбранном вами языке. Вывод может быть записан STDOUT, возвращен из функции или чем-либо подобным на выбранном вами языке.
• Вход и выход должны быть в десятичной основе.

Контрольные примеры

Следующие тесты 1-индексированы. Ваша программа должна быть в состоянии пройти любой из тестовых примеров, представленных здесь, максимум за 1 минуту.

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

счет

Это код-гольф , поэтому выигрывает самый короткий ответ в байтах.

05AB1E , 15 14 13 байт

Сохранил байт благодаря Emigna ! Код:

µNœvyJÂïÊP}_½

Объяснение:

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

Использует кодировку CP-1252 . Попробуйте онлайн! ,

Брахилог, 19 байт

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

Попробуйте онлайн!

Занимает около 17 секунд N = 270.

объяснение

• Основной предикат:

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

• Предикат 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
  

Брахилог , 21 20 байт

1 байт благодаря Fatalize.

Вы разработали задачу для Brachylog?

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

Попробуйте онлайн!

270 занимает около полминуты здесь.

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

Exit code:     0

Предикат 0 (основной предикат)

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

Предикат 1 (вспомогательный предикат)

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.

Пиф, 14

e.ff&_ITshT.p`

Попробуйте здесь или запустите Test Suite

Расширение:

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 байт

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

Объяснение:

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 байтов

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
}

По сути - функция, проверяющая членство в пермутапалиндромном множестве и увеличивающая цикл while, пока не найдет n-й член.

Python 2,7, 163 154 байта:

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]

Достаточно просто. В основном используется whileцикл многократно создавать массивы , содержащие permutapalindromic чисел диапазона , [1,Q)пока Qне является достаточно большим , так что массив содержит Inputколичество элементов. Затем он выводит последний элемент в этом массиве.

Попробуйте онлайн! (Ideone)

Perl 6 , 66 байт

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

0 основано

Объяснение:

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

Тестовое задание:

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

Дьялог АПЛ , 51 байт

Один индексированные.

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

{ функция, где ⍵ представляет аргумент

⍵⊃{ использовать аргумент, чтобы выбрать из результата функции

⍵/⍨{ отфильтровать аргумент с результатом функции

(⍵≤9)∨ аргумент меньше или равен 9, ИЛИ

(1<≢c~'0')∧ при удалении нулей остается более одной цифры

1≥+/ 0 или 1 это сумма

2| странности

+⌿ суммы столбца

c∘.=∪cтаблица сравнения c и уникальные элементы c , где c ...

←⍕⍵ является строковым представлением аргумента

}¨⍵ применяется к каждому из аргументов

}⍳5×⍵ применяется к {1, 2, 3, ..., 5 раз аргументу}

} [конец функции]

Мгновенно завершает все тесты на TryAPL

JavaScript (ES6), 92

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

Меньше гольфа

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

Тестовое задание

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 (с использованием внешней библиотеки - Enumerable) (142 байта)

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

Ссылка на lib: https://github.com/mvegh1/Enumerable/

Объяснение кода: _.Sequence создает перечислимое число для «n» элементов на основе предиката подписи («i» , «a», накопленный массив ). Приведите текущую итерацию к строке и создайте из нее список всех перестановок. Проверьте, удовлетворяет ли какая-либо из перестановок тесту, не начинающемуся с «0», и что перестановка перестановки равна перестановке. Вернуть последний элемент в последовательности, потому что это желаемый результат согласно OP

Python 2, 93 байта

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-индексироваться. В зависимости от вашей системы последний контрольный пример может превышать допустимую глубину рекурсии.

Не вычисляет перестановки. Вместо этого используется тот факт, что две строки являются перестановками, если они равны при сортировке. Чтобы проверить, является ли число пермутапалиндромным, проверяется, совпадают ли его отсортированные цифры с отсортированными цифрами любого палиндрома до границы.

96 байт:

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-индексироваться. В зависимости от вашей системы последний контрольный пример может превышать допустимую глубину рекурсии.

Это не смотрит на перестановки и вместо этого использует следующую характеристику:

Число является пермутапалиндромным именно тогда, когда

• Максимум одна из его цифр появляется нечетное число раз, и
• Он не имеет формы d00 ... 00 с одним или несколькими нулями.

Это верно, потому что палиндром должен спаривать цифры от начала и до конца, за исключением возможной центральной цифры. Исключением является требование, чтобы начальная цифра была ненулевой, и поэтому некоторая ненулевая цифра должна появляться дважды, если только число не однозначное.

Haskell, 89 87 байт

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

C 254 байта

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