कभी विषम या कभी नहीं

15

क्या आपने ध्यान दिया, कि यह एक पैलेंड्रोम है?


गैर-नकारात्मक पूर्णांक संख्या या स्ट्रिंग का प्रतिनिधित्व करने वाला इनपुट

आउटपुट
4 संभावित आउटपुट, संख्या के दो गुणों का प्रतिनिधित्व करते हैं:

  • क्या यह पैलिंड्रोम है
  • मुश्किल # 2

मुश्किल # 2 संपत्ति
यदि संख्या पैलिंड्रोम नहीं है, तो यह संपत्ति सवाल का जवाब देती है "क्या पहले और आखिरी अंक में समान समानता है?"
यदि संख्या palindrome है, तो यह गुण प्रश्न का उत्तर देता है "क्या पहला और मध्य अंक समान समानता है?"। यहां तक ​​कि लंबाई के लिए, मध्य अंक केंद्र के दो अंकों में से एक है।

उदाहरण

12345678 -> गलत झूठी
यह पैलिंड्रोम नहीं है, पहले और अंतिम अंकों में अलग समानता है

12345679 -> गलत सच
यह पैलिंड्रोम नहीं है, पहले और आखिरी अंकों में समान समानता है

12344321 -> सच्चा झूठा
यह पैलिंड्रोम है, पहले अंक 1 और मध्य अंक 4 में अलग समानता है

123454321 -> ट्रू ट्रू
यह पैलिंड्रोम है, पहले अंक 1 और मध्य अंक 5 में समान समानता है

PS
आप आउटपुट प्रकार और प्रारूप तय करने के लिए तैयार हैं। यह कोई भी 4 विशिष्ट मूल्य हो सकते हैं। बस अपने उत्तर में इसका उल्लेख करें।

code-golf  number-theory  palindrome 
— मृत पोसुम
स्रोत
यह स्पष्ट नहीं है कि "इस संख्या का आधा" का क्या मतलब है। मुझे लगा कि इसका मतलब n / 2 है, लेकिन यह स्पष्ट करने का अर्थ है कि यह पहली या आखिरी छमाही है।
— xnor
@ एक्सनोर इसका स्ट्रिंग
— डेड पॉसम
मुझे लगता है कि मुझे लगता है कि शासन को लागू करने का एक सरल तरीका है।
— xnor
@xnor अच्छा लगता है, धन्यवाद!
— मृत पोसम
क्या हम गैर-नकारात्मक पूर्णांक इनपुट मान सकते हैं?
— टाइटस

जवाबों:

6

05AB1E, 15 , 14 13 बाइट्स (रिले और कारुसोकोम्पुटिंग के लिए धन्यवाद)

ÐRQi2ä¨}ȹRÈQ

ऑनलाइन कोशिश करें

यदि यह एक पैलिंड्रोम है तो कोष्ठक के साथ लौटता है

0 के साथ रिटर्न अगर समता अलग है, 1 यदि यह समान है

Ð इनपुट जोड़ें, जैसे कि मेरे पास काम करने के लिए पर्याप्त इनपुट है

R स्टैक के अंतिम तत्व को उल्टा करें

Q देखें कि क्या यह समान है (दो शीर्ष तत्व लेता है और == करता है)

i यदि कथन है, तो केवल तब होता है जब यह एक पैलिंड्रोम हो

2 अंक 2 को पुश करें

ä इनपुट को 2 बराबर स्लाइस में विभाजित करें

¨ विभाजन के पहले तत्व को धक्का दें (1264621 परिणाम 1264 में)

} अगर अंत

È जांचें कि क्या अंतिम तत्व सम है

¹ पहले इनपुट को फिर से पुश करें

R उस इनपुट को उल्टा करें

È जांचें कि क्या यह अभी भी है

Q जाँच करें कि क्या परिणाम भी समान हैं और स्पष्ट रूप से प्रिंट

— पी। को पता है
स्रोत
2
क्या आप अपने कोड की कुछ व्याख्या करेंगे?
— मृत पोसुम
वास्तव में जल्द ही करेंगे
— पी। नॉप्स
1
आप ¨इसके बजाय उपयोग कर सकते हैं 1£।
— रिले
आपको समाप्ति ,, निहित आउटपुट की आवश्यकता नहीं है । इसके बजाय 2äआप द्विभाजित का उपयोग कर सकते हैं Â:; 12 के लिए 2 बाइट्स की बचत:ÐRQi¨}ȹRÈQ
— मैजिक ऑक्टोपस Urn
मैं द्विभाजित भाग का परीक्षण करूँगा, यह कुछ परिदृश्यों में अजीब तरह से व्यवहार करता है, लेकिन यह ,आपको मुख्य भाग में धकेलना चाहिए)।
— मैजिक ऑक्टोपस Urn
8

PHP, 55 52 बाइट्स

echo$p=strrev($n=$argn)==$n,$n-$n[$p*log($n,100)]&1;

STDIN से इनपुट लेता है; साथ चलाना -R।

उत्पादन:

  • 10 palindrome और समान समता के लिए
  • 11 palindrome और विभिन्न समता के लिए
  • 0 नॉन-पैलिंड्रोम और समान समानता के लिए
  • 1 नॉन-पलिंड्रोम और विभिन्न समता के लिए

टिप्पणियाँ:

  • strlen($n)/2== log($n,10)/2==log($n,100)
  • यदि palindrome, मध्य अंक की तुलना करें $n[1*log($n,100)]
  • यदि नहीं, तो पहला अंक $n[0*log($n,100)]
  • ... पूरी संख्या तक (<- सबसे कम बिट <- अंतिम अंक)
— टाइटस
स्रोत
आप sandbox.onlinephpfunctions.com/code/… के<?= बजाय का उपयोग करके एक बाइट को बचा सकते हैंecho
— roberto06
@ roberto06 $argnकेवल साथ परिभाषित किया गया है -R, और यह टैग की अनुमति नहीं देता है।
— टाइटस
ठीक है, नहीं पता था कि, धन्यवाद।
— रोबर्टो 06
@ roberto06 प्रतीक्षा करें ... $argnभी उपलब्ध है -F। लेकिन एन.एम.
— टाइटस
7

जेली , 16 14 बाइट्स

DµŒḂṄHC×LĊị+ḢḂ

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

आउटपुट दो लाइनें:

  • 1palindrome के लिए, 0नहीं के लिए
  • 0के लिए मुश्किल # 2 , 1नहीं करने के लिए

व्याख्या

DµŒḂṄHC×LĊị+ḢḂ    Main link. Argument: n (number)
D                 Get the digits of n
 µ                Start a new monadic chain
  ŒḂ              Check if the digit array is a palindrome (1 if yes, 0 if no)
    Ṅ             Print the result with a newline
     H            Halve (0.5 if palindrome, 0 if not)
      C           Subtract from 1 (0.5 if palindrome, 1 if not)
       ×          Multiply by...
        L         ...length of array (length/2 if palindrome, length if not)
         Ċ        Round up
          ị       Take item at that index from the digits
           +      Add...
            Ḣ     ...first item of digits
             Ḃ    Result modulo 2
— PurkkaKoodari
स्रोत
मैं हमेशा अपने आप से पूछती हूं, आपको इस से प्रोग्राम लिखने में सक्षम होने के लिए कितने अलग-अलग चरित्र सीखने होंगे? क्या आप सभी अर्थ और सभी वर्ण जानते हैं? क्या आप ALT कुंजी या वर्ण तालिका का उपयोग किए बिना भी वर्ण टाइप कर सकते हैं? इस तरह के लिए एक आईडीई क्या दिखता है?
— डैनियल डब्ल्यू।
3
@DanFromGermany मुझे अभी तक अधिकांश पात्र याद नहीं हैं। उसकी वजह से मुझे यूएस इंटरनेशनल कीबोर्ड लेआउट सीखने को नहीं मिला, इसलिए मैं सिर्फ विकी के किरदारों को कॉपी करता हूं । विकास TIO में परीक्षण और त्रुटि से होता है।
— पुरकाकूदरी
5

पावरशेल , 114 99 बाइट्स

param($n)((0,(($z=$n[0]%2)-eq$n[-1]%2)),(1,($z-eq$n[$n.length/2]%2)))[($n-eq-join$n[$n.length..0])]

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

15 बाइट्स @Sinusoid का धन्यवाद सहेजा गया।

एक स्ट्रिंग के रूप में इनपुट। एक प्रकार की सरणी को आउटपुट करता है (0|1) (True|False), 0जिसमें "नॉट ए पैलिंड्रोम" और 1"पैलिंड्रोम" का Trueसंकेत होता है , और संकेत समता मेल खाता है और Falseअन्यथा।

यह एक छद्म टर्नरी का उपयोग करके और उचित स्थान पर अनुक्रमण द्वारा किया जाता है (a,b)[index]। सूचकांक ($n-eq-join$n[$n.length..0])जांचता है कि क्या इनपुट एक पैलिंड्रोम है। यदि ऐसा नहीं है, हम ले aभाग है, जो एक है 0के साथ है कि क्या पहले अंक की समता युग्मित $n[0]है -eqपिछले अंक की समता के लिए UAL $n[-1]। अन्यथा, हम उस bहिस्से में हैं, जो एक 1युग्मित है कि क्या $z(पहले अंक -eqकी समता ) मध्य अंक की समता के लिए ual है $n[$n.length/2]।

इससे पहले, मुझे "$($n[0])"पूर्णांक के रूप में सही ढंग से कास्ट करने के लिए पहला अंक प्राप्त करना था , क्योंकि $n[0]ए charऔर II %मोड के charआधार पर modulo ऑपरेटर coalesces है , जो शाब्दिक मूल्य नहीं है, जबकि stringशाब्दिक मूल्य है। हालाँकि, @ सीनसॉइड ने मुझे यह देखने में मदद की0,1,2,...,9 शाब्दिक मूल्यों के रूप में सभी में समान समानता है 48,49,50,...,57, इसलिए यदि यह ASCII मूल्य का उपयोग करता है तो हमें अभी भी समान परिणाम मिलता है।

उस सरणी को पाइपलाइन पर छोड़ दिया गया है, और आउटपुट निहित है।

— AdmBorkBork
स्रोत
जिज्ञासा से बाहर, $आपको %2एक संख्या में मापांक करने पर दोहरे उद्धरण और एक अतिरिक्त का उपयोग क्यों करना पड़ा ? मैंने खुद यह कोशिश की और यह आवश्यक नहीं था अगर मैंने व्यक्तिगत रूप से प्रत्येक चरण किया था, लेकिन यह तब है जब आप इसे एक सरणी के अंदर रखते हैं? क्या शक्तियां इसे एक भिन्न चर प्रकार के रूप में मानती हैं?
— साइनसॉइड
@ साइनसॉइड यह एक स्ट्रिंग के रूप में इनपुट ले रहा है, इसलिए जब $n[0]अनुक्रमित होता है, तो यह ए के रूप में बाहर आता है char। से कलाकारों charके लिए intमजबूर %ऑपरेटर से जाना नहीं है '1'करने के लिए 1, लेकिन करने के लिए ASCII मूल्य है, इसलिए यह है 49। इसके "$( )"बजाय एक स्पष्ट कास्ट को स्ट्रिंग करता है, जो इसे ठीक से परिवर्तित करता है 1। ... हालांकि, अब है कि आप इसे का उल्लेख है, समता की 0..9ASCII रूप में ही है 48..57, तो मैं शायद गोल्फ कर सकते हैं कि नीचे। धन्यवाद!
— AdmBorkBork
@ साइनसॉइड 15 बाइट्स बचा, धन्यवाद!
— AdmBorkBork
3

VBA, 117 99 बाइट्स

टाइटस की बदौलत बचाए गए 18 बाइट्स

Sub p(s)
b=s
If s=StrReverse(s)Then r=2:b=Left(s,Len(s)/2+.1)
Debug.?r+(Left(s,1)-b And 1);
End Sub

एक बार स्वरूपित होने के बाद इसका अधिक विस्तार नहीं होता है:

Sub p(s)
    b = s
    If s = StrReverse(s) Then r = 2: b = Left(s, Len(s) / 2 + 0.1)
    Debug.Print r + (Left(s, 1) - b And 1);
End Sub

यहाँ दिए गए परीक्षण मामले के परिणाम हैं:

s = 12345678     p(s) = 1 = False False
s = 12345679     p(s) = 0 = False True
s = 12344321     p(s) = 3 = True False
s = 123454321    p(s) = 2 = True True
— इंजीनियर टोस्ट
स्रोत
क्या VBA में बिटवाइज़ ऑपरेटर हैं? &1इसके बजाय प्रयास करें mod 2। तुम भी या भी बेहतर के If/Thenसाथ छुटकारा मिल सकता है और ... और 2 बाइट्स के साथ ट्रिकी # 2: उलट ; इसे सीधे प्रिंट करने के साथ अधिक सहेजें :। तब 95 बाइट्स होना चाहिए; 98 अगर काम नहीं करता है। r=r+2-2*(left(s,1)-b &1)If s = StrReverse(s) then r=2r=r+1-(left(s,1)-b &1)r=r+(left(s,1)-b &1)Debug.Print r+(left(s,1)-b &1)&1
— टाइटस
@ धन्यवाद! मैं वास्तव में बिटवाइज़ ऑपरेशन से परिचित नहीं था। VBA में बिटवाइज़ ऑपरेशन होते हैं, लेकिन वे Andसिर्फ इसके बजाय उपयोग करते हैं &। मुझे पता चला कि आपके पहले सुझाव को कैसे लागू किया जाए लेकिन मैं यह पता नहीं लगा सका कि आप तीसरी पंक्ति को कैसे बदल सकते हैं StrReverse।
— इंजीनियर टोस्ट
Sub p(s);b=s;If s=StrReverse(s)Then r=2:b=Mid(s,Len(s)/2+.1,1);Debug.?r+(Left(s,1)-b&1);End Sub-> 0/2 पलिंड्रोम्स के लिए, 1/0 ट्रिकी # 2 के लिए
— टाइटस
ओह और आप के Mid()साथ Left(s,Len(s)/2+1)या तो बदलने में सक्षम होना चाहिए ।
— टाइटस
1
@Titus क्योंकि VBA बेवकूफ है और हमेशा 0.5 से गोल नहीं होता है। यह गोल-से-सम तर्क का उपयोग करता है। यदि स्ट्रिंग 9 वर्ण लंबा है, तो Len(s)/2= 4.5जो VBA के लिए गोल होगा 4। यदि यह 7 वर्ण लंबा है, तो Len(s)/2= 3.5जो VBA के लिए भी गोल होगा 4। जोड़ने 0.1से चंचलता ठीक होती है।
— इंजीनियर टोस्ट
3

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

{($/=.flip==$_),[==] .ords[0,($/??*/2!!*-1)]X%2}

कोशिश करो

में परिणाम (True True) (True False) (False True)या(False False)

विस्तारित:

{                  # bare block lambda with implicit parameter ｢$_｣

  (
    $/ =           # store in ｢$/｣
    .flip == $_    # is ｢$_｣ equal backwards and forwards
  ),


  [==]             # reduce the following using &infix:<==> (are they equal)

    .ords\         # list of ordinals (short way to make ｢$_｣ indexable)
    [
      0,           # the first digit's ordinal
      (
        $/         # if the first test is True (palindrome)
        ??   * / 2 # get the value in the middle
        !!   * - 1 # else get the last value
      )
    ]
    X[%] 2         # cross those two values with 2 using the modulus operator
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
3

जावा 8, 205 197 182 168 134 बाइट्स

n->{int l=n.length(),a=n.charAt(0)%2;return n.equals(new StringBuffer(n).reverse()+"")?a==n.charAt(l/2)%2?4:3:a==n.charAt(l-1)%2?2:1;}

आउटपुट: 1झूठे-झूठ के लिए; 2झूठे-सच्चे के लिए; 3सत्य-असत्य के लिए;4सच्चे-सच्चे के लिए।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

n->{                     // Method with String parameter and integer return-type
  int l=n.length(),      //  The length of the input String
      a=n.charAt(0)%2,   //  Mod-2 of the first digit
  return n.equals(new StringBuffer(n).reverse()+"")?
                         //  If the String is a palindrome
    a==n.charAt(l/2)%2?  //   And if the first and middle digits are both even/odd
     4                   //    return 4
    :                    //   Else
     3                   //    Return 3
   :a==n.charAt(l-1)%2 ? //  Else-if the first and last digits are both even/odd
    2                    //   Return 2
   :                     //  Else
    1;                   //   Return 1
}                        // End of method
— केविन क्रूज़सेन
स्रोत
1

हास्केल , 89 बाइट्स

(x:r)#y=mod(sum$fromEnum<$>[x,y])2
f x|reverse x/=x=2+x#last x|y<-length x`div`2=x#(x!!y)

इसे ऑनलाइन आज़माएं! उपयोग: f "12345"। ट्रू फल्स के लिए रिटर्न 0, 1सही गलत के लिए,2 झूठा सच के लिए और 3झूठा झूठा के लिए।

फ़ंक्शन #दोनों अंकीय वर्णों को अपने एससीआई वर्ण कोड में परिवर्तित करता है और उन्हें रकम देता है। यदि दोनों सम हैं या दोनों विषम हैं तो सम राशि भी होगी, अन्यथा यदि एक सम है और अन्य विषम सम विषम है। मोडुलो दो की गणना, समान समानता के लिए #रिटर्न 0और 1अन्यथा। fजाँचता है कि इनपुट स्ट्रिंग xएक पैलिंड्रोम है। यदि तब नहीं #कहा जाता है xऔर परिणाम के अंतिम वर्ण के साथ xऔर दो को जोड़ दिया जाता है, अन्यथा यदि इसके बजाय मध्य वर्ण के साथ xपैलंड्रोमिक कॉल #किया xजाता है और परिणाम को छोड़ दिया जाता है।

— Laikoni
स्रोत
1

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

fun Char.e()=toInt()%2==0;
val y=x.reversed()==x;val z=x.first();println("${y},${if(y)z.e()==x.get(x.length/2).e();else z.e()==x.last().e()}")

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

fun Char.e() = toInt() % 2 == 0; //character extension function, returns if character(as int) is even

val y = x.reversed() == x
val z = x.first()

println(
"${y} //returns whether or not input is a palindrome
, //comma separator between the values
${if(y) z.e() == x.get(x.length/2).e() // if it's a palindrome compare first and middle parity
else z.e() == x.last().e()}" //else compare first and last parity
)
— luminous_arbour
स्रोत
1

आरईएक्सएक्स, 104 100 बाइट्स

arg a
parse var a b 2''-1 c
e=a=reverse(a)
b=b//2
if e then f=b&centre(a,1)//2
else f=b&c//2
say e f

रिटर्न तार्किक मान जोड़ी 0 0, 0 1, 1 0या 1 1।

— idrougge
स्रोत
1

आर, 115 109 105 बाइट्स

w=strtoi(el(strsplit(scan(,""),"")))
c(p<-all(w==rev(w)),w[1]%%2==switch(p+1,tail(w,1),w[sum(1|w)/2])%%2)

स्टड से इनपुट लेता है। रिटर्न FALSE FALSEझूठी झूठी के लिए, FALSE TRUEझूठी यह सच है के लिए, TRUE FALSEयह सच है झूठा के लिए, और TRUE TRUEयह सच है यह सच है के लिए।

— rturnbull
स्रोत
1

AWK, 97 96 बाइट्स

{n=split($0,a,"")
for(;j<n/2;)s+=a[j+1]!=a[n-j++]
x=(a[1]%2==a[s?n:int(n/2)+1]%2)+(s?0:2)
$0=x}1

सरलतम उपयोग कोड को फ़ाइल में रखना है: OddEvenफिर करें:

awk -f OddEven <<< "some number here"

आउटपुट अनिवार्य रूप से प्रश्न में तुलना की बिट-योग है, उदाहरण के लिए

0, Not palindrome and first and last digits have different parity
1, Not palindrome and first and last digits have same parity 
2, Palindrome and the first digit and middle digit have different parity
3, Palindrome and the first digit and middle digit have same parity

मैं ()से हटाने की कोशिश की , (s?0:2)लेकिन यह किसी भी तरह से ऑपरेटर की प्रक्रिया को गड़बड़ कर देता है।

— रॉबर्ट बेन्सन
स्रोत
J पर वेतन वृद्धि को रोककर एक बाइट को बचाया। इसका मतलब यह है के लिए () एक समय () के साथ प्रतिस्थापित किया जा सकता है, लेकिन कोई बाइट्स ऐसा करने में :( बचाया जाएगा
— रॉबर्ट बेन्सन
1

सीजेएम, 32 बाइट्स

q:N_W%=N0=~2%NW=~2%N_,2/=~2%3$?=

इनपुट ढेर के शीर्ष पर एक संख्या है।

स्पष्टीकरण:

q                                 e# Read input:          | "12345679"
 :N                               e# Store in N:          | "12345679"
   _                              e# Duplicate:           | "12345679" "12345679"
    W%                            e# Reverse:             | "12345679" "97654321"
      =                           e# Check equality:      | 0
       N                          e# Push N:              | 0 "12345679"
        0=~                       e# First digit:         | 0 1
           2%                     e# Modulo 2:            | 0 1
             N                    e# Push N:              | 0 1 "12345679"
              W=~                 e# Get last digit:      | 0 1 9
                 2%               e# Modulo 2:            | 0 1 1
                   N              e# Push N:              | 0 1 1 "12345679"
                    _             e# Duplicate:           | 0 1 1 "12345679" "12345679"
                     ,            e# Length:              | 0 1 1 "12345679" 8
                      2/          e# Divide by 2:         | 0 1 1 "12345679" 4
                        =         e# Get digit (as char): | 0 1 1 '5
                         ~        e# Eval character       | 0 1 1 5
                          2%      e# Modulo 2:            | 0 1 1 1
                            3$    e# Copy stack element:  | 0 1 1 1 0
                              ?   e# Ternary operator:    | 0 1 1
                               =  e# Check equality:      | 0 1
— फल तोड़ना
स्रोत
1

ग्रूवी, 326 303 बाइट्स

श्रंक कोड:

String str="12345678";char pal,par;pal=str==str.reverse()?'P':'N';if(pal=='P'){par=(int)str.charAt(0).toString()%2==str.charAt((int)str.length()-1-(int)((str.length()-1)/2))%2?'S':'N'}else{par = (int)str.charAt(0).toString()%2==str.charAt((int)(str.length()-1)%2)?'S':'N'};print((String)pal+(String)par)

मूल कोड (स्पष्टीकरण के साथ):

Declare str as String                        String str = "12345678"
Declare pal and par as char                  char pal, par
Check if Palindrome or not                   pal = str==str.reverse()?'P':'N'
If Palindrome...                             if (pal=='P') {
and has same parity (S) and if not (N)       par = (int)str.charAt(0).toString()%2==str.charAt((int)str.length()-1-(int)((str.length()-1)/2))%2?'S':'N'
else if not palindrome...                    } else {
and has same parity (S) and if not (N)       par = (int)str.charAt(0).toString()%2==str.charAt((int)(str.length()-1)%2)?'S':'N'
closing tag for if                           }
Print desired output                         print((String)pal+(String)par)

मूल कोड (स्पष्टीकरण के बिना):

String str = "12345678"
char pal, par
pal = str==str.reverse()?'P':'N'
if (pal=='P') {
    par = (int)str.charAt(0).toString()%2==str.charAt((int)str.length()-1-(int)((str.length()-1)/2))%2?'S':'N'
} else {
    par = (int)str.charAt(0).toString()%2==str.charAt((int)(str.length()-1)%2)?'S':'N'
}
print((String)pal+(String)par)

इनपुट:

Just change "12345678" to another set of non-negative digits.

आउटपुट:

"PS" - Palindrome with Same Parity
"PN" - Palindrome with Diff Parity
"NS" - Non-palindrome with Same Parity
"NN" - Non-palindrome with Diff Parity
— जिमवेल एनोबॉन्ग
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.