Geben Sie bei einer Ganzzahl einen Wahrheitswert aus , wenn dieser um 180 ° gedreht ist, oder einen anderen falschen Wert.

0, 1und 8haben Rotationssymmetrie. 6wird 9und umgekehrt.

Folge von Zahlen, die wahrheitsgemäße Ergebnisse liefern: 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, ...

Diese Frage wird von meinem eigenen Ruf bei der Einlieferung inspiriert: 6009.

05AB1E , 22 16 15 14 Bytes

Code:

Â23457ð«-69‡Q

Probieren Sie es online!

Vorheriger Code:

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

Um herauszufinden , ob der String rotationssymmetrisch ist, brauchen wir nur zu transkribieren 69mit 96umgekehrter Zeichenfolge und prüfen , ob sie gleich sind. Das andere , was wir wissen müssen , ist , wenn die Zahl nur die Ziffern enthält 0, 1, 8, 6und 9. Genau das werden wir tun:

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

Der „vd•Teil konvertiert die Zeichenfolge tatsächlich vdvon der Basis 190 zur Basis 10 . Sie können dies ausprobieren hier .

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Python 2, 50 Bytes

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

Die Methode '01xxxx9x86'.findsetzt ein Ziffernzeichen auf die umgedrehte Zahl, wobei jede nicht umdrehbare Ziffer angegeben wird -1. Diese Funktion wird auf die umgekehrte Zahlenfolge abgebildet, wodurch eine Liste von Ziffern erstellt wird.

Dies wird mit dem [1::3]Trick in eine Zeichenfolge konvertiert, mit der Ausnahme, dass dies stattdessen umgekehrt wird [-2::-3](dank Dennis, der 4 Bytes spart) und mit der ursprünglichen Zeichenfolge verglichen wird. Alle -1Zeichen aus nicht umklappbaren Ziffern richten die Konvertierung falsch aus, sodass sie fehlschlägt.

56 Bytes:

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

Überprüft, ob die umgekehrte Zahlenfolge mit den umgekehrten Ersetzungen identisch ist. Ziffern, die nicht gewechselt werden können, werden durch ersetzt, 'x'um immer die falsche Antwort zu geben.

Die Ersetzung erfolgt mit translateeiner Zeichenfolge von 256 Zeichen, wobei die entsprechenden ASCII-Werte ersetzt werden. Es sind nur die 10 Werte 48von 57Bedeutung, aber ich habe auf Länge 16 aufgefüllt, damit die Gesamtlänge 256 beträgt. Ich frage mich, ob es einen kürzeren Weg gibt.

Einige andere Ansätze (Längen 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 Bytes

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

Ich weiß nicht, ist anonymen Funktionen so erlaubt oder nicht

Grundsätzlich gleiche Idee wie Python2 Antwort. Wenn die Eingabe keine Ganzzahl ist, verhalte dich schlecht (dh abaergibt true)

JavaScript (ES6), 56 Byte

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

Perl, 29 26 Bytes

Beinhaltet +1 für -p

Führen Sie mit der Eingabe auf STDIN aus:

rotation.pl <<< 69

rotation.pl:

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

Jelly, 16-15 Bytes

,ȷ9+90860¤Dị/⁼Ṛ

Probieren Sie es online!

Wie es funktioniert

,ȷ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.

Retina, 57 49 Bytes

8 Bytes gespart dank @Martin Büttner .

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

• Reduktion als solche anwenden: 1610880191-> 61088019-> 108801-> 0880-> 88-> (leer).
• Returns , 1wenn nur 0, 1, 8, oder (leer) verlassen wird.
• Kehrt 0sonst zurück.

Probieren Sie es online!

sh, 40 33 Bytes

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

Eingabe über Kommandozeilenargument, Ausgabe über Exit-Code. Generiere alle Testfälle:

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

TSQL, 122 Bytes

Ich bin neu im Codieren von Golf, daher weiß ich nicht genau, wie ich die Zeichen zählen soll. Zählen Sie es hier als 1, da in diesem Fall die Nummer 8 verwendet wird

Dies gibt 1 zurück, wenn der umgekehrte Wert übereinstimmt, und nichts, wenn er nicht übereinstimmt:

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

Für Menschen lesbar:

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

Retina , 40 38 33 Bytes

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

Probieren Sie es online!

Erläuterung

Dies verwendet einen völlig anderen Ansatz als die andere Retina-Antwort. Anstatt alle symmetrischen Teile zu entfernen, führen wir einfach die Transformation durch, indem wir die Zeichenfolge umkehren 6und 9s vertauschen und dann auf Gleichheit vergleichen. Um sicherzustellen, dass keine unsymmetrischen Ziffern angezeigt werden, werden sie auch in 9s in einer Hälfte umgewandelt.

$
;$_

Wir duplizieren die Eingabe, indem wir das Ende der Zeichenfolge abgleichen und ;gefolgt von der gesamten Eingabe einfügen .

T`92-7`69`;.+

Dies führt eine Zeichentransliteration nur in der zweiten Hälfte durch, indem es mit übereinstimmt ;.+. Die beiden Transliterationssätze erweitern sich auf:

9234567
6999999

Denn 2-7bezeichnet einen Bereich und der Zielsatz wird mit dem letzten Zeichen aufgefüllt, um der Länge des Quellensatzes zu entsprechen. Daher wechselt die Bühne 6und 9verwandelt sich auch alle 23457in 9s.

+`(.);\1
;

+Entfernen Sie wiederholt ( ) ein Paar identischer Zeichen um das ;. Dies wird entweder fortgesetzt, bis nur noch das ;übrig ist oder bis die beiden Zeichen um das ;nicht mehr identisch sind, was bedeutet, dass die Zeichenfolgen nicht umgekehrt sind.

^;

Überprüfen Sie, ob das erste Zeichen ;und drucken 0oder 1entsprechend.

Pyth - 21 Bytes

&!-z+`180K`69qzX_z_KK

Test Suite .

Pyth, 17 Bytes

!-FmC_B`d,QC\􄽥

Testen Sie es im Pyth-Compiler .

Wie es funktioniert

!-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 für Applikationen, 150 111 Bytes

In der Konsole oder als UDF verwendbar.

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

Verbessert, indem implizite Typkonvertierungen ausgenutzt werden und drei Schritte anstelle von zwei Schritten auf jeder Seite der Gleichung ausgetauscht werden. Count Includes Functionund End FunctionAnweisungen.

GNU sed, 84 Bytes

(einschließlich +1 für -rFlagge)

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

Wenn die Linie mit einer Drehung des Anfangszeichens endet, kürzen Sie beide Enden um eins. Wiederholen, bis es keine Übereinstimmung mehr gibt. Berücksichtigen Sie ein einzelnes symmetrisches Zeichen. Wenn dann noch etwas übrig ist, war die Eingabe nicht symmetrisch, und wir geben false zurück. Andernfalls geben Sie true zurück.

C 82 Bytes

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

Erweitert

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

Erläuterung

Wir kehren die Ziffern der xModulo-10-Arithmetik um und ersetzen dabei 6 und 9 durch ihre Reflexionen. Wir ersetzen die rotationsasymmetrischen Ziffern durch Nullen (beachten Sie, dass wir symmetrische Fünfer und / oder Zweier behandeln können, indem wir einfach die Ersetzungstabelle ändern s). Wenn die neue Nummer der ursprünglichen entspricht (in 'z' gespeichert), ist sie rotationssymmetrisch.

Testprogramm

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

Dies gibt die Liste der in der Frage angegebenen symmetrischen Zahlen aus.

MATL, 25 21 22 Bytes

j69801VmAGtP69VtPXE=vA

Probieren Sie es online!

Erläuterung

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

Im Ernst, 23 Bytes

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

Probieren Sie es online!

Dies ist im Wesentlichen eine Portierung der Python 2-Lösung von xnor .

Erläuterung:

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

Das nimmt die Zahl, konvertiert sie in eine Zeichenfolge, dreht sie und vergleicht sie dann mit dem Original als Zeichenfolge für Gleichheit. Nicht drehbare Ziffern werden einfach in konvertiert0

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

Teste es hier!