Dato un numero intero, genera un valore di verità se è lo stesso sottosopra (ruotato di 180 °) o un valore di falsa in caso contrario.

0, 1e 8hanno simmetria rotazionale. 6diventa 9e viceversa.

Sequenza di numeri che producono risultati veritieri: 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, ...

Questa domanda si ispira la mia reputazione, al momento del distacco: 6009.

05AB1E , 22 16 15 14 byte

Codice:

Â23457ð«-69‡Q

Provalo online!

Codice precedente:

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

Per capire se la stringa è simmetrica rotazionale, abbiamo solo bisogno di traslitterare 69con 96, invertire la stringa e verificare se sono uguali. L'altra cosa che dobbiamo sapere è se il numero unico contenga le cifre 0, 1, 8, 6e 9. Quindi è esattamente quello che faremo:

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

La „vd•parte converte effettivamente la stringa vddalla base 190 alla base 10 . Puoi provarlo qui .

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

Utilizza la codifica CP-1252 . Provalo online!

Python 2, 50 byte

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

Il metodo '01xxxx9x86'.findprende un carattere cifra per il suo numero capovolto, con qualsiasi cifra inarrestabile che dà -1. Questa funzione è mappata sulla stringa numerica inversa, producendo un elenco di cifre.

Questo è convertito in una stringa con il [1::3]trucco , tranne che è invece invertito facendo [-2::-3](grazie a Dennis per questo, salvando 4 byte), e rispetto alla stringa numerica originale. Qualunque -1cifra non digitabile disallineerà la conversione, facendola fallire.

56 byte:

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

Verifica se la stringa numerica invertita è uguale a quella con le sostituzioni capovolte. Le cifre che non possono essere capovolte vengono sostituite con 'x'per dare sempre la risposta sbagliata.

La sostituzione avviene con translateuna stringa di 256 caratteri, sostituendo i corrispondenti valori ASCII. Solo i 10 valori 48per 57la materia, ma ho imbottiti di lunghezza 16 per rendere la lunghezza totale sia 256. Mi chiedo se c'è un modo più breve.

Alcuni altri approcci (lunghezze 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]))

Rubino, 54 46 byte

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

Non lo so, sono consentite o meno funzioni anonime come quelle

Praticamente la stessa idea della risposta Python2. Se l'input non è intero, agire in modo errato (ovvero abarestituisce true)

JavaScript (ES6), 56 byte

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

Perl, 29 26 byte

Include +1 per -p

Esegui con l'input su STDIN:

rotation.pl <<< 69

rotation.pl:

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

Gelatina, 16 15 byte

,ȷ9+90860¤Dị/⁼Ṛ

Provalo online!

Come funziona

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

8 byte salvati grazie a @Martin Büttner .

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

• Applicare la riduzione in quanto tale: 1610880191-> 61088019-> 108801-> 0880-> 88-> (vuoto).
• Restituisce 1se solo 0, 1, 8, o (vuoto) è a sinistra.
• Restituisce 0altrimenti.

Provalo online!

sh, 40 33 byte

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

Input tramite argomento da riga di comando, output tramite codice di uscita. Genera tutti i test:

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

TSQL, 122 byte

Sono nuovo nel campo del golf, quindi non sono sicuro di come contare i personaggi. Contandolo come 1 qui poiché il numero utilizzato in questo caso è 8

Ciò restituirà 1 quando il valore inverso corrisponde e nulla quando non corrisponde:

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

Leggibile dagli umani:

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 byte

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

Provalo online!

Spiegazione

Questo utilizza un approccio completamente diverso dall'altra risposta Retina. Invece di rimuovere tutte le parti simmetriche, semplicemente eseguire la trasformazione di invertire la stringa e scambiando 6e 9s e quindi confrontare l'uguaglianza. Per assicurarci che non compaiano cifre non simmetriche, le trasformiamo anche in 9s a metà.

$
;$_

Dupliciamo l'input abbinando la fine della stringa e inserendo ;seguito da tutto l'input.

T`92-7`69`;.+

Ciò esegue una traslitterazione di caratteri solo nella seconda metà abbinandola a ;.+. I due set di traslitterazione si espandono in:

9234567
6999999

Perché 2-7indica un intervallo e il set target è riempito con l'ultimo carattere per corrispondere alla lunghezza del set sorgente. Quindi, il palcoscenico si scambia 6e 9trasforma anche tutto 23457in 9s.

+`(.);\1
;

Ripetutamente ( +) rimuovi una coppia di caratteri identici attorno a ;. Ciò continuerà fino a quando rimarrà solo il carattere ;o finché i due caratteri attorno a ;non saranno più identici, il che significherebbe che le stringhe non sono inverse l'una rispetto all'altra.

^;

Controlla se il primo carattere è ;e stampa 0o di 1conseguenza.

Pyth - 21 byte

&!-z+`180K`69qzX_z_KK

Test Suite .

Pyth, 17 byte

!-FmC_B`d,QC\􄽥

Provatelo in Pyth compilatore .

Come funziona

!-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, Applications Edition, 150 111 byte

Utilizzabile in console o come UDF.

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

Migliorato sfruttando le conversioni di tipo implicite e facendo tre passaggi di scambio anziché due passaggi su ciascun lato dell'equazione. Il conteggio include Functione End Functiondichiarazioni.

GNU sed, 84 byte

(incluso +1 per la -rbandiera)

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

Se la linea termina con una rotazione del carattere iniziale, taglia entrambe le estremità di una. Ripeti fino a quando non c'è corrispondenza. Tieni conto di un singolo carattere simmetrico, quindi se qualcosa rimane, l'input non era simmetrico e restituiamo false; altrimenti restituisce vero.

C, 82 byte

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

allargato

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

Spiegazione

Invertiamo le cifre xdell'uso dell'aritmetica modulo-10, sostituendo 6 e 9 con le loro riflessioni mentre procediamo. Sostituiamo le cifre asimmetriche di rotazione con zeri (nota che possiamo gestire cinque e simmetrici simmetrici semplicemente cambiando la tabella di sostituzione s). Se il nuovo numero è uguale all'originale (salvato in 'z'), allora è simmetrico in senso rotazionale.

Programma di test

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

Questo stampa l'elenco dei numeri simmetrici indicati nella domanda.

MATL, 25 21 22 byte

j69801VmAGtP69VtPXE=vA

Provalo online!

Spiegazione

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

Scherzi a parte, 23 byte

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

Provalo online!

Questa è essenzialmente una porta della soluzione Python 2 di xnor .

Spiegazione:

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

Questo prende il numero, lo converte in una stringa, lo ruota e quindi lo confronta con l'originale come una stringa per l'uguaglianza. Le cifre non ruotabili vengono semplicemente convertite in0

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

Provalo qui!