Основанные палиндромы

Question

Палиндромное число, в качестве напоминания, - это любое число, которое читается так же, как вперед и назад. А как насчет палиндромов на других базах?

Ввод

Любое целое число bгде b > 1.

Вывод

Все целые числа с основанием 10 от 0 до 1000 включительно, которые являются палиндромами с основанием b. Результатом может быть список целых чисел или целых чисел, разделенных разделителем, например запятой или новой строкой.

Тестовые примеры

Input->Output

10->{0,1,2,3,4,5,6,7,8,9,11,22,33,44,55,66,77,88,99,101,111,121,131,141,151,161,171,181,191,202,212,222,232,242,252,262,272,282,292,303,313,323,333,343,353,363,373,383,393,404,414,424,434,444,454,464,474,484,494,505,515,525,535,545,555,565,575,585,595,606,616,626,636,646,656,666,676,686,696,707,717,727,737,747,757,767,777,787,797,808,818,828,838,848,858,868,878,888,898,909,919,929,939,949,959,969,979,989,999}

2->{0,1,3,5,7,9,15,17,21,27,31,33,45,51,63,65,73,85,93,99,107,119,127,129,153,165,189,195,219,231,255,257,273,297,313,325,341,365,381,387,403,427,443,455,471,495,511,513,561,585,633,645,693,717,765,771,819,843,891,903,951,975}

9->{0,1,2,3,4,5,6,7,8,10,20,30,40,50,60,70,80,82,91,100,109,118,127,136,145,154,164,173,182,191,200,209,218,227,236,246,255,264,273,282,291,300,309,318,328,337,346,355,364,373,382,391,400,410,419,428,437,446,455,464,473,482,492,501,510,519,528,537,546,555,564,574,583,592,601,610,619,628,637,646,656,665,674,683,692,701,710,719,728,730,820,910,1000}

Answer 1

Python 3 , 78 байт

Выводит числа в убывающем порядке 1000 -> 0и закорачивает сZeroDivisionError

def f(b,n=1000):
 r=0;m=n
 while m:r=r*b+m%b;m//=b
 n==r==print(n);f(b,n-n//n)

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

В f(b,n-n//n) -> f(b,n-1)рекурсивно до 0и ошибок , потому что деление на ноль не определено.

Python 3 , 76 байт

Мы можем сократить ответ на 2 байта, если разрешен вывод с плавающей запятой.

def f(b,n=1e3):
 r=0;m=n
 while m:r=r*b+m%b;m//=b
 n==r==print(n);f(b,n-n/n)

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

Answer 2

C (gcc) вперед, 118 117 115 байт

b[11],*p,*x,i,m;f(n){for(i=-1;i++<1e3;){for(p=x=b,m=i;m;*p++=m%n,m/=n);while(p>x)m|=*--p-*x++;m||printf("%d,",i);}}

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

C (gcc) , назад, 115 113 байт

b[11],*p,*x,i,m;f(n){for(i=1001;i--;){for(p=x=b,m=i;m;*p++=m%n,m/=n);while(p>x)m|=*--p-*x++;m||printf("%d,",i);}}

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

Объяснение

Подпись C:

// Technically implicit int with a void return
void f(int base);

Перебирает все числа от 0 до 1000, baseвручную конвертирует их в базу , затем проверяет, является ли это палиндромом.

Обратная версия делает то же самое, но наоборот.

Печатает совпадающие числа, разделенные запятыми, в стандартный вывод.

Безголовая версия

#include <stdio.h>
// A buffer to hold our converted integer.
// It is large enough for 1000 in binary.
int buffer[11];
// Start and end pointers for buffer
int *start, *end;
// Loop counter
int i;
// Temporary
int tmp;

void f(int base)
{
    // Loop for 0 to 1000
#ifdef BACKWARDS
    // Loop backwards
    for (i = 1001; i-- != 0;) {
#else
    // Loop forwards
    // for (i = 0; i <= 1000; i++)
    for (i = -1; i++ < 1e3; ) {
#endif
        // Convert to base in buffer, tracking the length in end.
        for(start = end = buffer, tmp = i; tmp != 0;) {
            *end++ = tmp % base;
            tmp /= base;
        }

        // Check if it is a palindrome.
        // Loop while our starting pointer is less than our ending pointer.
        // tmp will zero at the start thanks to the loop condition.
        while (end > start)
            // Assembly style comparison using subtraction.
            // If *end == *start, tmp will still be zero.
            // If not, it will be permanently set to non-zero with a binary or.
            tmp |= *--end - *start++;
        // If tmp is still zero (meaning it is a palindrome), print.
        tmp || printf("%d,", i);
    }
}

Спасибо Арно за -1 байт!

Спасибо Тоби Спейту за -2 байта!

Answer 3

05AB1E , 7 байт

₄ÝʒIвÂQ

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

Объяснил

₄Ý	"Push the range [0, 1000]"\
  ʒ	"and keep the items where:"\
   Iв	"After being converted to base (input)"\
     ÂQ	"have its reverse equal to itself"\

Answer 4

Желе , 7 байт

ȷŻbŒḂ¥Ƈ

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

Как это устроено

ȷŻbŒḂ¥Ƈ - Main link. Takes a base b on the left
ȷ       - 1000
 Ż      - [0, 1, 2, ..., 1000]
     ¥  - Group the previous 2 links into a dyad f(k, b):
  b     -   Convert k to base b
   ŒḂ   -   Is this a palindrome?
      Ƈ - Filter [0, 1, 2, ..., 1000], keeping those k that are true under f(k, b)

Answer 5

Japt , 11 байт

A³ô fÈìU êê

Попробуй это

Answer 6

Язык Wolfram Language (Mathematica) , 44 байта

Pick[r=0~Range~1000,r-r~IntegerReverse~#,0]&

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

-13 байт от @att

Answer 7

JavaScript (ES6),  87  86 байт

Возвращает строку, разделенную запятыми.

n=>(g=k=>--k&&g(k)+((h=k=>a=k?[k%n,...h(k/n|0)]:[])(k)+''==a.reverse()?[,k]:''))(1001)

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

Как?

n => (                        // n = input base
  g = k =>                    // g is a recursive function taking a counter k
    --k &&                    //   decrement k; abort if it's equal to 0
    g(k) + (                  //   otherwise do a recursive call and append the ...
      ( h = k =>              //   ... result of the recursive function h
        a = k ?               //     which builds an array a[]
          [ k % n,            //     consisting of each digit of k in base n,
            ...h(k / n | 0) ] //     dividing k by n and taking the integer part
        :                     //     for the next iteration until k = 0
          []                  //
      )(k) + ''               //   invoke h with k and coerce the result to a string
      == a.reverse() ?        //   if this is palindromic:
        [, k]                 //     append a comma followed by k to the output
      :                       //   else:
        ''                    //     just append an empty string
    )                         //
)(1001)                       // initial call to g with k = 1001

Answer 8

Scala , 62 87 байт

• Исправлено после того, как Сиу Чинг Понг -Асука Кенджи- указал, BigIntчто toStringработает только для баз до 36.
• Сохранен 1 байт благодаря @cubic lettuce .

b=>0 to 1000 filter{x=>val y=Seq.unfold(x){q=>Option.when(q>0)(q%b,q/b)};y==y.reverse}

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

Это довольно просто. Он делает диапазон от 0 до 1000, затем фильтрует, проверяя, равны ли они их реверсе в базе b. Чтобы преобразовать в базу b(в виде строки), BigInt«s toStringметод является использовался, но теперь Seq.unfoldиспользуется для создания Seqцифр.

Answer 9

Шелуха , 12 11 байт

Изменить: -1 байт благодаря LegionMammal978

foS=↔B⁰ŀdḋ9

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

Фактический код «основанного палиндрома» составляет 7 байтов ( foS=↔B⁰), но указание 0 ... 1000 стоит на 5 4 (благодаря LegionMammal978) больше байтов.
Мы могли бы сэкономить байт, если можно будет вывести еще несколько базируемых палиндромов со значениями до десятичных 1024 ( foS=↔B⁰ŀ□32).

f               # output the truthy values of
       ŀdḋ9     # series from zero up to one less than 1001
                # (decimal interpretation of binary digits of '9')
 o              # based on combination of 2 functions:
  S=↔           # 1. is it equal to reverse of itself?
     B⁰         # 2. digits in base given by argument

Answer 10

Уголь , 14 байт

ＮθＩΦ⊕φ⁼↨ιθ⮌↨ιθ

Попробуйте онлайн! Ссылка на подробную версию кода. Пояснение:

Ｎθ              Input the base `b`
     φ          Predefined variable 1000
    ⊕           Incremented
   Φ            Filter on implicit range
        ι       Current value
       ↨ θ      Converted to base `b`
      ⁼         Equals
            ι   Current value
           ↨ θ  Converted to base `b`
          ⮌     Reversed
  Ｉ             Cast to string
                Implicitly print

Answer 11

Haskell , 63 байта

f b|let 0%m=m;n%m=div n b%(m*b+mod n b)=[n|n<-[0..1000],n==n%0]

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

Основываясь на хорошей идее из ответа Python dingledooper : чтобы проверить, что nэто базовый bпалиндром, не генерируйте список базовых bцифр, а наоборот, nкак базовое bчисло, запустив базовое преобразование, считывающее цифры с конца, и убедитесь, что результат по-прежнему равен n.

Код |let 0%m=m;n%m=div n b%(m*b+mod n b)рекурсивно определяет инфиксную функцию, %которая меняет основание n(заданное 0как начальный второй аргумент). Определение его внутри letсторожа позволяет нам получить доступ к аргументу bосновной функции, тогда как автономная функция должна будет передавать его при каждом рекурсивном вызове.

Answer 12

APL (расширенный Dyalog) , 17 15 байт

Спасибо Razetime за -2 байта!
Исправлена ​​ошибка, спасибо Siu Ching Pong !

Требуется источник индекса 0.

⍸⎕(⊤≡∘⌽⊤)¨⍳1001

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

                 ⍝ tradfn taking the base as input
          ⍳1001  ⍝ the indices up to 1000
 ⍵(     )¨       ⍝ apply a function to each index as a right argument and the input base as a left argument:
      ⌽⊤         ⍝  the reverse of the index converted to the input base 
    ≡            ⍝  does it match 
   ⊤             ⍝  the index converted to the input base
⍸                ⍝ all truthy indices

Answer 13

C - 76 байт

i=1001,a,z;f(b){for(;i--;i-z||printf("%d ",i))for(a=i,z=0;a;a/=b)z=z*b+a%b;}

Объяснение

Достаточно отличается от моего предыдущего ответа на отдельную публикацию ордера. На этот раз мы полностью меняем номер, а затем сравниваем его с исходным. Таким образом, нам не нужно исключать нули в конце или особый случай 0.

void fun(int b)
{
    for (int i = 1001; i--;) {
        int z = 0;
        for (int a = i; a != 0; a /= b) {
            z = z*b + a%b;
        }
        if (i==z) {
            printf("%d ",i);
        }
    }
}

Этот метод надежно работает iдо INT_MAX/bи bдо INT_MAXили соответствующих эквивалентов, если мы изменим используемый целочисленный тип. Для беззнаковых типов (или с gcc -fwrapv) он должен работать для всего диапазона i.

Answer 14

C, 100 байт

i=1001,a,z;f(b){for(;--i;)for(a=i,z=0;i%b*a;a/=b)if(a==z||a==(z=z*b+a%b))printf("%d ",i);puts("0");}

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

Код без присмотра

void fun(int b)
{
    for (int i = 1001; --i;) {
        if (i%b) {              /* no leading/trailing zeros */
            for (int a = i, z = 0; a != 0; a /= b) {
                if (a==z) {
                    printf("%d ",i);
                }
                z = z*b + a%b;
                if (a==z) {
                    printf("%d ",i);
                }
            }
        }
    }
    puts("0");
}

Объяснение

Это выводит сначала самые высокие числа, поскольку не был указан конкретный порядок. Для каждого номера кандидата мы уменьшаем его (as a) путем последовательного деления на основание, используя остаток для построения обратного числа (in z). Если aстановится равным z, то мы имеем палиндром. Обычно мы останавливаемся на этом ( a >= zв условии цикла), но для игры в гольф мы продолжаем до конца a==0.

Нам нужно проверить равенство как до, так и после переноса остатка в z, чтобы принять палиндромы как нечетной, так и четной длины.

Наконец, мы печатаем 0, что всегда является палиндромом, и его проще в частном случае, чем включать в цикл.

Метод работает для целых чисел вплоть до того, INT_MAXесли мы отменим условие i%b*aобратно i%b&&a, а также будет работать для других целочисленных типов.

Answer 15

K (ngn / k) , 18 байт

{&{x~|x}'x\'!1001}

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

• x\'!1001 преобразовать каждое из 0..1000 в представление base-x
• {x~|x}' проверьте, является ли каждое представление палиндромом
• & получить индексы истин

Answer 16

Python 3.8 (предварительная версия) , 92 85 байт

lambda b:[i for i in range(1001)if(f:=lambda n:n*[0]and[n%b]+f(n//b))(i)==f(i)[::-1]]

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

Спасибо dingledooper за сохранение 7 байт!

Answer 17

Haskell, 67 байт

b&n=take n$mod n b:b&div n b
f b=[n|n<-[0..1000],reverse(b&n)==b&n]

f- интересующая функция. Попробуйте онлайн!

Возможно, единственный умный момент здесь - это использование take nв качестве базового случая для функции расширения цифр. Когда n=0, take nигнорирует свой аргумент, и поэтому рекурсия останавливается из-за лени; когда n>0, конечно, не будет больше nцифр, поэтому безопасно оставить только первую n. Следующее определение эквивалентно (и одинаково длинно):

b&0=[]
b&n=mod n b:b&div n b

... но take nверсия более интересная, потому что она более запутанная. ^ _ ^

Answer 18

J , 27 байт

((-:|.)@(#.inv)"0#])i.@1001

Как

• (...) i.@1001 - Все это представляет собой крючок J, что означает, что аргумент будет левым аргументом для всего в скобках, а правый аргумент будет целыми числами от 0 до 1000: i.@1001
• ...#]Фраза в скобках использует copy #для фильтрации правого аргумента ]по булевой маске, полученной из фразы слева от #:
• (-:|.)@(#.inv)"0- Ранг 0 "0гарантирует, что фраза применима к каждому отдельному номеру правильного аргумента. Сама фраза сначала преобразует каждое из этих чисел в список цифр в базе, заданной левым аргументом (#.inv), а затем проверяет, равен ли этот список его обратной стороне (-:|.)@. Таким образом, вся фраза вернет 1, когда это истинно, и 0 в противном случае, и эта логическая маска будет фильтровать правильный аргумент по желанию.

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

Answer 19

Ruby 2.7 , 74 байта

->b{(0..1e3).select{(a=(g=->k,r=[]{k>0?g[k/b,r<<k%b]:r})[_1])==a.reverse}}

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

TIO использует старую версию Ruby, тогда как в Ruby 2.7 мы пронумеровали параметры, что позволяет сэкономить два байта.

---

Рубин , 48 байт

->b{(0..1e3).select{|k|(k=k.to_s b)==k.reverse}}

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

Не работает для баз старше 64 из-за ограничений в .to_sметоде.

Answer 20

JavaScript (V8) , 77 89 байт

Исправлено для баз больше 36.

b=>{for(i=-1;i<1e3;){j=[],k=++i;while(k|=0)j.push(k%b),k/=b;''+j==j.reverse()&&print(i)}}

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

Answer 21

PowerShell , 102 100 98 95 87 75 байт

-14 байт благодаря mazzy!

param($u)0..1e3|?{for($b=@();$_=($_-($b+=$_%$u)[-1])/$u){}"$b"-eq$b[11..0]}

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

Answer 22

R , 82 81 байт

(или 79 байт с использованием довольно сложного разделителя " \n[1] ")

Изменить: -1 байт благодаря caird coinheringaahing

function(b)for(i in 0:1e3)if(!i||all((a=i%/%b^(0:log(i,b))%%b)==rev(a)))cat(i,'')

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

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

function(b)
 for(i in 0:1000)               # loop i through zero to 1000
  if(!i                         # if i is zero (always a palindrome),
   ||                           # or
   all(                         # if all the digits of
    (a=i%/%b^(0:log(i,b))%%b)   # a = the representation of i in base b
    ==rev(a))                   # are the same as themselves reversed
  )cat(i,'')                    # output this i

Answer 23

jq , 66 байт

. as$a|range(1001)|select([while(.>0;./$a|floor)|.%$a]|reverse==.)

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

Объяснение

. as $a |                # Assign the input to $a. range(1001) | # For every item in [0..1000]: select ( # Filter out all items where: [ while(. > 0; # The list of quotients from repeatedly . / $a | floor)     #     short-dividing by $a |. % $a]           #     And then modulo-ing by $a
  | reverse == .)        # is equal to its reverse
```

Answer 24

Pyth , 11 байт

f_IjTQUh^T3

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

---

f_IjTQUh^T3 | Explanation
------------+---------------------------------------
f           | filter
      Uh^T3 | the range [0, 1001)
   jTQ      | on whether each number in base <input>
 _I         | equals itself reversed

Answer 25

Java 10, 118 байт

b->{for(int i=-1;i++<1e3;){var s=b.toString(i,b);if(s.contains(new StringBuffer(s).reverse()))System.out.println(i);}}

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

Пояснение:

b->{                           // Method with Integer parameter and no return-type
  for(int i=-1;i++<1e3;){      //  Loop `i` in the range [0,1000]:
    var s=b.toString(i,b);     //   Convert `i` to base-`b` as String
    if(s.contains(new StringBuffer(s).reverse()))
                               //   If this String is a palindrome:
      System.out.println(i);}} //    Print `i` with trailing newline