Если задано целое число, выведите истинное значение, если оно совпадает с перевернутым (повернутым на 180 °) или неверным значением в противном случае.

0, 1И 8имеет осевую симметрию. 6становится 9и наоборот.

Последовательность чисел, дающая достоверные результаты: OEIS A000787

0, 1, 8, 11, 69, 88, 96, 101, 111, 181, 609, 619, 689, 808, 818, 888, 906, 916, 986, 1001, 1111, 1691, 1881, 1961, 6009, 6119, 6699, 6889, 6969, 8008, 8118, 8698, 8888, 8968, 9006, 9116, 9696, 9886, 9966, 10001, 10101, 10801, 11011, 11111, 11811, 16091, ...

Этот вопрос вдохновлен моей собственной репутации на момент размещения: 6009.

05AB1E , 22 16 15 14 байтов

Код:

Â23457ð«-69‡Q

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

Предыдущий код:

Â69‡Q¹¹„vd•ÃQ*

Для того, чтобы выяснить , является ли строка вращательной симметрии, мы просто должны транслитерациям 69с 96, обратной строкой и проверить , если они равны. Другая вещь , которую мы должны знать, если номер только содержит цифры 0, 1, 8, 6и 9. Это именно то, что мы собираемся сделать:

                     # Bifurcate the input, which pushes input and input[::-1]
 69Â                  # Bifurcate 69, which pushes 69 and 96.
    ‡                 # Transliterate 69 with 96 in the input, e.g. 1299 becomes 1266.
     Q                # Check for equality.
      ¹¹              # Push input again twice.
        „vd•          # Compressed version for 10869.

„vd•Часть фактически преобразует строку vdиз базы 190 к основанию 10 . Вы можете попробовать это здесь .

            Ã        # Keep the characters of the second string in the first string.
                       667788 would become 6688 (since 7 is not in 10869).
             Q       # Check for equality.
              *      # Multiply the top two numbers, which actually does an AND function.

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

Python 2, 50 байт

lambda n:`n`==`map('01xxxx9x86'.find,`n`)`[-2::-3]

Метод '01xxxx9x86'.findпереводит цифру в перевернутую цифру с любой необъяснимой цифрой -1. Эта функция отображается на строку с обратными номерами, создавая список цифр.

Это преобразуется в строку с [1::3]уловкой , за исключением того, что вместо этого она переворачивается [-2::-3](спасибо Деннису за это, экономя 4 байта) и сравнивается с исходной числовой строкой. Любые -1из нечитаемых цифр сместят преобразование, что приведет к сбою.

56 байтов:

lambda n:`n`[::-1]==`n`.translate('01xxxx9x86______'*16)

Проверяет, совпадает ли измененная числовая строка с перевернутыми заменами. Цифры, которые нельзя перевернуть, заменяются на, 'x'чтобы всегда давать неправильный ответ.

Замена выполняется translateна строке из 256 символов, заменяя соответствующие значения ASCII. Только 10 значений 48к 57материи, но я проложенный до длины 16 , чтобы общая длина будет 256. Я интересно , если есть более короткий путь.

Некоторые другие подходы (длина 59, 60, 60):

lambda n:set(zip(`n`,`n`[::-1]))<=set(zip('01896','01869'))
r=lambda s:set(zip(s,s[::-1]));lambda n:r(`n`)<=r('9018106')
lambda n:all(a+b in'001188969'for a,b in zip(`n`,`n`[::-1]))

Рубин, 54 46 байт

 ->a{(b=a.to_s).tr('1-9','1w-z9x86').reverse==b}

Я не знаю, разрешены или нет анонимные функции

В основном та же идея, что и в Python2. Если ввод не целочисленный, действуйте плохо (т.е. abaдает true)

JavaScript (ES6), 56 байт

n=>n==[...''+n].reverse().map(c=>'0100009086'[c]).join``

Perl, 29 26 байт

Включает +1 для -p

Запустите с помощью ввода на STDIN:

rotation.pl <<< 69

rotation.pl:

#!/usr/bin/perl -p
$_=reverse==y/962-7/69a/r

Желе, 16 15 байт

,ȷ9+90860¤Dị/⁼Ṛ

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

Как это работает

,ȷ9+90860¤Dị/⁼Ṛ  Main link. Argument: n (integer)

         ¤       Evaluate the three links to the left as a niladic chain:
 ȷ9              Yield 1000000000.
    90860        Yield 90860.
   +             Add to yield 1000090860.
,                Pair; yield [n, 1000090860].
          D      Convert both integers to base 10.
           ị/    Reduce by index, i.e., for each digit of n, retrieve the element
                 of [1, 0, 0, 0, 0, 9, 0, 8, 6, 0] at that index (1-based).
              Ṛ  Yield the digits of n in reversed order.
             ⁼   Test for equality.

Сетчатка, 57 49 байт

8 байтов сохранено благодаря @Martin Büttner .

+`^(([018])(.*)\2|9(.*)6|6(.*)9)$
$3$4$5
^[018]?$

• Примените сокращение как таковое: 1610880191-> 61088019-> 108801->0880 -> 88-> (пусто).
• Возвращает , 1если только 0,1 , 8или (пустой) остались.
• Возвращает в 0противном случае.

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

ш, 40 33 байта

[ `rev<<<$1|tr 6923457 96` = $1 ]

Ввод через аргумент командной строки, вывод через код выхода. Генерация всех тестовых случаев:

for i in `seq 0 10000`
do
  if [ `rev<<<$i|tr 6923457 96` = $i ]
  then
    echo $i
  fi
done

TSQL, 122 байта

Я новичок в коде гольфа, поэтому не совсем уверен, как считать персонажей. Здесь он считается как 1, поскольку число, используемое в этом случае, равно 8

Это вернет 1, когда обратное значение совпадает, и ничего, если оно не совпадает:

SELECT 1FROM(values(8))x(x)WHERE(x)NOT like'%[23457]%'and REPLACE(REPLACE(x,6,4),9,6)=REVERSE(REPLACE(REPLACE(x,9,4),9,6))

Человек читаемый:

SELECT 1
FROM
  (values(808))x(x)
WHERE(x)
  NOT like'%[23457]%'
  and REPLACE(REPLACE(x,6,4),9,6)=REVERSE(REPLACE(REPLACE(x,9,4),9,6))

Сетчатка , 40 38 33 байта

$
;$_
T`92-7`69`;.+
+`(.);\1
;
^;

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

объяснение

Это использует совершенно другой подход от другого ответа Retina. Вместо удаления всех симметричных частей, мы просто выполняем преобразование реверсирования строки и замены 6и 9s, а затем сравниваем на равенство. Чтобы убедиться, что несимметричные цифры не появляются, мы также превращаем их в 9s в половине.

$
;$_

Мы дублируем ввод, сопоставляя конец строки и вставляя ;после него весь ввод.

T`92-7`69`;.+

Это выполняет транслитерацию символов только во второй половине, сопоставляя ее с ;.+. Два набора транслитерации расширяются до:

9234567
6999999

Потому что 2-7обозначает диапазон, а целевой набор дополняется последним символом, чтобы соответствовать длине исходного набора. Следовательно, сцена меняет 6и 9тоже превращает все 23457в 9s.

+`(.);\1
;

Повторно ( +) удалить пару одинаковых символов вокруг ;. Это будет продолжаться до тех пор, пока ;не останется только символ или, пока два символа вокруг ;не перестанут совпадать, что будет означать, что строки не противоположны друг другу.

^;

Проверьте, есть ли первый символ ;и напечатайте 0или 1соответственно.

Pyth - 21 байт

&!-z+`180K`69qzX_z_KK

Тестовый пакет .

Pyth, 17 байт

!-FmC_B`d,QC\􄽥

Проверьте это в компиляторе Pyth .

Как это работает

!-FmC_B`d,QC\􄽥  (implicit) Store the input in Q.

            \􄽥  Yield the Unicode character with code point 1068901.
           C    Compute its code point.
         ,Q     Pair the input and 1068901.
   m            Map; for each d in [Q, 1068901]:
       `d         Yield the string representation of d.
     _B           Yield the pair of `d` and `d` reversed.
    C             Zip. For the second string, this gives
                  ['11', '00', '69', '88', '96', '00', '11'].
 -F             Fold by difference, i.e., removes all pairs in the second list
                from the first list.
!               Logically negate the result, returning True iff the list is empty.

Visual Basic для приложений, 150 111 байтов

Используется в консоли или как UDF.

Function c(b)
c=(Not b Like"*[!01869]*")And b=Replace(Replace(Replace(StrReverse(b),9,7),6,9),7,6)
End Function

Улучшено за счет использования неявных преобразований типов и выполнения трех шагов обмена вместо двух шагов с каждой стороны уравнения. Граф включает в себя Functionи End Functionзаявления.

GNU sed, 84 байта

(включая +1 за -rфлаг)

:
s/^6(.*)9$/\1/
s/^9(.*)6$/\1/
s/^([081])(.*)\1$/\2/
t
s/^[081]$//
s/.+/0/
s/^$/1/

Если строка заканчивается вращением ее начального символа, обрежьте оба конца на один. Повторяйте, пока нет совпадения. Учитывайте один симметричный символ, тогда, если что-то останется, входные данные не были симметричными, и мы возвращаем false; в противном случае верните истину.

C, 82 байта

char*s="0100009086";f(x){int y=0,z=x;for(;x;x/=10)y=y*10+s[x%10]-'0';return z==y;}

расширенный

char *s = "0100009086";
int f(int x)
{
    int y=0, z=x;
    for(; x; x/=10)
        y = y*10 + s[x%10]-'0';
    return z==y;
}

объяснение

Мы меняем цифры xиспользования арифметики по модулю-10, заменяя 6 и 9 их отражениями по мере продвижения. Мы заменяем вращательно-асимметричные цифры нулями (обратите внимание, что мы можем обрабатывать симметричные пятерки и / или двойки, просто меняя таблицу заменыs ). Если новое число равно оригиналу (сохранено в «z»), то оно является вращательно-симметричным.

Тестовая программа

#include <stdio.h>
int main()
{
    int i;
    for(i=0;  i <= 16091; ++i)
        if (f(i))
            printf("%d\n", i);
}

Это печатает список симметричных чисел, приведенных в вопросе.

MATL, 25 21 22 байта

j69801VmAGtP69VtPXE=vA

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

объяснение

j       % Explicitly grab input as string
69801   % Number literal
V       % Convert to a string
mA      % Check if all input chars are members of this list
G       % Explicitly grab the input
tP      % Duplicate and flip it
69      % Number literal
V       % Convert to string ('69')
tP      % Duplicate and flip it ('96')
XE      % Replace all '6' with '9', and '9' with '6'
=       % Check that this substituted string is equal to the original
v       % Vertically concatenate all items on the stack
A       % Ensure everything is true
        % Implicitly print boolean result

Серьезно, 23 байта

,$;`"01xxxx9x86"í`MRεj=

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

По сути это порт решения xnor Python 2 .

Объяснение:

,$;`"01xxxx9x86"í`MRεj=
,$;                      push two copies of str(input)
   `"01xxxx9x86"í`M      map: get each digit's rotated digit (or x if not rotatable)
                   Rεj   reverse and join on empty string to make a string
                      =  compare equality with original input

Котлин, 69 байт

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

{i->"$i".map{"0100009086"[it-'0']}.joinToString("").reversed()=="$i"}

Проверьте это здесь!