ได้รับจำนวนเต็มส่งออกtruthyค่าถ้ามันเป็นเช่นเดียวคว่ำลง (หมุน 180 องศา) หรือfalsyคุ้มค่าเป็นอย่างอื่น

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](ขอบคุณ Dennis สำหรับสิ่งนี้การบันทึก 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]))

Ruby, 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อย่างอื่น

ลองออนไลน์!

sh, 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

Test Suite

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/

หากบรรทัดลงท้ายด้วยการหมุนของอักขระเริ่มต้นให้ตัดทั้งสองด้วยที ทำซ้ำจนกว่าจะไม่มีการแข่งขัน บัญชีสำหรับอักขระสมมาตรเดียวจากนั้นหากมีสิ่งใดเหลืออยู่อินพุตจะไม่สมมาตรและเราส่งคืนค่าเท็จ มิฉะนั้นคืนความจริง

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 ด้วยการสะท้อนกลับของพวกเขาในขณะที่เราไป เราแทนที่ตัวเลขการหมุนแบบอสมมาตรด้วยเลขศูนย์ (โปรดทราบว่าเราสามารถจัดการ fives สมมาตรและ / หรือ twos เพียงแค่เปลี่ยนตารางการเปลี่ยน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 วิธีการแก้ปัญหาของงูหลาม

คำอธิบาย:

,$;`"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

Kotlin, 69 ไบต์

สิ่งนี้ใช้ตัวเลขแปลงเป็นสตริงหมุนมันแล้วเปรียบเทียบกับต้นฉบับเป็นสตริงเพื่อความเท่าเทียมกัน ตัวเลขที่ไม่สามารถหมุนได้จะถูกแปลงเป็น0

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

ทดสอบที่นี่!