पूरी तरह से palindromic त्रिकोण

Question

स्ट्रिंग पर विचार करें 160615051। इसे इस तरह "त्रिभुजित" किया जा सकता है:

  1
 606
15051

फिर, प्रत्येक पंक्ति एक palindrome है। यह भी ध्यान रखें कि परिधि पर प्रत्येक पक्ष भी एक ताल है:

  1  |   1   |   
 6   |    6  |      
1    |     1 | 15051 

इसलिए, इस स्ट्रिंग को पूरी तरह से पैलिंड्रोमिक त्रिकोण माना जा सकता है। 100इस मामले में ऊँचाई के बारे में चिंता न करें , इसके लिए तालमेल नहीं होना चाहिए।

इनपुट: मुद्रण योग्य ASCII वर्णों की एक स्ट्रिंग 0x20 से 0x7E तक। यह एक चरित्र सरणी, एक एकल स्ट्रिंग, या ASCII कोड बिंदुओं की एक सरणी हो सकती है। आपका इनपुट हमेशा त्रिभुजित होने में सक्षम होगा (अर्थात, इसकी लंबाई हमेशा एक पूर्ण वर्ग होगी)।

आउटपुट : एक सत्य मान यदि स्ट्रिंग पूरी तरह से पैलिंड्रोमिक त्रिकोण है, या अन्यथा एक गलत मूल्य है।

परीक्षण के मामलों

input => output

1 => true
A => true
AAAA => true
nope => false
{{}} => false
1101 => true
1011 => false
1202 => false
111110001 => true
160615051 => true
160625052 => false
1111111111111111 => true
1121123211234321123454321 => true
HHeHHeleHHellleHHellolleH => true
HellolleHHellleHHeleHHeHH => false
111111111111111111111111111111111111 => true
abcbdefeddefgfedbcdefedcbabcdefedcba => true

Answer 1

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

J’ƲœṗZ⁻¦µU⁼

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

पृष्ठभूमि

हम इनपुट स्ट्रिंग के 0-आधारित सूचकांकों को देखकर शुरू करते हैं।

 H  H  e  H  H  e  l  e  H  H  e  l  l  l  e  H  H  e  l  l  o  l  l  e  H
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

त्रिकोण की पंक्तियों को प्राप्त करने के लिए, हम 1 , 1 + 3 = 4 , 1 + 3 + 5 = 9 , और 1 + 3 + 5 + 7 = 16 सूचकांकों से पहले स्ट्रिंग को विभाजित कर सकते हैं । चूंकि (n + 1) ² = n² + (2n + 1) , ये रकम इंडेक्स सूची में सकारात्मक, पूर्ण वर्ग हैं। यदि हम 0 से पहले स्ट्रिंग को विभाजित करते हैं , तो यह सभी 0-आधारित सूचकांकों से पहले विभाजन के रूप में सरल है जो एकदम सही वर्ग हैं।

विभाजन के बाद, हमें निम्नलिखित तार मिलते हैं।

""
"H"
"HeH"
"HeleH"
"HellleH"
"HellolleH"

अगला, हम पहले कॉलम के सभी पात्रों के साथ शुरुआत में खाली स्ट्रिंग को बदलते हैं।

"HHHHH"
"H"
"HeH"
"HeleH"
"HellleH"
"HellolleH"

कार्य अब यह जांचने के लिए कम हो गया है कि क्या सभी तारों को उलटने से एक ही स्ट्रिंग सरणी प्राप्त होती है।

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

पहले Jइनपुट स्ट्रिंग के सभी 1-आधारित सूचकांकों को उत्पन्न करता है J, फिर ’सभी 0-आधारित सूचकांकों को प्राप्त करने के लिए उन्हें घटाता है । Ʋस्क्वरनेस के लिए सभी 0-आधारित सूचकांकों का परीक्षण करता है। ऊपर से हमारे उदाहरण के लिए, यह निम्नलिखित बूलियन सरणी देता है।

 1  1  0  0  1  0  0  0  0  1  0  0  0  0  0  0  1  0  0  0  0  0  0  0  0

अगला, हम œṗइनपुट स्ट्रिंग को विभाजित करने के लिए कॉल करते हैं, उदाहरण के लिए,

 H  H  e  H  H  e  l  e  H  H  e  l  l  l  e  H  H  e  l  l  o  l  l  e  H

सभी 1 के पहले (वास्तव में, सभी सत्य तत्व)। हमारे उदाहरण के लिए, यह निम्नलिखित स्ट्रिंग सरणी देता है।

['', 
 'H',
 'HeH',
 'HeleH',
 'HellleH',
 'HellolleH'
]

Z⁻¦यकीनन इस जवाब का सबसे दिलचस्प हिस्सा है। आइए Z1¦पहले अधिक सरल का विश्लेषण करें ।

¦है विरल त्वरित। यह स्टैक से दो लिंक खा जाता है, विशेष रूप से 1और Zइस मामले में। पहले Zइसके तर्क पर लागू किया जाता है: स्ट्रिंग सरणी पहले से। Zहै जिप परमाणु और स्तंभों द्वारा स्ट्रिंग सरणी / 2 डी चरित्र सरणी पढ़ता है, उपज

['HHHHH',
 'eeee',
 'Hlll',
 'ell',
 'Hlo',
 'el',
 'Hl',
 'e',
 'H'
]

क्या इनपुट स्ट्रिंग के बाईं ओर हुआ करता था और स्ट्रिंग सरणी का पहला कॉलम अब पहला स्ट्रिंग बन जाता है ।

अब ¦पेशाब करता है 1और एक ही इंडेक्स पाता है: १ । इस प्रकार मूल स्ट्रिंग सरणी में पहला स्ट्रिंग बदले के पहले मान के साथ बदल जाता है Z; अन्य सूचकांकों पर तार अप्रभावित रहते हैं।

['HHHHH',
 'H',
 'HeH',
 'HeleH',
 'HellleH',
 'HellolleH'
]

चलो इस सरणी को A कहते हैं ।

हमने Z⁻¦इसके बजाय उपयोग किया Z1¦, लेकिन इससे कोई फर्क नहीं पड़ता: ⁻असमानता के लिए इनपुट स्ट्रिंग के साथ स्ट्रिंग सरणी की तुलना करें, 1 के बाद से बराबर नहीं हैं। दोनों के बीच अंतर यह है कि Z⁻¦डाइएडिक ⁻है, क्योंकि हमें œṗZ⁻¦इसके बजाय लिखने की अनुमति है œṗ¹Z1¦। इसका कारण यह है कि एक सनक ( œṗ) के बाद एक भिक्षु ( œṗ¹Z1¦) एक कांटा होता है (भिक्षु को श्रृंखला के तर्क / इनपुट स्ट्रिंग पर लागू किया जाता है, और लौटाया गया मान सही तर्क के रूप में पारित किया जाता है œṗ), जबकि एक रंगा दूसरे रंग का होता है (या श्रृंखला के अंत में) एक है हुक , यानी, अपने अधिकार तर्क श्रृंखला के तर्क है।

यह सब करने के लिए छोड़ दिया है palindromicness के लिए जाँच करें। µएक नई (विवादास्पद) श्रृंखला शुरू करता है, जिसका तर्क A है । समाप्त कर देना परमाणु Uमें सभी स्ट्रिंग्स पराजयों एक (लेकिन एक ही), तो ⁼परिणाम के साथ तुलना एक समानता के लिए। लौटाया गया बूलियन 1 पूरी तरह से पैलिंड्रोमिक त्रिकोण को इंगित करता है; अन्य तार 0 पर वापस आ जाएंगे ।

Comments

मुझे वास्तव में जेली को पढ़ना सीखना चाहिए। (स्पष्टीकरण, कृपया?)

— CAD97

मैंने अपना उत्तर संपादित कर दिया है।

— डेनिस

Answer 2

जाप , 25 21 17 बाइट्स

सहेजे गए 2 बाइट @obarakon की बदौलत

ò@°T ¬v1
pUmg)eêP

इसे ऑनलाइन टेस्ट करें!

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

 ò@  ° T ¬ v1   // Implicit: U = input string, T = 0
UòXY{++T q v1}  // First line; reset U to the result of this line.
UòXY{        }  // Partition U at indices where
     ++T q      //   the square root of T incremented
           v1   //   is divisible by 1.
                // This breaks U at square indices, giving rows of 1, 3, 5, ... chars.
 pUmg)eêP
UpUmg)eêP
  Umg           // Take the first char of every item of U.
Up   )          // Append this to U.
      e         // Check that every item in the resulting array
       êP       // is a palindrome.
                // Implicit: output result of last expression

ध्यान दें कि हमें दोनों पक्षों की जांच करने की आवश्यकता नहीं है ; यदि पक्ष समान नहीं हैं, तो पंक्तियों में से कम से कम एक तालबद्ध नहीं है।

Comments

यह इस बहुस्तरीय बात को जाप की एक नई विशेषता है?

— ल्यूक

@ ल्यूक हाँ, मैंने इसे मंगलवार को जोड़ा। इसे दिखाने का मेरा यह पहला मौका है :-)

— ETHproductions

मेरे गोल्फ टिप पर कभी ध्यान न दें। यह बस जाँच करें कि क्या प्रत्येक रेखा पैलिंड्रोमिक थी, जो सही परिणाम देने के लिए भी हुई ...

— ल्यूक

Answer 3

05AB1E , 18 बाइट्स

gÅÉ£õÜÐíQs€¬āÈÏÂQ*

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Comments

आप एक बाइट को थोड़ा संशोधित करके बचा सकते हैंgÅÉ£ÐíQs€¬āÈÏJÂQ*

— कलसवरस

gÅÉ£आप लोमड़ी की तरह ... मैं उन लोगों को कम list-commands.py

— आंकता

Answer 4

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

J²‘Ṭœṗ⁸ZḢ$ṭ$ŒḂ€Ạ

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

तुच्छ के लिए जोनाथन एलन के लिए धन्यवाद, लेकिन इतना स्पष्ट -2 बाइट बचत नहीं है।

Comments

मेरे त्रिकोण निर्माण का उपयोग करें और बाइट को बचाएं:JƲ0;œṗ⁸ZḢ$ṭ$ŒḂ€Ạ

— जोनाथन एलन

... वास्तव में उस विचार को असत्य के साथ जोड़ दें और एक अन्य बाइट को बचाएं, क्योंकि विभाजन "ज़िप सबसे छोटा" होगा:J²‘Ṭœṗ⁸ZḢ$ṭ$ŒḂ€Ạ

— जोनाथन एलन

@JonathanAllan उम्म ... मुझे आखिर इसकी आवश्यकता क्यों है ½? अब Jऔर अधिक समझ में आता है ...

— एरिक आउटगोल्फर

Answer 5

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

f=(s,n=1,t='',u='',g=([...a])=>''+a==a.reverse())=>s?g(s.slice(0,n))&f(s.slice(n),n+2,t+s[0],u+s[n-1]):g(t)&g(u)

tऔर uपक्षों को इकट्ठा करें ताकि उन्हें अंत में परीक्षण किया जा सके।

Answer 6

सी #, 184 बाइट्स

using System.Linq;
b=a=>string.Concat(a.Reverse())==a
f=>{string c=f[0]+"",d=c,e="";for(int i=1,k=1,s=f.Length;i<s;)
{c+=f[i];d+=f[(i+=k+=2)-1];e=f.Substring(s-k);}return b(c)&b(d)&b(e);}

सोचा था कि समाधान अच्छा लग रहा था जब तक कि मैं पैलिंड्रोम भाग को नहीं मिला

Ungolfed संस्करण:

Func<string, bool> b = a => string.Concat(a.Reverse()) == a;
        Func<string, bool> func = f => {

            string c = f[0] + "", d = c, e = "";

            for (int i = 1, k = 1, s = f.Length; i < s;) {
                c += f[i];
                d += f[(i += k += 2) - 1];
                e = f.Substring(s - k);
            }

            return b(c) & b(d) & b(e);
        };

Comments

क्या आप e=..बाइट बचाने के लिए लूप लाइन के लिए आगे बढ़ सकते हैं ? बाइट की गिनती में नए अंक गिनने की कोई आवश्यकता नहीं है इसलिए मैं मान रहा हूं कि आप नहीं हैं।

— TheLethalCoder

नहीं, मैं नए सिरे से गिनती नहीं कर रहा हूं, मैं ई को लूप में स्थानांतरित नहीं कर सकता क्योंकि मुझे रिटर्न स्टेटमेंट में इसकी आवश्यकता है।

— लीफडेवेन जू

मेरा मतलब इस तरह था....; i < s;e = f.Substring(s - k)){c+=....

— TheLethalCoder

Answer 7

जावा 8, 358 301 बाइट्स

import java.util.*;s->{List<String>l=new Stack();for(int i=0,p=1,t=1;p<=s.length();p+=t+=2)l.add(s.substring(i,i=p));String a="",b=a;for(String q:l){a+=q.charAt(0);b+=q.charAt(q.length()-1);}return p(a)&p(b)&p(l.get(l.size()-1));}boolean p(String s){return s.equals(new StringBuffer(s).reverse()+"");}

इनपुट एक है String, आउटपुट एक है boolean।

स्पष्टीकरण:

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

import java.util.*;               // Required import for List and Stack

s->{                              // Method (1) with String parameter and boolean return-type
  List<String>l=new Stack();      //  Create a String-list
  for(int i=0,p=1,t=1;            //  Initialize some index/counter integers
      p<=s.length();              //  Loop (1) over the String in sections
      p+=t+=2)                    //    And increase `p` like this after every iteration: 1,4,9,16,25,etc.
    l.add(s.substring(i,i=p));    //   And add a substring-section to the list (0,1 -> 1,4 -> 4,9 -> 9,16 -> etc.)
                                  //  End of loop (1) (implicit / single-line body)
  String a="",b=a;                //  Two temp Strings
  for(String q:l){                //  Loop (2) over the list
    a+=q.charAt(0);               //   And append the first character to String `a`
    b+=q.charAt(q.length()-1);    //   And the last character to String `b`
  }                               //  End of loop (2)
  return p(a)                     //  Return if String `a` is a palindrome
        &p(b)                     //   as well as String `b`
        &p(l.get(l.size()-1));    //   as well as the last String in the list
}                                 // End of method (1)

boolean p(String s){              // Method (2) with String parameter and boolean return-type
  return s.equals(new StringBuffer(s).reverse()+"");
                                  //  Return if this String is a palindrome
}                                 // End of method (2)

Answer 8

जेली ,  20  21 बाइट्स

+2 बाइट्स - मैंने बग्गी कोड जारी किया :(
-1 बाइट - विषम पूर्णांक जैसे मोल्डिंग से स्क्वायर इंडेक्स पर विभाजन के लिए ले जाया गया

JƲ0;œṗ⁸ZḢ$ṭ$ŒḂ€Ạ

पात्रों की एक सूची को स्वीकार करने और लौटने 1(सत्य) या 0(फाल्सी) के लिए एक राक्षसी लिंक।
नोट: यह विनिर्देश के उस भाग का उपयोग करता है जो इनपुट को एक वर्ग लंबाई तक सीमित करता है।

इसे ऑनलाइन आज़माएं! या परीक्षण सूट देखें।

17 बाइट्स को यह देखते हुए सरल किया जा सकता है कि यदि सभी पंक्तियाँ केवल एक "साइड" चेकिंग ( JƲ0;œṗ⁸ZḢ$ṭ$ŒḂ€Ạ) की आवश्यकता होती हैं , हालांकि एरिक आउटलेफ़र ने पहले ही इस तथ्य पर ध्यान दिया और अपने उत्तर में इसका इस्तेमाल किया, इसलिए मैंने उन्हें बचाने के लिए त्रिकोण निर्माण विधि दी है। वहाँ एक बाइट।

इसके अतिरिक्त, यह बदले में 16 बाइट्स में सुधार किया जा सकता है यह देखते हुए कि सत्य अनुक्रमित पर विभाजन बाईं ओर तर्क ( J²‘Ṭœṗ⁸ZḢ$ṭ$ŒḂ€Ạ) में अधिक होने पर कोई आपत्ति नहीं करता है ।

कैसे?

JƲ0;œṗµ2BịЀ⁸Z;⁸ŒḂ€Ạ - Link: list, a      e.g. "abcbazxza"
J                     - range of length of a  = [1,2,3,4,5,6,7,8,9]
 Ʋ                   - is square? (vectorises) [1,0,0,1,0,0,0,0,1]
   0;                 - prepend a zero        [0,1,0,0,1,0,0,0,0,1]
     œṗ               - partition a at 1s     ["a","bcb","azxza"]
       µ              - monadic chain separation, call that t
        2B            - 2 in binary = [1,0]
             ⁸        - chain's left argument, t
          ịЀ         - map with index into    ["aa","bb","aa"] (1st and last of each of t)
              Z       - transpose              ["aba","aba"] (left and right "sides" of t)
               ;⁸     - concatenate t          ["aba","aba","a","bcb","azxza"]
                 ŒḂ€  - palindromic? for €ach  [1,1,1,1,1]
                    Ạ - all?                   1

Comments

डारन, मैं जेली उत्तर देने ही वाला था। हालांकि तकनीकी रूप से मेरा गलत है और लंबे समय तक दो बार ... अच्छा काम :): पी

— हाइपरन्यूट्रीनो

"पढ़ने वाले से पहले भी देखा गया कि" सत्यवाचक अनुक्रमों में विभाजन करने से कोई फर्क नहीं पड़ता है अगर वामपंथी तर्क में अधिकता है "।

— आउटगोल्फ

Answer 9

गणितज्ञ, 156 बाइट्स

B=StringTake;Count[PalindromeQ/@Join[A=Table[B[#,{i^2+1,(i+1)^2}],{i,0,(s=Sqrt@StringLength@#)-1}],{StringJoin@Table[B[A[[i]],1],{i,Length@A}]}],True]==s+1&

इनपुट

[ "1101"]

Comments

क्या तुम If[<stuff>, True, False]सिर्फ साथ नहीं बदल सकते <stuff>? और मुझे लगता And@@(...)है कि इससे छोटा है Count[...,True]==s, जिसका अर्थ यह भी है कि आपको sएक चर के रूप में परिभाषित करने की आवश्यकता नहीं है ।

— पेड़ नहीं

रुको, क्या यह वास्तव में विकर्णों का परीक्षण करता है? मुझे परीक्षण मामलों ( "1202"और "160625052") के एक जोड़े के लिए झूठी सकारात्मक बातें मिल रही हैं ।

— पेड़ नहीं

सभी समस्याएं

— J42161217

Answer 10

PHP , 97 बाइट्स

for($t=1;~$s=substr($argn,$i**2,$i++*2+1);$d.=$s[0])$t&=strrev($s)==$s;$t&=strrev($d)==$d;echo$t;

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

Comments

रुको, क्या यह वास्तव में विकर्णों का परीक्षण करता है? मुझे परीक्षण मामलों के एक जोड़े के लिए झूठी सकारात्मकता मिल रही है ("1202" और "160625052")।

— J42161217

@ जेनी_मैथी अब यह काम करती है

— जार्ज ह्यूल्सरमैन

Answer 11

जावा, 136 बाइट्स

l->{for(int i=0,j,k=1;i<l.size();i=j,k+=2)if(!l.subList(i,j=i+k).equals(l.subList(i,j).asReversed().toList()))return false;return true;}

MutableList<Character>ग्रहण संग्रह से उपयोग करता है

Function<MutableList<Character>, Boolean> func = l->{
   for(int i=0,j,k=1;i<l.size();i=j,k+=2)  // `i` is the start index, `j` is the end index, `k` increments by 2
       if(!l.subList(i,j=i+k).equals( //Check that the first partition equals
           l.subList(i,j).asReversed().toList())  // The same sublist reversed
       )
       return false;
   return true;
};

Answer 12

पर्ल 5 , 81 + 1 ( -p) = 82 बाइट्स

$a[0].=$1while($a[++$q]=substr$_,0,($#i+=2),'')=~/(.)/;$\||=$_ ne reverse for@a}{

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

undefसच के लिए आउटपुट (यानी, रिक्त, रिक्त), झूठे के लिए कोई भी संख्या

Answer 13

एक्सेल VBA, 87 बाइट्स

बेनामी VBE तत्काल विंडो फ़ंक्शन जो सेल से इनपुट लेता है [A1]और VBE तत्काल विंडो में आउटपुट करता है

k=1:For i=1To[Len(A1)^.5]:s=Mid([A1],j+1,i*2-1):j=j+i*2-1:k=k*(s=StrReverse(s)):Next:?k

Answer 14

अजगर 2 , 128 118 115 बाइट्स

def f(s):
 w=1;l=r='';b=[]
 while s:l+=s[0];r+=s[w-1];b+=[s[:w]];s=s[w:];w+=2
 print all(d==d[::-1]for d in[l,r]+b)

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