घूर्णी समरूपता वाले अंक

Question

पूर्णांक को देखते हुए, एक सत्य मान का उत्पादन अगर यह एक ही उल्टा (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।

Comments

यह प्रिंट रोटेशन-सुरक्षित नंबरों के एक डुबकी जैसा दिखता है ।

— xnor

@xnor वे एक जैसे नहीं हैं। उस प्रश्न में यह शामिल है कि क्या रोटेशन पर संख्या एक और मान्य संख्या बन जाएगी (और इसे अलग रखने के लिए एक अवधि जोड़ें), न कि क्या यह एक ही संख्या है। मैंने पोस्ट करने से पहले उस सवाल पर गौर किया।

— mbomb007

@ mbomb007 मेरी गलती। मैं फिर से खुल गया।

— xnor

क्या हम इनपुट को एक स्ट्रिंग के रूप में ले सकते हैं?

— xnor

@xnor यदि भाषा में संख्यात्मक प्रकार हैं, तो उन्हें उदाहरण के लिए, फ़ंक्शन मापदंडों के लिए उपयोग करना चाहिए। लेकिन अगर, उदाहरण के लिए, पायथन में, आप लेते हैं raw_input, तो उपयोगकर्ता ने एक पूर्णांक में प्रवेश किया, जो पर्दे के पीछे एक स्ट्रिंग बन जाएगा। कोई बात नहीं।

— mbomb007

Answer 1

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 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Answer 2

अजगर 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'हमेशा गलत उत्तर देने के साथ बदल दिया जाता है।

प्रतिस्थापन translateASCII के संगत मानों की जगह, 256 वर्णों की एक स्ट्रिंग के साथ किया जाता है । केवल 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]))

Comments

शायद यह मदद करेगा: codegolf.stackexchange.com/a/48994/34718

— mbomb007

Answer 3

रूबी, 54 46 बाइट्स

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

मुझे नहीं पता, अनाम कार्य जैसे अनुमति या नहीं

मूल रूप से पायथन 2 उत्तर के समान विचार। यदि इनपुट पूर्णांक नहीं है, तो खराब है (यानी abaदेता है true)

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! अच्छा पहला जवाब: डी बेनामी कार्यों को किसी भी संदर्भ में अनुमति दी जाती है जहां सामान्य नामित कार्यों की अनुमति है।

— बिल्ली

यहां तक ​​कि हमारे मानकों द्वारा एक "फ़ंक्शन" क्या है?

— बिल्ली

Answer 4

जावास्क्रिप्ट (ईएस 6), 56 बाइट्स

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

Comments

सरणी में ... क्या करता है?

— ericw31415

@ ericw31415 इस मामले में यह स्ट्रिंग को वर्णों में बदल देता है। अधिक आम तौर पर, आप कुछ भी चलने योग्य प्रदान कर सकते हैं और यह इसे पुनरावृत्त करेगा और सरणी में तत्वों को शामिल करेगा।

— नील

तो [... '' + n] मूल रूप से n.split ("") जैसी ही चीज है? मैं इस बारे में और कहां पढ़ सकता हूं?

— ericw31415

@ ericw31415 हां, इस मामले में मैं इसे शॉर्टहैंड के रूप में उपयोग करता हूं split``। एक और अधिक शक्तिशाली सरणी शाब्दिक

— नील

Answer 5

पर्ल, 29 26 बाइट्स

के लिए +1 शामिल है -p

STDIN पर इनपुट के साथ चलाएँ:

rotation.pl <<< 69

rotation.pl:

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

Answer 6

जेली, 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.

Comments

यह उत्तर 15 बाइट्स के साथ दूसरे के साथ जुड़ा हुआ है, लेकिन अन्य उत्तर पहले पोस्ट किया गया था। क्या आप 1 बाइट से शेव कर सकते हैं?

— mbomb007

मैंने काफी कोशिश की है; मुझे नहीं लगता कि मैं कर सकता हूँ। हालांकि, हमारे डिफ़ॉल्ट टाई ब्रेकर है जीतने अंक प्राप्त करने के लिए पहले इस सवाल का जवाब है, और मुझे लगता है मैं 15 के लिए सबसे पहले हो गया लगता है।

— डेनिस

Answer 7

रेटिना, 57 49 बाइट्स

8 बाइट्स ने @Martin Büner को धन्यवाद दिया ।

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

• कमी को इस प्रकार लागू करें: 1610880191-> 61088019-> 108801-> 0880-> 88-> (खाली)।
• रिटर्न 1अगर केवल 0, 1, 8, या (खाली) छोड़ दिया है।
• 0अन्यथा लौटता है।

इसे ऑनलाइन आज़माएं!

Answer 8

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

Answer 9

TSQL, 122 बाइट्स

मैं कोड गोल्फ के लिए नया हूं, इसलिए यह सुनिश्चित नहीं है कि पात्रों की गिनती कैसे की जाए। इस मामले में प्रयुक्त संख्या 8 के बाद से इसे यहां 1 के रूप में गिना जा रहा है

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

Answer 10

रेटिना , 40 38 33 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

यह अन्य रेटिना उत्तर से पूरी तरह से अलग दृष्टिकोण का उपयोग करता है। सभी सममित भागों को हटाने के बजाय, हम बस स्ट्रिंग को उलटने और स्वैपिंग 6और 9एस के परिवर्तन का प्रदर्शन करते हैं और फिर समानता के लिए तुलना करते हैं। यह सुनिश्चित करने के लिए कि कोई गैर-सममित अंक नहीं दिखाई देते हैं, हम उन्हें 9एक आधे में भी बदल देते हैं ।

$
;$_

हम स्ट्रिंग के अंत से मेल खाते हुए इनपुट की नकल करते हैं और ;पूरे इनपुट के बाद सम्मिलित करते हैं।

T`92-7`69`;.+

यह केवल दूसरी छमाही पर एक चरित्र लिप्यंतरण के साथ मेल खाता है ;.+। दो लिप्यंतरण सेटों का विस्तार होता है:

9234567
6999999

क्योंकि 2-7एक सीमा को दर्शाता है और स्रोत सेट की लंबाई से मिलान करने के लिए अंतिम सेट के साथ लक्ष्य सेट को गद्देदार किया जाता है। इसलिए, चरण स्वैप 6और 9और भी सब से बदल जाता है 23457में 9है।

+`(.);\1
;

बार-बार ( +) के आसपास समान वर्णों की एक जोड़ी को हटा दें ;। यह या तो तब तक जारी रहेगा जब तक कि केवल ;छोड़ दिया गया है या जब तक कि चारों ओर के दो अक्षर ;समान नहीं हैं, जिसका अर्थ होगा कि तार एक दूसरे के विपरीत नहीं हैं।

^;

जांचें कि पहला वर्ण है या ;प्रिंट 0और 1तदनुसार।

Comments

लीवर, बहुत लीवर।

— कैलकुलेटर

Answer 11

पायथ - 21 बाइट्स

&!-z+`180K`69qzX_z_KK

टेस्ट सूट ।

Comments

X_zKजैसा काम करता है वैसा ही करता है X_z_KK। तीसरा पैरामीटर वैकल्पिक है।

— जेक्यूब

Answer 12

पायथ, 17 बाइट्स

!-FmC_B`d,QC\􄽥

इसे पायथ कंपाइलर में टेस्ट करें ।

यह काम किस प्रकार करता है

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

Answer 13

अनुप्रयोगों के लिए विज़ुअल बेसिक, 150 111 बाइट्स

कंसोल में या यूडीएफ के रूप में उपयोग करने योग्य।

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बयान शामिल हैं ।

Answer 14

जीएनयू सेड, 84 बाइट्स

( -rझंडे के लिए +1 सहित )

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

यदि रेखा अपने शुरुआती चरित्र के रोटेशन के साथ समाप्त होती है, तो दोनों छोरों को एक-एक करके ट्रिम करें। तब तक दोहराएं जब तक कोई मेल न हो। एक एकल सममित चरित्र के लिए खाता है, तो अगर कुछ भी रहता है, तो इनपुट सममित नहीं था, और हम झूठे लौटते हैं; अन्यथा सही लौटें।

Answer 15

सी, 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;
}

व्याख्या

हम xmodulo-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);
}

यह प्रश्न में दी गई सममित संख्याओं की सूची को प्रिंट करता है।

Answer 16

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

Answer 17

गंभीरता से, 23 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह अनिवार्य रूप से xnor के पायथन 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

Answer 18

कोटलिन, 69 बाइट्स

यह संख्या लेता है, इसे एक स्ट्रिंग में परिवर्तित करता है, इसे घुमाता है, और फिर इसकी तुलना समानता के लिए मूल स्ट्रिंग के रूप में करता है। गैर-घूर्णन योग्य अंक बस में परिवर्तित हो जाते हैं0

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

यहाँ यह परीक्षण!