आधारित पलिंड्रोम्स
रिफ्रेशर के रूप में एक पलिंड्रोमिक संख्या, कोई भी संख्या होती है जो पीछे की तरह आगे की ओर पढ़ती है। हालांकि, अन्य ठिकानों में पलिंड्रोम के बारे में क्या?
इनपुट
कोई भी पूर्णांक bजहां b > 1।
आउटपुट
सभी पूर्णांक आधार 0 से 1000 तक के 10 संख्याओं को शामिल करते हैं जो आधार b में palindromes हैं। आउटपुट या तो पूर्णांक, या पूर्णांक द्वारा अलग किए गए पूर्णांक की एक सूची हो सकती है जैसे अल्पविराम या एक नई रेखा।
परीक्षण के मामलों
Input->Output
10->{0,1,2,3,4,5,6,7,8,9,11,22,33,44,55,66,77,88,99,101,111,121,131,141,151,161,171,181,191,202,212,222,232,242,252,262,272,282,292,303,313,323,333,343,353,363,373,383,393,404,414,424,434,444,454,464,474,484,494,505,515,525,535,545,555,565,575,585,595,606,616,626,636,646,656,666,676,686,696,707,717,727,737,747,757,767,777,787,797,808,818,828,838,848,858,868,878,888,898,909,919,929,939,949,959,969,979,989,999}
2->{0,1,3,5,7,9,15,17,21,27,31,33,45,51,63,65,73,85,93,99,107,119,127,129,153,165,189,195,219,231,255,257,273,297,313,325,341,365,381,387,403,427,443,455,471,495,511,513,561,585,633,645,693,717,765,771,819,843,891,903,951,975}
9->{0,1,2,3,4,5,6,7,8,10,20,30,40,50,60,70,80,82,91,100,109,118,127,136,145,154,164,173,182,191,200,209,218,227,236,246,255,264,273,282,291,300,309,318,328,337,346,355,364,373,382,391,400,410,419,428,437,446,455,464,473,482,492,501,510,519,528,537,546,555,564,574,583,592,601,610,619,628,637,646,656,665,674,683,692,701,710,719,728,730,820,910,1000}
जवाब
पायथन 3 , 78 बाइट्स
घटते क्रम में संख्याओं को आउटपुट करता है 1000 -> 0, और शॉर्ट-सर्किट के साथ एZeroDivisionError
def f(b,n=1000):
r=0;m=n
while m:r=r*b+m%b;m//=b
n==r==print(n);f(b,n-n//n)
इसे ऑनलाइन आज़माएं!
f(b,n-n//n) -> f(b,n-1)जब तक recurses 0, और त्रुटियों शून्य से भाग देने अपरिभाषित है, क्योंकि।
पायथन 3 , 76 बाइट्स
यदि फ्लोटिंग-पॉइंट आउटपुट की अनुमति है, तो हम 2 बाइट्स द्वारा उत्तर को छोटा कर सकते हैं।
def f(b,n=1e3):
r=0;m=n
while m:r=r*b+m%b;m//=b
n==r==print(n);f(b,n-n/n)
इसे ऑनलाइन आज़माएं!
सी (जीसीसी) आगे, 118 117 115 बाइट्स
b[11],*p,*x,i,m;f(n){for(i=-1;i++<1e3;){for(p=x=b,m=i;m;*p++=m%n,m/=n);while(p>x)m|=*--p-*x++;m||printf("%d,",i);}}
इसे ऑनलाइन आज़माएं!
सी (जीसीसी) , पीछे की ओर, 115 113 बाइट्स
b[11],*p,*x,i,m;f(n){for(i=1001;i--;){for(p=x=b,m=i;m;*p++=m%n,m/=n);while(p>x)m|=*--p-*x++;m||printf("%d,",i);}}
इसे ऑनलाइन आज़माएं!
स्पष्टीकरण
सी हस्ताक्षर:
// Technically implicit int with a void return
void f(int base);
0 से 1000 तक की सभी संख्याओं के माध्यम से लूप, उन्हें baseहाथ से आधार में परिवर्तित करता है, फिर जाँचता है कि क्या यह एक पैलिंड्रोम है।
बैकवर्ड संस्करण एक ही काम करता है, लेकिन पीछे की तरफ।
प्रिंट से मिलान करने वाले अंक, अल्पविराम अलग, स्टडआउट के लिए।
अनप्लग्ड संस्करण
#include <stdio.h>
// A buffer to hold our converted integer.
// It is large enough for 1000 in binary.
int buffer[11];
// Start and end pointers for buffer
int *start, *end;
// Loop counter
int i;
// Temporary
int tmp;
void f(int base)
{
// Loop for 0 to 1000
#ifdef BACKWARDS
// Loop backwards
for (i = 1001; i-- != 0;) {
#else
// Loop forwards
// for (i = 0; i <= 1000; i++)
for (i = -1; i++ < 1e3; ) {
#endif
// Convert to base in buffer, tracking the length in end.
for(start = end = buffer, tmp = i; tmp != 0;) {
*end++ = tmp % base;
tmp /= base;
}
// Check if it is a palindrome.
// Loop while our starting pointer is less than our ending pointer.
// tmp will zero at the start thanks to the loop condition.
while (end > start)
// Assembly style comparison using subtraction.
// If *end == *start, tmp will still be zero.
// If not, it will be permanently set to non-zero with a binary or.
tmp |= *--end - *start++;
// If tmp is still zero (meaning it is a palindrome), print.
tmp || printf("%d,", i);
}
}
-1 बाइट्स के लिए अरनौल को धन्यवाद!
-2 बाइट्स के लिए टोबी स्पाइट का धन्यवाद!
05AB1E , 7 बाइट्स
₄ÝʒIвÂQ
इसे ऑनलाइन आज़माएं!
व्याख्या की
₄Ý "Push the range [0, 1000]"\
ʒ "and keep the items where:"\
Iв "After being converted to base (input)"\
ÂQ "have its reverse equal to itself"\
जेली , 7 बाइट्स
ȷŻbŒḂ¥Ƈ
इसे ऑनलाइन आज़माएं!
यह काम किस प्रकार करता है
ȷŻbŒḂ¥Ƈ - Main link. Takes a base b on the left
ȷ - 1000
Ż - [0, 1, 2, ..., 1000]
¥ - Group the previous 2 links into a dyad f(k, b):
b - Convert k to base b
ŒḂ - Is this a palindrome?
Ƈ - Filter [0, 1, 2, ..., 1000], keeping those k that are true under f(k, b)
जाप , 11 बाइट्स
A³ô fÈìU êê
इसे अजमाएं
वोल्फ्राम लैंग्वेज (मैथमेटिका) , 44 बाइट्स
Pick[r=0~Range~1000,r-r~IntegerReverse~#,0]&
इसे ऑनलाइन आज़माएं!
-13 बाइट्स @ से
जावास्क्रिप्ट (ईएस 6), 87 86 बाइट्स
अल्पविराम से अलग किया गया स्ट्रिंग लौटाता है।
n=>(g=k=>--k&&g(k)+((h=k=>a=k?[k%n,...h(k/n|0)]:[])(k)+''==a.reverse()?[,k]:''))(1001)
इसे ऑनलाइन आज़माएं!
कैसे?
n => ( // n = input base
g = k => // g is a recursive function taking a counter k
--k && // decrement k; abort if it's equal to 0
g(k) + ( // otherwise do a recursive call and append the ...
( h = k => // ... result of the recursive function h
a = k ? // which builds an array a[]
[ k % n, // consisting of each digit of k in base n,
...h(k / n | 0) ] // dividing k by n and taking the integer part
: // for the next iteration until k = 0
[] //
)(k) + '' // invoke h with k and coerce the result to a string
== a.reverse() ? // if this is palindromic:
[, k] // append a comma followed by k to the output
: // else:
'' // just append an empty string
) //
)(1001) // initial call to g with k = 1001
स्काला , 62 87 बाइट्स
- फिक्स्ड के बाद सिउ चिंग पोंग -Asuka Kenji- ने बताया
BigInt'stoStringकेवल ऊपर से 36 ठिकानों के लिए काम करता है। - @ ब्यूटि लेटेस के लिए 1 बाइट धन्यवाद ।
b=>0 to 1000 filter{x=>val y=Seq.unfold(x){q=>Option.when(q>0)(q%b,q/b)};y==y.reverse}
इसे ऑनलाइन आज़माएं!
यह बहुत सीधा है। यह 0 से 1000 तक की सीमा बनाता है, फिर छानकर जांचता है कि क्या वे आधार में अपने रिवर्स के बराबर हैं b। आधार b(एक स्ट्रिंग के रूप में) में परिवर्तित करने के लिए , BigInt's' toStringविधि का उपयोग किया गया था, लेकिन अब Seq.unfoldइसका उपयोग Seqअंकों का निर्माण करने के लिए किया जाता है ।
भूसी , 12 11 बाइट्स
संपादित करें: LegionMammal978 के लिए -1 बाइट धन्यवाद
foS=↔B⁰ŀdḋ9
इसे ऑनलाइन आज़माएं!
वास्तविक 'आधारित पैलिंड्रोम' कोड 7 बाइट्स ( foS=↔B⁰) है, लेकिन 0 ... 1000 की लागत 5 4 निर्दिष्ट करने के लिए (LegionMammal978 के लिए धन्यवाद) अधिक बाइट्स।
हम एक बाइट बचा सकते हैं अगर यह ठीक है कि दशमलव 1024 ( foS=↔B⁰ŀ□32) तक के मूल्यों के साथ कुछ और आधारित पैलिंड्रोमों का उत्पादन किया जाए ।
f # output the truthy values of
ŀdḋ9 # series from zero up to one less than 1001
# (decimal interpretation of binary digits of '9')
o # based on combination of 2 functions:
S=↔ # 1. is it equal to reverse of itself?
B⁰ # 2. digits in base given by argument
चारकोल , 14 बाइट्स
ＮθＩΦ⊕φ⁼↨ιθ⮌↨ιθ
इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:
Ｎθ Input the base `b`
φ Predefined variable 1000
⊕ Incremented
Φ Filter on implicit range
ι Current value
↨ θ Converted to base `b`
⁼ Equals
ι Current value
↨ θ Converted to base `b`
⮌ Reversed
Ｉ Cast to string
Implicitly print
हास्केल , 63 बाइट्स
f b|let 0%m=m;n%m=div n b%(m*b+mod n b)=[n|n<-[0..1000],n==n%0]
इसे ऑनलाइन आज़माएं!
Dingledooper के पायथन उत्तर से एक अच्छे विचार के आधार पर : यह जांचने के लिए कि nएक आधार है-b palindrome, आधार- bअंकों की सूची उत्पन्न नहीं करता है , लेकिन अंत से आधार-रूपांतरण रीडिंग अंक चलाकर आधार-संख्या के nरूप में रिवर्स करता है b, और जाँच करें कि परिणाम अभी भी बराबर है n।
कोड |let 0%m=m;n%m=div n b%(m*b+mod n b)पुनरावर्ती रूप से एक इन्फिक्स फ़ंक्शन को परिभाषित करता है जो %आधार को उलट देता है n( 0प्रारंभिक दूसरे तर्क के रूप में दिया गया है)। एक letगार्ड के अंदर इसे परिभाषित करने से हम तर्क bको मुख्य फ़ंक्शन तक पहुंच सकते हैं , जबकि एक स्टैंडअलोन फ़ंक्शन को प्रत्येक पुनरावर्ती कॉल के साथ इसे पारित करने की आवश्यकता होगी।
एपीएल (डायलॉग एक्सटेंडेड) , 17 15 बाइट्स
-2 बाइट्स के लिए रज़ाइम को धन्यवाद !
एक बग सियू चिंग पोंग के लिए धन्यवाद !
सूचकांक उत्पत्ति की आवश्यकता है 0।
⍸⎕(⊤≡∘⌽⊤)¨⍳1001
इसे ऑनलाइन आज़माएं!
⍝ tradfn taking the base as input
⍳1001 ⍝ the indices up to 1000
⍵( )¨ ⍝ apply a function to each index as a right argument and the input base as a left argument:
⌽⊤ ⍝ the reverse of the index converted to the input base
≡ ⍝ does it match
⊤ ⍝ the index converted to the input base
⍸ ⍝ all truthy indices
सी - 76 बाइट्स
i=1001,a,z;f(b){for(;i--;i-z||printf("%d ",i))for(a=i,z=0;a;a/=b)z=z*b+a%b;}
स्पष्टीकरण
पर्याप्त रूप से मेरे पहले के उत्तर से अलग वारंट पोस्टिंग से अलग है। इस बार, हम पूरी तरह से संख्या को उल्टा करते हैं, फिर मूल की तुलना करते हैं। इसलिए हमें ट्रेलिंग शून्य, या विशेष मामले को खत्म करने की आवश्यकता नहीं है 0।
void fun(int b)
{
for (int i = 1001; i--;) {
int z = 0;
for (int a = i; a != 0; a /= b) {
z = z*b + a%b;
}
if (i==z) {
printf("%d ",i);
}
}
}
इस विधि के लिए मज़बूती से काम करता है iअप करने के लिए INT_MAX/bऔर bअप करने के लिए INT_MAX, या उचित समकक्ष अगर हम पूर्णांक इस्तेमाल किया प्रकार बदलें। अहस्ताक्षरित प्रकारों (या साथ gcc -fwrapv) के लिए, इसे पूरी श्रृंखला के लिए काम करना चाहिए i।
सी, 100 बाइट्स
i=1001,a,z;f(b){for(;--i;)for(a=i,z=0;i%b*a;a/=b)if(a==z||a==(z=z*b+a%b))printf("%d ",i);puts("0");}
इसे ऑनलाइन आज़माएं
अघोषित कोड
void fun(int b)
{
for (int i = 1001; --i;) {
if (i%b) { /* no leading/trailing zeros */
for (int a = i, z = 0; a != 0; a /= b) {
if (a==z) {
printf("%d ",i);
}
z = z*b + a%b;
if (a==z) {
printf("%d ",i);
}
}
}
}
puts("0");
}
स्पष्टीकरण
यह संख्या को सबसे पहले आउटपुट करता है, क्योंकि कोई विशेष आदेश निर्दिष्ट नहीं किया गया था। प्रत्येक उम्मीदवार संख्या के लिए, हम इसे (as a) आधार द्वारा क्रमिक रूप से विभाजित करके, रिवर्स संख्या (में z) का निर्माण करने के लिए शेष का उपयोग करके कम करते हैं । यदि aबराबर हो जाता है z, तो हमारे पास एक ताल है। आमतौर पर, हम वहाँ ( a >= zलूप स्थिति में) रुकेंगे, लेकिन गोल्फिंग के लिए, हम सभी तरह से जारी रखेंगे a==0।
हमें शेष zऔर विषम लंबाई दोनों को स्वीकार करने के लिए शेष को स्थानांतरित करने से पहले और बाद में समानता का परीक्षण करने की आवश्यकता है ।
अंत में, हम प्रिंट करते हैं 0, जो हमेशा एक palindrome होता है, और लूप में शामिल करने की तुलना में विशेष-मामले में आसान होता है।
विधि पूर्णांक के लिए काम करती है INT_MAXयदि हम स्थिति को i%b*aवापस अनगुल्फ करते हैं i%b&&a, और अन्य पूर्णांक प्रकारों के लिए भी काम करेंगे।
K (ngn / k) , 18 बाइट्स
{&{x~|x}'x\'!1001}
इसे ऑनलाइन आज़माएं!
x\'!10010..1000 में से प्रत्येक को बेस-एक्स प्रतिनिधित्व में बदलें{x~|x}'जाँच करें कि क्या प्रत्येक प्रतिनिधित्व एक पैलिंड्रोम है&ट्रूस के संकेत मिलता है
पायथन 3.8 (पूर्व-रिलीज़) , 92 85 बाइट्स
lambda b:[i for i in range(1001)if(f:=lambda n:n*[0]and[n%b]+f(n//b))(i)==f(i)[::-1]]
इसे ऑनलाइन आज़माएं!
7 बाइट बचाने के लिए dingledooper के लिए धन्यवाद !
हास्केल, 67 बाइट्स
b&n=take n$mod n b:b&div n b
f b=[n|n<-[0..1000],reverse(b&n)==b&n]
fरुचि का कार्य है। इसे ऑनलाइन आज़माएं!
शायद यहां एकमात्र चतुर बिट take nअंक-विस्तार फ़ंक्शन के लिए एक बेस केस बनाने का उपयोग है । जब n=0, take nइसके तर्क की उपेक्षा करता है और इसलिए पुनरावृत्ति आलस्य के माध्यम से बंद हो जाती है; जब n>0, निश्चित रूप से nअंकों से अधिक नहीं होगा तो यह केवल पहले रखने के लिए सुरक्षित है n। निम्नलिखित परिभाषा समतुल्य है (और समान रूप से लंबी):
b&0=[]
b&n=mod n b:b&div n b
... लेकिन take nसंस्करण अधिक मजेदार है क्योंकि यह अधिक भ्रामक है। ^ _ ^
जे , 27 बाइट्स
((-:|.)@(#.inv)"0#])i.@1001
किस तरह
(...) i.@1001- पूरी बात एक जे हुक है, जिसका अर्थ है कि तर्क में सब कुछ के लिए बाएं arg होगा, और दायाँ arg पूर्णांक 0 से 1000 होगा:i.@1001...#]पैरेंस के अंदर वाक्यांश बूलियन मास्क द्वारा#दाईं ओर फिल्टर करने के लिए कॉपी का उपयोग करता है]जिसके परिणामस्वरूप बाईं ओर वाक्यांश होता है#:(-:|.)@(#.inv)"0- रैंक 0"0सुनिश्चित करता है कि वाक्यांश सही संख्या के प्रत्येक व्यक्ति पर लागू हो। वाक्यांश पहले उन संख्याओं में से प्रत्येक को बाईं ओर दिए गए आधार में अंकों की एक सूची में परिवर्तित(#.inv)करता है, और फिर जाँचता है कि क्या यह सूची इसके विपरीत के बराबर है(-:|.)@। पूरा वाक्यांश इस प्रकार 1 लौटेगा जब यह सच है और 0 अन्यथा, और यह बूलियन मुखौटा सही arg को वांछित के रूप में फ़िल्टर करेगा।
इसे ऑनलाइन आज़माएं!
रूबी 2.7 , 74 बाइट्स
->b{(0..1e3).select{(a=(g=->k,r=[]{k>0?g[k/b,r<<k%b]:r})[_1])==a.reverse}}
इसे ऑनलाइन आज़माएं!
TIO रूबी के एक पुराने संस्करण का उपयोग करता है, जबकि Ruby 2.7 में, हमने गिने हुए पैरामीटर हैं, जो दो बाइट्स बचाता है।
रूबी , 48 बाइट्स
->b{(0..1e3).select{|k|(k=k.to_s b)==k.reverse}}
इसे ऑनलाइन आज़माएं!
.to_sविधि में सीमा के कारण 64 से अधिक आधारों के लिए काम नहीं करता है ।
जावास्क्रिप्ट (V8) , 77 89 बाइट्स
36 से अधिक आधारों के लिए निश्चित।
b=>{for(i=-1;i<1e3;){j=[],k=++i;while(k|=0)j.push(k%b),k/=b;''+j==j.reverse()&&print(i)}}
इसे ऑनलाइन आज़माएं!
पावरशेल ,
102
100
98
95
87
75 बाइट्स
-14 बाइट्स mazzy के लिए धन्यवाद!
param($u)0..1e3|?{for($b=@();$_=($_-($b+=$_%$u)[-1])/$u){}"$b"-eq$b[11..0]}
इसे ऑनलाइन आज़माएं!
आर , 82 81 बाइट्स
(या " " के बजाय जटिल सीमांकक का उपयोग करके 79 बाइट्स\n[1] )
संपादित करें: -1 बाइट caird coinheringaahing के लिए धन्यवाद
function(b)for(i in 0:1e3)if(!i||all((a=i%/%b^(0:log(i,b))%%b)==rev(a)))cat(i,'')
इसे ऑनलाइन आज़माएं!
मैन्युअल रूप से नए बेस प्रतिनिधित्व में अंकों की गणना करता है, और जांचता है कि क्या वे स्वयं उलट के समान हैं।
function(b)
for(i in 0:1000) # loop i through zero to 1000
if(!i # if i is zero (always a palindrome),
|| # or
all( # if all the digits of
(a=i%/%b^(0:log(i,b))%%b) # a = the representation of i in base b
==rev(a)) # are the same as themselves reversed
)cat(i,'') # output this i
jq , 66 बाइट्स
. as$a|range(1001)|select([while(.>0;./$a|floor)|.%$a]|reverse==.)
इसे ऑनलाइन आज़माएं!
स्पष्टीकरण
. as $a | # Assign the input to $a. range(1001) | # For every item in [0..1000]: select ( # Filter out all items where: [ while(. > 0; # The list of quotients from repeatedly . / $a | floor) # short-dividing by $a |. % $a] # And then modulo-ing by $a
| reverse == .) # is equal to its reverse
```
अजगर , 11 बाइट्स
f_IjTQUh^T3
इसे ऑनलाइन आज़माएं!
f_IjTQUh^T3 | Explanation
------------+---------------------------------------
f | filter
Uh^T3 | the range [0, 1001)
jTQ | on whether each number in base <input>
_I | equals itself reversed
जावा 10, 118 बाइट्स
b->{for(int i=-1;i++<1e3;){var s=b.toString(i,b);if(s.contains(new StringBuffer(s).reverse()))System.out.println(i);}}
इसे ऑनलाइन आज़माएं।
स्पष्टीकरण:
b->{ // Method with Integer parameter and no return-type
for(int i=-1;i++<1e3;){ // Loop `i` in the range [0,1000]:
var s=b.toString(i,b); // Convert `i` to base-`b` as String
if(s.contains(new StringBuffer(s).reverse()))
// If this String is a palindrome:
System.out.println(i);}} // Print `i` with trailing newline