निर्धारित करें कि क्या पूर्णांक किसी दिए गए मूलांक (आधार) में एक ताल है।

Question

एक प्रोग्राम लिखें जो स्टडिन दो पूर्णांक से पढ़ता है, प्रत्येक नई पंक्ति समाप्त हो गई, उसके बाद "संख्या" और "मूलांक" कहा जाता है, और:

1. किसी निश्चित संदेश आप अगर संख्या कि मूलांक में विलोमपद चाहते प्रिंट करता है (उदाहरण के लिए true, t, 1)
2. किसी भी अलग अलग तय संदेश अगर आप चाहते हैं नंबर (जैसे कि मूलांक में विलोमपद नहीं है प्रिंट करता है false, f, 0, आदि)
3. ये संदेश प्रत्येक रन के लिए समान होना चाहिए, लेकिन इसके बारे में कोई नियम नहीं हैं कि उन्हें क्या होना चाहिए (जो कि गोल्फ के लिए सबसे अच्छा है)।
4. आप मान सकते हैं कि इनपुट वैध है, दो धनात्मक पूर्णांक। "संख्या" से अधिक नहीं होगी 2147483647, "मूलांक" से अधिक नहीं होगी 32767।
5. आप बाहरी संसाधनों का उपयोग नहीं कर सकते हैं, लेकिन आप अपनी भाषा में डिफ़ॉल्ट रूप से शामिल किसी भी गणित फ़ंक्शन का उपयोग कर सकते हैं।

नोट: एक मूलांक केवल संख्या का आधार है।

नमूना चलता है:

16
10
false

16
3
true

16
20
true

121
10
true

5
5
false

12346
12345
true

16781313
64
true

16781313
16
true

Comments

नोट: एक मूलांक केवल संख्या का आधार है।

अब अच्छा लग रहा है। आप बाहरी संसाधनों पर प्रतिबंध लगाना चाह सकते हैं।

@ user2509848 हम्म, उदाहरण के लिए?

— डुर्रोन 597

यदि कोई व्यक्ति वेब पर एक कैलकुलेटर पा सकता है जो आधारों के बीच संख्याओं को परिवर्तित करता है, तो यह लगभग निश्चित रूप से उपयोग किया जाएगा। हम हाल ही में ट्राली उत्तर के एक दाने कर रहे हैं।

क्या निश्चित संदेशों में से एक खाली स्ट्रिंग हो सकता है (यह मानते हुए कि दूसरा एक गैर-रिक्त स्ट्रिंग है)?

— टॉबी स्पाइट

Answer 1

जे (23 चार) और के (19) डबल फीचर

दो भाषाएँ बहुत समान हैं, दोनों सामान्य और इस विशिष्ट गोल्फ में। यहाँ जे है:

(-:|.)#.^:_1~/".1!:1,~1

• ,~1- नंबर 1 को खुद बनाते हुए, एरे बनाते हुए 1 1।
• 1!:1- कीबोर्ड से दो तार में पढ़ें ( 1!:1पढ़ने के लिए है, और 1कीबोर्ड इनपुट के लिए फ़ाइल हैंडल / नंबर है)।
• ". - प्रत्येक स्ट्रिंग को एक संख्या में बदलें।
• #.^:_1~/- F~/ x,yखोजने का मतलब है y F x। हमारा Fहै #.^:_1, जो आधार विस्तार करता है।
• (-:|.)- क्या तर्क मेल खाता है ( -:) इसका उल्टा ( |.) है? 1हां, 0नहीं के लिए।

और यहाँ K है:

a~|a:_vs/|.:'0::'``

• 0::'``- 0::प्रत्येक ( ') के लिए एक स्ट्रिंग ( ) कंसोल से लाइन ( `इसके लिए फ़ाइल हैंडल है ) में पढ़ें ।
• .:'- कन्वर्ट ( .:) प्रत्येक ( ') स्ट्रिंग एक नंबर के लिए।
• _vs/|- संख्याओं की जोड़ी को उल्टा कर दें, ताकि मूलांक संख्या के सामने हो, और फिर उनके बीच /आधार विस्तार फ़ंक्शन _vs("वेक्टर से स्केलर") डालें ।
• a~|a:- इसके परिणामस्वरूप विस्तार को निर्दिष्ट करें a, और फिर जांचें कि क्या aमैच ( ~) इसका उल्टा है ( |)। फिर, 1हाँ के लिए, 0नहीं के लिए।

Comments

@ ak82 मेरा मानना ​​है कि यह इस तरह से अधिक दिलचस्प है

— जॉन

Answer 2

GolfScript, 10 अक्षर

~base.-1%=

यदि हम इसे सरल तरीके से करते हैं तो यह गोल्फस्क्रिप्ट के लिए एक आसान है। उत्पादन होता है 0/ 1झूठा / सच के लिए।

~       # Take input and evaluate it (stack: num rdx)
base    # Fortunately the stack is in the correct order for
        # a base transformation (stack: b[])
.       # Duplicate top of stack (stack: b[] b[])
-1%     # Reverse array (stack: b[] brev[])
=       # Compare the elements

Answer 3

एपीएल (20)

⎕{≡∘⌽⍨⍵⊤⍨⍺/⍨⌊1+⍺⍟⍵}⎕

आउटपुट 0या 1, जैसे:

      ⎕{≡∘⌽⍨⍵⊤⍨⍺/⍨⌊1+⍺⍟⍵}⎕
⎕:
      5
⎕:
      5
0
      ⎕{≡∘⌽⍨⍵⊤⍨⍺/⍨⌊1+⍺⍟⍵}⎕
⎕:
      16781313
⎕:
      64
1

स्पष्टीकरण:

• ⎕{... }⎕: दो नंबर पढ़ें, उन्हें फंक्शन में पास करें। ⍵पहला नंबर है और ⍺दूसरा नंबर है।
• ⌊1+⍺⍟⍵: आधार में floor(1+⍺ log ⍵)प्रतिनिधित्व के लिए आवश्यक अंकों की संख्या ।⍵⍺
• ⍺/⍨: प्रत्येक अंक के लिए आधार, इसलिए हमारे ⍺द्वारा गणना की गई संख्या से दोहराया गया।
• ⍵⊤⍨: ⍵दिए गए आधार में संख्याओं का प्रतिनिधित्व करें (संख्याओं का उपयोग करते हुए, इसलिए यह सभी मूल्यों के लिए काम करता है ⍺)।
• ≡∘⌽⍨: देखें कि क्या परिणाम इसके विपरीत के बराबर है।

Answer 4

पर्ल, 82 77 73 69 बाइट्स

$==<>;$.=<>;push(@a,$=%$.),$=/=$.while$=;@b=reverse@a;print@a~~@b?1:0

इनपुट नंबर STDIN की इनपुट लाइनों के रूप में अपेक्षित हैं और परिणाम के रूप में 1या लिखा है0 पूर्व पहले नंबर अर्थ दिए गए आधार के अपने प्रतिनिधित्व में विलोमपद।

संपादित करें 1:$= कुछ बाइट्स का उपयोग करके , क्योंकि इसका आंतरिक रूपांतरण int में है।

संपादन 2: स्मार्टमैच ऑपरेटर ~~सीधे सरणी तत्वों की तुलना करता है, इस प्रकार एक स्ट्रिंग में रूपांतरण की आवश्यकता नहीं होती है।

संपादन 3: एक अनावश्यक चर को हटाकर अनुकूलन।

65 बाइट्स : यदि रिक्त स्ट्रिंग को आउटपुट के लिए अनुमति दी जाती है false, तो अंतिम चार बाइट्स को हटाया जा सकता है।

अनप्लग्ड संस्करण

$= = <>;
$. = <>;
while ($=) {
    push(@a, $= % $.);
    $= /= $.; # implicit int conversion by $=
}
@b = reverse @a;
print (@a ~~ @b) ? 1 : 0

एल्गोरिथ्म एक सरणी में परिवर्तित संख्या के अंकों को संग्रहीत करता है @a। फिर इस सरणी के स्ट्रिंग प्रतिनिधित्व की तुलना रिवर्स ऑर्डर में सरणी के साथ की जाती है। रिक्त स्थान अंकों को अलग करता है।

Comments

क्षमा करें, मेरा उत्तर वास्तव में $=एकरूप है , लेकिन आप को व्हिप intस्टेप का उपयोग करने के लिए ... और प्रश्न के लिए खड़े रहना anything you wantकुछ भी नहीं हो सकता है जो आप चाहते हैं ;-)

— F. Hauri

@ F.Hauri: धन्यवाद, मैं अपडेट करूंगा। $=भी टिप के रूप में दिया जाता है इस सवाल का जवाब सवाल का "पर्ल में गोल्फ के लिए सुझाव" । लौटने पर 06 अतिरिक्त बाइट्स खर्च होते हैं, लेकिन यह मेरी धारणा थी कि एक निश्चित संदेश खाली होने का इरादा नहीं है।

— हेइको ओबर्डिएक

हेम ,, वापसी 0 लागत 4 अतिरिक्त बाइट्स, नहीं 6. लेकिन मैं बनाए रखने के: है कुछ भी! silence

— एफ। हौरी

@ F.Hauri: हाँ, 4 सही है, अतिरिक्त दो बाइट्स ungolfed संस्करण के कोष्ठक थे।

— हीको ओबर्डिएक

Answer 5

जावास्क्रिप्ट 87

function f(n,b){for(a=[];n;n=(n-r)/b)a.push(r=n%b);return a.join()==a.reverse().join()}

nतर्क संख्या है, bतर्क मूलांक है।

Answer 6

साधु, ४५

इंटरैक्टिव प्रॉम्प्ट में चलता है

A=Integer(input()).digits(input())
A==A[::-1]

प्रिंट्स Trueजब यह एक palindrome होता है, तो प्रिंट करता Falseहै

Answer 7

पर्ल 54 56 62

$==<>;$-=<>;while($=){$_.=$/.chr$=%$-+50;$=/=$-}say$_==reverse

परीक्षण करने के लिए:

for a in $'16\n3' $'16\n10' $'12346\n12345' $'12346\n12346' $'21\n11' $'170\n16';do
    perl -E <<<"$a" ' 
        $==<>;$-=<>;while($=){$_.=$/.chr$=%$-+50;$=/=$-}say$_==reverse
    '
  done

दे देंगे:

1

1


1

इस उत्पादन तो 1के लिए trueजब विलोमपद पाया जाता है और है कुछ भी नहीं किसी और यदि।

Ungolfing:

$==<>;                            # Stdin to `$=`  (value)
$-=<>;                            # Stdin to `$-`  (radix)
while ( $= ) {
    $_.= $/. chr ( $= % $- +50 ); # Add *separator*+ chr from next modulo to radix to `$_`
    $=/= $-                       # Divide value by radix
}
say $_ == reverse                 # Return test result

नोटा :

• $_ वर्तमान लाइन बफर है और शुरू में खाली है।
• $=एक आरक्षित चर है, जो लाइन प्रिंटिंग के लिए उपयोग किया जाता है, यह एक लाइन काउंटर है। तो यह चर एक पूर्णांक है , इस पर किसी भी गणना के परिणामस्वरूप एक पूर्णांक पूर्णांक होगा यदि int()उपयोग किया गया था।
• $- मज़े के लिए इस्तेमाल किया गया था, बस पारंपरिक पत्रों का उपयोग नहीं करने के लिए ... (कुछ और मोटे तौर पर) ...

Comments

स्पष्ट करने के लिए, यह कुछ नहीं कहता है जब यह एक palindrome नहीं है, और 1 कब है?

— डुर्रोन 597

अच्छी चाल। हालांकि गलत सकारात्मक: आधार के साथ 21 11. अंकों को स्ट्रिंग तुलना में एक विभाजक की आवश्यकता है।

— Heiko Oberdiek

आgरग +३! @HeikoOberdiek तुम सही हो ...

— F. Hauri

@ F.Hauri: इसके अलावा अंक उलट हो जाते हैं। इस प्रकार बेस 16 के साथ 170 0xAA है, एक पैलिंड्रोम, लेकिन परिणाम गलत है।

— हेइको ओबर्डिएक

अरग +6!

— धर्मपरिवर्तन

Answer 8

गणितज्ञ 77 43

IntegerDigits[n,b]आधार बी में अंकों की सूची के रूप में n का प्रतिनिधित्व करता है। प्रत्येक बेस-बी अंक को निर्णायक रूप से व्यक्त किया जाता है।

उदाहरण के लिए, 16781313 आधार 17 में एक तालमेल नहीं है:

IntegerDigits[16781313, 17]

{11, 13, 15, 11, 14, 1}

हालांकि, यह है आधार 16 में विलोमपद:

IntegerDigits[16781313, 16]

{, 0, 0, 1, 1, 0, 0, 1}

---

यदि उपरोक्त उदाहरणों में आदेशित जोड़े दर्ज किए गए थे,

(x=Input[]~IntegerDigits~Input[])==Reverse@x

लौटूंगा

गलत (* (क्योंकि {11, 13, 15, 11, 14, 1}! = {1, 14, 11, 15, 13, 11}) *)

सच्चा (* (क्योंकि {1, 0, 0, 1, 0, 0, 1}) {1, 0, 0, 1, 0, 0, 1}) के बराबर है *)

Comments

अजीब, उत्तर के लिए आवश्यक नहीं, लेकिन मैं उत्सुक हूं, यह उन्हें कैसे प्रस्तुत करता है?

— डुर्रोन 597

जब मैं बेवकूफ टाइपकास्ट के कारण हार जाता हूं तो मुझे इससे नफरत होती है ...

— user12205

कृपया "टाइपकास्ट" समझाएं।

— डेविड सी

मेरे ऋषि समाधान 2 वर्णों से आपके से अधिक लंबा है क्योंकि मुझे टाइप करने के लिए इनपुट डालना होगाInteger

— user12205

अब मुझे समझ में आया कि आपका क्या मतलब है। धन्यवाद।

— डेविड मार्क

Answer 9

हास्केल (80 वर्ण)

tb 0 _=[]
tb x b=(tb(div x b)b)++[mod x b]
pali n r=(\x->(x==reverse x))(tb n r)

इसके साथ बुलाओ pali $number $radix। सच है, जब संख्या एक पैलिंड्रोम है, तो गलत यदि नहीं।

Answer 10

रूबी - 76 वर्ण

f=->(n,b){n==0?[]:[n%b,*f.(n/b,b)]};d=f.(gets.to_i,gets.to_i);p d==d.reverse

Answer 11

पर्ल 6 , 27 बाइट्स (22 बिना स्टडिन / आउट)

say (+get).base(get)~~.flip

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

  get()                     # pulls a line of stdin
 +                          # numerificate
(      ).base(get())        # pull the radix and call base to 
                            #  convert to string with that base
                    ~~      # alias LHS to $_ and smartmatch to
                      .flip # reverse of the string in $_

Perl6, पठनीय गोल्फ के राजा (घोड़ों?) (और भी कुछ पठनीय नहीं है)।

पर्ल 6 फ़ंक्शन (स्टड / स्टडआउट नहीं), 22 बाइट्स

{$^a.base($^b)~~.flip}

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

Comments

baseमेरे जवाब में उपयोग नहीं किए जाने का कारण यह है कि baseकेवल बेस 36 तक का समर्थन करता है, और सवाल रेडिक्स का समर्थन करने के लिए कहता है32767

— जो किंग

ऊह, वह नहीं जानता था। हम्म।

— फिल एच

Answer 12

डीजी - 97 बाइट्स

डीजी की कोशिश कर रहा है :

n,r=map int$input!.split!
a=list!
while n=>
 a.append$chr(n%r)
 n//=r
print$a==(list$reversed a)

व्याख्या की:

n, r=map int $ input!.split!      # convert to int the string from input
a = list!                         # ! calls a function without args
while n =>
 a.append $ chr (n % r)           # append the modulus
 n //= r                          # integer division
print $ a == (list $ reversed a)  # check for palindrome list

Answer 13

सी, 140 132

int x,r,d[32],i=0,j=0,m=1;main(){scanf("%d %d",&x,&r);for(;x;i++)d[i]=x%r,x/=r;i--;for(j=i;j;j--)if(d[j]-d[i-j])m=0;printf("%d",m);}

• मूलांक 1 समर्थित नहीं है :)

Comments

बस puts(m)सही काम करेगा?

— डुर्रोन 597

printf("%d",m);8 वर्णों से छोटा होगा।

— VX

Answer 14

हास्केल - 59

मैक्स रीड के जवाब के लिए कुछ परिवर्तन।

0%_=[]
x%b=x`mod`b:((x`div`b)%b)
p=((reverse>>=(==)).).(%)

Answer 15

अजगर , 4 बाइट्स

_IjF

इसे यहां आज़माएं या एक परीक्षण सूट देखें (~ 10-15 सेकंड)।

Answer 16

डीसी, 39 बाइट्स

लंबाई निश्चित रूप से ( 33₁₂) है।

[[t]pq]sgod[O~laO*+sad0<r]dsrx+la=g[f]p

संख्या और मूलांक स्टैक के शीर्ष पर होना चाहिए (वर्तमान संख्या आधार में); संख्या कम से कम 0 होनी चाहिए, और मूलांक कम से कम 2 होना चाहिए। आउटपुट tयदि यह एक पैलिंड्रोम है और fयदि नहीं। जैसा कि यह चुनौती में निर्दिष्ट नहीं है, मैंने मान लिया है कि संख्याओं में अग्रणी शून्य कभी नहीं होता है (इसलिए किसी भी संख्या में समाप्त होता है0 नहीं हो सकती है)।

व्याख्या

एक पूर्ण कार्यक्रम के रूप में:

#!/usr/bin/dc

# read input
??

# success message
[[t]pq]sg

# set output radix
o

# keep a copy unmodified
d

# reverse the digits into register a
[O~ laO*+sa d0<r]dsrx

# eat the zero left on stack, and compare stored copy to a
+ la=g

# failure message
[f]p

Answer 17

लाटेक्स, 165 बाइट्स

उदाहरण के लिए desmos.com पर

kमूलांक, एक समायोज्य इनपुट है

b=\floor \left(\log _k\left(\floor \left(x\right)\right)\right)
f\left(x\right)=k^bx-x-\left(k^2-1\right)\sum _{n=1}^bk^{\left(b-n\right)}\floor \left(xk^{-n}\right)

यदि f(x)=0, xआधार में एक ताल है k।

Answer 18

पर्ल 6 , 34 बाइट्स

-4 बाइट्स फिलह की बदौलत

{@(polymod $^a: $^b xx*)~~[R,] $_}

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

Comments

आप 2r को बचाने के लिए @r के बजाय $ _ का उपयोग कर सकते हैं

— Phil H

@PhilH नहीं । (एक Seq असाइन करता है, सूची नहीं)

— Jo King

आह, माफ करना त्रुटि नहीं देखी

— फिल एच

@PhilH आपकी दूसरी टिप ने अभी भी बाइट्स बचाने में मदद की है!

— जो किंग

हमेशा कष्टप्रद कि $ _ या @_ पर मेटा को कम करने का कोई छोटा तरीका नहीं है।

— फिल एच

Answer 19

05AB1E ,  4  3 बाइट्स

вÂQ

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

в      # The first (implicit) input converted to base second (implicit) input
       #  i.e. 12345 and 12346 → [1,1]
       #  i.e. 10 and 16 → [1,6]
 Â     # Bifurcate the value (short for duplicate & reverse)
       #  i.e. [1,1] → [1,1] and [1,1]
       #  i.e. [1,6] → [1,6] and [6,1]
  Q    # Check if they are still the same, and thus a palindrome
       #  i.e. [1,1] and [1,1] → 1
       #  i.e. [1,6] and [6,1] → 0

Answer 20

सी (जीसीसी) , 79 बाइट्स

n,r,m;main(o){for(scanf("%d %d",&n,&r),o=n;n;n/=r)m=m*r+n%r;printf("%d",m==o);}

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

मंद होना

n,r,m;main(o){
for(scanf("%d %d",&n,&r),       Read the number and the radix.
o=n;                            ...and save the number in o
n;                              Loop while n is non-zero
n/=r)                           Divide by radix to remove right-most digit.
m=m*r+n%r;                      Multiply m by radix to make room for a digit
                                and add the digit.
printf("%d",m==o);}             Print whether we have a palindrome or not.

इस तथ्य के आधार पर कि एक पैलिंड्रोम के लिए, संख्या का उल्टा होना स्वयं संख्या के बराबर होना चाहिए।

मान लीजिए कि आपके पास कुछ बेस में तीन अंकों की संख्या एबीसी है। इसे आधार से गुणा करना हमेशा ABC0 में परिणाम करेगा, और शेष के रूप में C के साथ AB में इसे आधार से विभाजित करना होगा। इसलिए नंबर को उलटने के लिए हम मूल संख्या से दाएं-सबसे अंकों को निकालते हैं और इसे उलटी संख्या पर दाईं ओर सम्मिलित करते हैं। उस अंक के लिए जगह बनाने के लिए, हम पूर्व-हाथ से आधार द्वारा रिवर्स गुणा करते हैं।

मूल रूप से:

n       rev
ABC     0
AB      C
AB      C0
A       CB
A       CB0
0       CBA

Comments

यह अच्छा है, क्या आप इसके पीछे का गणित समझा सकते हैं?

— डुर्रोन 597

@ Durron597 ज़रूर! पोस्ट में एक स्पष्टीकरण जोड़ा गया।

— गैस्ट्रोपनर