Bir palindrom, kendi tersi olan bir kelimedir.

Şimdi, palindromlara benzeyen fakat olmayan bazı kelimeler var. Kelimesini düşünün Örneğin sheesh, sheeshonun tersi olduğundan bir palindrom değil hseehsfarklı olan düşündüğümüz ancak eğer sho zaman ters olmasıdır, tek harf olmak sheesh. Bu tür bir kelimeye yarı palindrom diyeceğiz.

Özellikle, bir kelime yarı palindromdur, eğer kelimeyi bazı parçalara bölersek, parçaların sırası tersine çevrildiğinde orijinal kelime oluşmuş olur. ( sheeshBu parçalar için sh e e sh) Ayrıca, hiçbir yığın kelimenin kelimenin iki yarısından da harf içermesini gerektirmeyecektir (aksi halde her kelime yarı palindrom olur). Örneğin rear, yarı palindrom değildir r ea r, çünkü eaorijinal kelimenin iki tarafından da harfleri içeren bir yığın ( ) vardır. Tuhaf uzunluktaki bir kelimenin merkez karakterini kelimenin iki tarafında da görüyoruz, bu nedenle tuhaf uzunluktaki kelimeler için merkez karakterinin her zaman kendi öbeklerinde olması gerekir.

Göreviniz pozitif tamsayıların bir listesini almak ve bunların yarı palindrom olup olmadıklarını belirlemek olacaktır. Kodunuz, eğer biri yarı palindrom, diğeri ise, iki tutarsız eşitsiz değer vermelidir. Bununla birlikte, kodunuzun byte dizisinin kendisi yarı palindrom olmalıdır .

Yanıtlar, baytlarda daha az bayt daha iyi olacak şekilde puanlanacaktır.

Test-vakalar

[] -> True
[1] -> True
[2,1,2] -> True
[3,4,2,2,3,4] -> True
[3,5,1,3,5] -> True
[1,2,3,1] -> False
[1,2,3,3,4,1] -> False
[11,44,1,1] -> False
[1,3,2,4,1,2,3] -> False

Daha fazla test penceresi oluşturmak için program.

Borri , bunların genelleştirilmiş Smarandache palindromlarına benzer olduğunu belirtti . Bu yüzden biraz daha okuma yapmak istiyorsan, başlaman gereken bir yer var.

Retina 0.8.2 , 85 69 bayt

M`^(.+,)*(\d+,)?(?<-1>\1)*$(?(1)^)|M`^(.+,)*(\d+,)?(?<-1>\1)*$(?(1)^)

Çevrimiçi deneyin! Açıklama:

M`

Maç modunu seçer. Aslında, Retina, tek satırlık bir program için Eşleştirme moduna varsayılandır, ancak kodun ikinci kopyası bu ilave karakterler için olmasa da daima eşleşir.

^

Maç başında başlamalıdır.

(.+,)*

Birkaç karakter dizisi yakalayın. Her çalıştırma virgülle bitmelidir.

(\d+,)?

İsteğe bağlı olarak bir rakam koşusu ve virgülle eşleştirin.

(?<-1>\1)*

İsteğe bağlı olarak, yakalananların hepsini ters sırayla eşleştirin ve her birini eşleştiği şekilde fırlatın.

$

Maç sonunda bitmelidir.

(?(1)^)

Yakalamaların tümü patlatılmadıkça geri izleme. Elde edebileceğimiz bir yakalama yoksa, imkansız olan bir yakalama varsa, eşleşmenin hala dizenin başında olmasını gerektirir.

Jöle , 27 23 bayt

ṖUṁ@Ƒ€ṚẸHḢŒŒHḢŒṖUṁ@Ƒ€ṚẸ

Yarı palindromlar için 1 döndürür , 0 , aksi.

Çevrimiçi deneyin!

Nasıl çalışır

ṖUṁ@Ƒ€ṚẸHḢŒŒHḢŒṖUṁ@Ƒ€ṚẸ  Main link. Argument: A (array)

          Π             Invalid token. Everything to its left is ignored.
           ŒH            Halve; divide A into two halves similar lengths. The middle
                         element (if there is one) goes into the first half.
             Ḣ           Head; extract the first half.
              ŒṖ         Generate all partitions of the first half.
                U        Upend; reverse each chunk of each partition.
                         Let's call the result C.

                     Ṛ   Yield R, A reversed.
                   Ƒ€    Fixed each; for each array P in C, call the link to the left
                         with arguments P and R.
                         Return 1 if the result is P, 0 if not.
                 ṁ@          Mold swapped; replace the n integers of C, in reading
                             order, with the first n integers of R.
                     Ẹ   Exists; check if one of the calls returned 1.

Python 2 , 157 153 147 143 bayt

Tsh sayesinde -4 bayt .

s=lambda x,i=0:len(x)<2or[]<x[i:]and(x[-i:]==x[:i])&s(x[i:-i])|s(x,i+1)
s=lambda x,i=0:len(x)<2or[]<x[i:]and(x[-i:]==x[:i])&s(x[i:-i])|s(x,i+1)

Çevrimiçi deneyin!

05AB1E , 59 47 43 41 bayt

2äøø€.œ`âʒ`RQ}gĀIg_^q2äøø€.œ`âʒ`RQ}gĀIg_^

@Emigna sayesinde -12 bayt .

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

2ä               # Split the input into two parts
                 #  i.e. [3,4,2,0,2,3,4] → [[3,4,2,0],[2,3,4]]
  øø             # Zip twice without filler
                 # This will remove the middle item for odd-length inputs
                 #  i.e. [[3,4,2,0],[2,3,4]] → [[3,2],[4,3],[2,4]] → [[3,4,2],[2,3,4]]
    €.œ          #  Then take all possible partitions for each inner list
                 #   i.e. [[3,4,2],[2,3,4]]
                 #    → [[[[3],[4],[2]],[[3],[4,2]],[[3,4],[2]],[[3,4,2]]],
                 #       [[[2],[3],[4]],[[2],[3,4]],[[2,3],[4]],[[2,3,4]]]]
`                # Push both lists of partitions to the stack
 â               # Take the cartesian product (all possible combinations) of the partitions
                 #  i.e. [[[[3],[4],[2]],[[2],[3],[4]]],
                 #        [[[3],[4],[2]],[[2],[3,4]]],
                 #        ...,
                 #        [[[3,4,2]],[[2,3,4]]]]
  ʒ   }          # Filter this list of combinations by:
   `             #  Push both parts to the stack
    RQ           #  Check if the second list reversed, is equal to the first
                 #   i.e. [[3,4],[2]] and [[2],[3,4]] → 1 (truthy)
       gĀ        # After the filter, check if there are any combinations left
                 #  i.e. [[[[3,4],[2]],[[2],[3,4]]]] → 1 (truthy)
         Ig_     # Check if the length of the input was 0 (empty input-list edge-case)
                 #  i.e. [3,4,2,0,2,3,4] → 7 → 0 (falsey)
            ^    # Bitwise-XOR
                 #  i.e. 1 XOR 0 → 1 (truthy)
             q   # Stop the program (and then implicitly output the top of the stack)
2äøø€.œ`âʒ`RQ}gĀIg_^
                 # Everything after the `q` are no-ops to comply to the challenge rules

05AB1E , 37 bayt

Jonathan'ın ortaya çıkardığı teknikle aşağı yukarı aynı tekniği kullanır .

.œʒ€gηOZ;îå}εÂQ}ZĀqĀZ}QÂε}åî;ZOηg€ʒ.œ

Çevrimiçi deneyin!

.œʒ€gηOZ;îå}εÂQ}ZĀqĀZ}QÂε}åî;ZOηg€ʒ.œ

Tam program STDIN'den bir liste alır, 1 veya 0'ı STDOUT'a çıkar.

.œʒ        }

Filtreleme bölümleri tatmin edici ...

   €gηOZ;îå

Bu koşul: Her ( €g) 'nin uzunlukları , ön ekleri ( η) sonra Otoplanan ( ) bir listede saklanır , bu nedenle bize uzunluk listesinin kümülatif toplamını verir. Ardından, bu listenin maksimumunun tavandaki yarısı yığının üzerine itilir - ancak orijinal listenin üzerinde de tutulması ( Z;î) ve eğer varsa ( å) kümülatif toplamlarda ( ) ise, truthy döner.

εÂQ}

Her biri için, karşılaştırma ( Q) bir ile bir yığındaki ayrı itildiği, ters Â. 0 s ve 1 s listesini döndürür .

ZĀq

Maksimum. Herhangi bir gerçek değilse, o zaman 1 başka 0 . Yürütmeyi sonlandır. Takip eden her şey tamamen göz ardı edilir.

Piton 2 , 275 251 205 bayt

@KevinCruijssen sayesinde -24 bayt

@PostLeftGhostHunter sayesinde -44 bayt

@KevinCruijssen sayesinde -2 bayt daha

def s(x):
 l=len(x)
 if l<2:return 1>0
 for i in range(1,l/2+1):
	if x[l-i:]==x[:i]:return s(x[i:l-i])
def s(x):
 l=len(x)
 if l<2:return 1>0
 for i in range(1,l/2+1):
	if x[l-i:]==x[:i]:return s(x[i:l-i])

Yarı palindrom için True döndürür, aksi takdirde Yok

Çevrimiçi deneyin!

Jöle ,  33  32 bayt

-1 Outgolfer Erik sayesinde Jelly’e
uygulama detayını değiştirme ve hata düzeltme için Dennis’e de teşekkür ederiz.

ẸƇŒḂƇƊ$ƊĊHṀċÄẈṖŒŒṖẈÄċṀHĊƊ$ƊƇŒḂƇẸ

Yarı palindromlar 1, diğerleri verir 0.

$O(2^n)$

Veya test odasına bakın .

Tek parçalar olarak ŒḂler ({3 ^üncü ve 4 ^th {vs 29} ^inci ve 30 ^inci bayt}), sadece ayrıştırma için kod sağlamak için.

Nasıl?

Tüm iş sağ taraf - "Ana Bağlantı" tarafından gerçekleştirilir:

ŒṖẈÄċṀHĊƊ$ƊƇŒḂƇẸ - Main Link: list
ŒṖ               - all partitions
           Ƈ     - filter keep those for which this is truthy (i.e. non-zero):
          Ɗ      -   last three links as a monad:
  Ẉ              -     length of each
         $       -     last two links as a monad:
   Ä             -       cumulative addition
        Ɗ        -       last three links as a monad:
     Ṁ           -         maximum
      H          -         halve
       Ċ         -         ceiling
    ċ            -     count
              Ƈ  - filter keep those for which this is truthy:
            ŒḂ   -   is palindrome?
               Ẹ - any?

Perl 6 , 87 79 bayt

-Jo King'in cevabından bazı hileler ile 8 bayt

$!={/\s/&&/^(.+)\s[(.+)\s]*$0$/&&$1.$!}#$!={/\s/&&/^(.+)\s[(.+)\s]*$0$/&&$1.$!}

Çevrimiçi deneyin!

Tsh’in JavaScript cevabı limanı. İki farklı Regex nesnesi döndürür.

Ruby , 129 bayt

f=->l{!l[1]||(1...l.size).any?{|x|l[0,x]==l[-x,x]&&f[l[x..~x]]}}#f=->l{!l[1]||(1...l.size).any?{|x|l[0,x]==l[-x,x]&&f[l[x..~x]]}}

Çevrimiçi deneyin!

JavaScript (Node.js) , 139 bayt

f=a=>(s=(''+a).replace(/^(.*),((.*),)?\1$/,'$3'))!=a?f(s):/,/.test(s)//^(.*),((.*),)?\1$/,'$3'))!=a?f(s):/,/.test(s)f=a=>(s=(''+a).replace(

Çevrimiçi deneyin!

C (gcc) (X86), 216 bayt

p(L,a,n)int*a;{return n?(memcmp(a,a+L-n,n*4)|p(L-2*n,a+n,L/2-n))&&p(L,a,n-1):1<L;}
#define p(L,a)p(L,a,L/2)//p(L,a,n)int*a;{return n?(memcmp(a,a+L-n,n*4)|p(L-2*n,a+n,L/2-n))&&p(L,a,n-1):1<L;}
#define p(L,a)p(L,a,L/2)

Çevrimiçi deneyin!

p(L,a,n)auzunluk dizisi Lyarı palindrom ise 0 değerini , aksi takdirde 1 döndürür. Tüm uzunluk öneklerinin >nönceden işaretlenmiş olması durumunda, uzunluk önekini uzunluk nsonekiyle karşılaştırır n.p(L,a)Giriş noktası

Ne yazık ki, daha ilginç bir çözüm daha uzun:

224 bayt

(f(L,a,n))//#define p(L,a)(n=L/2,
int*a,n;
{return n?(memcmp(a,a+L-n,n*4)|f(L-2*n,a+n,L/2-n))&&f(L,a,n-1):1<L;}//{return n?(memcmp(a,a+L-n,n*4)|f(L-2*n,a+n,L/2-n))&&f(L,a,n-1):1<L;}
int*a,n;
#define p(L,a)(n=L/2,f(L,a,n))//(

Çevrimiçi deneyin!

Ungolfed:

(f(L,a,n)) //#define p(L,a)(n=L/2,
int*a,n;
{
  return n 
    ? (memcmp(a, a+L-n, n*4) | f(L-2*n, a+n, L/2-n)) &&
      f(L,a,n-1)
    : 1 < L;
} // { ... } 
int*a,n;
#define p(L,a)(n=L/2,f(L,a,n)) //(

Japt , 66 bayt

@¯X eUsXn}a1 "
ʧV?UÊ<2:ßUéV sVÑ
@¯X eUsXn}a1 "
ʧV?UÊ<2:ßUéV sVÑ

Japt Tercüman

Bu sürümde büyük gelişme, aslında pratik dillerin çoğunu şimdi atıyor. Önceki yöntemde hata olduğundan, şimdi bir tamsayı dizisi üzerinde çalışır.

Açıklama:

@        }a1         Find the first number n > 0 such that...
 ¯X                   the first n elements
     UsXn             and the last n elements
    e                 are the same

"
ʧV?UÊ<2:ßUéV sVÑ    String literal to make it a Semi-palindrome
@¯X eUsXn}a1 "

ʧV?                 If n >= length of input...
    UÊ<2              return true if the length is less than 2
        :            Otherwise...
          UéV         move n elements from the end of the input to the start
              sVÑ     remove the first 2*n elements
         ß            and repeat on the remaining elements

PHP 237 bayt

function f($a){for($x=2>$c=count($a);++$i<=$c/2;)$x|=($s=array_slice)($a,0,$i)==$s($a,-$i)&f($s($a,$i,-$i));return$x;}#function f($a){for($x=2>$c=count($a);++$i<=$c/2;)$x|=($s=array_slice)($a,0,$i)==$s($a,-$i)&f($s($a,$i,-$i));return$x;}

özyinelemeli işlevi, true(ikiden daha az eleman içeren giriş için) veya 1gerçeği,
0sahte için döndürür. Çevrimiçi deneyin (arıza içerir).

Gerçek kod uzunluğu 118 bayttır; yarı palindrom kod çoğaltma yoluyla oluşturuldu.

Daha iyi performans için, önce &ile değiştirin &&ve yerleştirin .!$x&&++$i

Scala, 252 bayt

def^(s:Seq[Int]):Int={val l=s.size;if(l>1)(1 to l/2).map(i=>if(s.take(i)==s.takeRight(i))^(s.slice(i,l-i))else 0).max else 1}//def^(s:Seq[Int]):Int={val l=s.size;if(l>1)(1 to l/2).map(i=>if(s.take(i)==s.takeRight(i))^(s.slice(i,l-i))else 0).max else 1}

Çevrimiçi deneyin!

PS. Görünüşe göre, çözüm sadece kaynak kodun yarı palindrom olması şartını yerine getirmek için 2 kat daha uzundur.

PPS. Kod-golf adayı değil, desen eşleştirme kullanarak tamamen işlevsel bir çözüm:

  def f(s:Seq[Int], i:Int=1):Int = {
    (s, i) match {
      case (Nil ,_) => 1
      case (Seq(_), _) => 1
      case (l, _) if l.take(i) == l.takeRight(i) => f(l.slice(i,l.size-i), 1)
      case (l, j) if j < l.size/2 => f(l, i+1)
      case (_, _) => 0
    }
  }

Perl 6 , 81 bayt

($!={/../&&/^(.+)(.*)$0$/&&$1.$!})o&chrs#($!={/../&&/^(.+)(.*)$0$/&&$1.$!})o&chrs

Çevrimiçi deneyin!

/../True için regex'i /^(.+)(.*)$0$/ve False için regex'i döndürür . Nwellnhof'un cevabına benzer şekilde çalışır , ancak listeyi önceden bir dizgeye dönüştürür.