Triangles entièrement palindromiques


18

Considérez la chaîne 160615051. Il peut être "triangulé" en tant que tel:

  1
 606
15051

Ensuite, chaque rangée est un palindrome. Notez également que chaque côté du périmètre est également un palindrome:

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

Par conséquent, cette chaîne peut être considérée comme un triangle entièrement palindromique. Ne vous inquiétez pas de l'altitude 100dans ce cas, elle n'a pas besoin d'être palindromique.

Entrée: une chaîne de caractères ASCII imprimables de 0x20 à 0x7E. Il peut s'agir d'un tableau de caractères, d'une chaîne unique ou d'un tableau de points de code ASCII. Votre entrée pourra toujours être triangulée (c'est-à-dire que sa longueur sera toujours un carré parfait).

Sortie : une valeur vraie si la chaîne est un triangle entièrement palindromique, ou une valeur de falsey sinon.

Cas de test

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

Réponses:


10

Gelée , 14 12 octets

J’ƲœṗZ⁻¦µU⁼

Essayez-le en ligne!

Contexte

Nous commençons par regarder les indices basés sur 0 de la chaîne d'entrée.

 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

Pour obtenir les lignes du triangle, nous pouvons diviser la chaîne avant les indices 1 , 1 + 3 = 4 , 1 + 3 + 5 = 9 et 1 + 3 + 5 + 7 = 16 . Puisque (n + 1) ² = n² + (2n + 1) , ces sommes sont précisément les carrés positifs et parfaits dans la liste d'index. Si nous divisons également la chaîne avant 0 , c'est aussi simple que de diviser avant tous les indices basés sur 0 qui sont des carrés parfaits.

Après le fractionnement, nous obtenons les chaînes suivantes.

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

Ensuite, nous remplaçons la chaîne vide au début par tous les caractères de la première colonne.

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

La tâche est maintenant réduite à vérifier si l'inversion de toutes les chaînes donne le même tableau de chaînes.

Comment ça fonctionne

JGénère d' abord tous les indices basés sur 1 de la chaîne d'entrée J, puis les décrémente avec pour produire tous les indices basés sur 0. Ʋteste tous les indices basés sur 0 pour l'équerrage. Pour notre exemple ci-dessus, cela donne le tableau booléen suivant.

 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

Ensuite, nous appelons œṗà partitionner la chaîne d'entrée, par exemple,

 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

avant tous les 1 (en fait, tous les éléments véridiques). Pour notre exemple, cela donne le tableau de chaînes suivant.

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

Z⁻¦est sans doute la partie la plus intéressante de cette réponse. Analysons d'abord le plus simple Z1¦.

¦est le rapide clairsemé . Il consomme deux liens de la pile, spécifiquement 1et Zdans ce cas. Le premier Zest appliqué à son argument: le tableau de chaînes d'avant. Zest l' atome zip et lit le tableau de chaînes / tableau de caractères 2D par colonnes, ce qui donne

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

Ce qui était le côté gauche de la chaîne d'entrée et la première colonne du tableau de chaînes devient maintenant la première chaîne .

¦Regarde maintenant 1et trouve un seul index: 1 . Ainsi, la première chaîne du tableau de chaînes d'origine est remplacée par la première chaîne dans la valeur de retour de Z; les chaînes des autres indices ne sont pas affectées.

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

Appelons ce tableau A .

Nous avons utilisé à la Z⁻¦place de Z1¦, mais cela ne fait aucune différence: compare le tableau de chaînes avec la chaîne d'entrée pour l'inégalité, ce qui donne 1 car elles ne sont pas égales. La différence entre les deux est qu'il Z⁻¦est dyadique parce qu'il nous permet d'écrire à la œṗZ⁻¦place de œṗ¹Z1¦. En effet, une dyade ( œṗ) suivie d'une monade ( œṗ¹Z1¦) est une fourchette (la monade est appliquée à l'argument de la chaîne / à la chaîne d'entrée, et la valeur renvoyée est transmise comme argument de droite à œṗ), tandis qu'une dyade suivie d'une autre dyade (ou à la fin de la chaîne) est un crochet , c'est-à-dire que son argument de droite est l'argument de la chaîne.

Tout ce qui reste à faire est de vérifier la palindromicité. µcommence une nouvelle chaîne (monadique) qui est l' argument est un . Le upend atome Uinverse toutes les chaînes A (mais pas A lui - même), puis compare le résultat avec une pour l' égalité. Le booléen renvoyé 1 indique un triangle entièrement palindromique; les autres chaînes retourneraient 0 .


Je devrais vraiment apprendre à lire Jelly. (Explication, s'il vous plaît?)
CAD97

1
J'ai édité ma réponse.
Dennis

6

Japt , 25 21 17 octets

Sauvegardé 2 octets grâce à @obarakon

ò@°T ¬v1
pUmg)eêP

Testez-le en ligne!

Comment ça fonctionne

 ò@  ° 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

Notez que nous n'avons pas besoin de vérifier les deux côtés; si les côtés ne sont pas les mêmes, au moins une des rangées n'est pas un palindrome.


Cette chose multiligne est-elle une nouvelle fonctionnalité de Japt?
Luke

@Luke Oui, je viens de l'ajouter mardi. C'est ma première chance de le montrer :-)
ETHproductions

Peu importe mon astuce de golf. Il suffit de vérifier si chaque ligne était palindromique, ce qui a également donné des résultats corrects ...
Luke


4

Gelée , 18 16 octets

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

Essayez-le en ligne!

Merci à Jonathan Allan pour les économies triviales mais pas si évidentes de -2 octets.


Utilisez ma construction triangulaire et enregistrez un octet:JƲ0;œṗ⁸ZḢ$ṭ$ŒḂ€Ạ
Jonathan Allan

... en fait, combinez cette idée avec la contrefaçon et enregistrez un autre octet, car le partitionnement sera "zip le plus court":J²‘Ṭœṗ⁸ZḢ$ṭ$ŒḂ€Ạ
Jonathan Allan

@JonathanAllan Umm ... pourquoi en ai-je besoin ½? Maintenant, Jc'est plus logique ...
Erik the Outgolfer

3

JavaScript (ES6), 112 octets

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)

tet ucollecter les côtés afin qu'ils puissent être testés à la fin.


2

C #, 184 octets

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);}

Je pensais que la solution semblait bonne jusqu'à ce que j'arrive à la partie palindrome

Version non golfée:

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);
        };

Pouvez-vous vous déplacer e=..dans la ligne de boucle for pour enregistrer un octet? Il n'est pas nécessaire de compter les sauts de ligne dans le nombre d'octets, donc je suppose que vous ne l'êtes pas.
TheLethalCoder

Non, je ne compte pas les sauts de ligne, je ne peux pas déplacer le e dans la boucle car j'en ai besoin dans l'instruction de retour.
LiefdeWen

Je voulais dire comme ça....; i < s;e = f.Substring(s - k)){c+=....
TheLethalCoder

2

Java 8, 358 301 octets

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()+"");}

L'entrée est un String, la sortie est un boolean.

Explication:

Essayez-le ici.

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)

1

Gelée ,  20  21 octets

+2 octets - J'ai publié un code bogué :(
-1 octet - déplacé du moulage comme des entiers impairs vers le partitionnement aux index carrés

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

Un lien monadique acceptant une liste de personnages et renvoyant 1(Truthy) ou 0(Falsey).
Remarque: cela utilise la partie de la spécification qui limite l'entrée à une longueur carrée.

Essayez-le en ligne! ou consultez la suite de tests .

Cela peut être simplifié à 17 octets en notant que si toutes les lignes sont des palindromes, un seul "côté" doit être vérifié ( JƲ0;œṗ⁸ZḢ$ṭ$ŒḂ€Ạ), mais Erik l'Outgolfer a déjà remarqué ce fait et l'a utilisé dans sa réponse , j'ai donc donné la méthode de construction du triangle pour les sauver un octet là-bas.

De plus, cela peut à son tour être amélioré à 16 octets en notant que le partitionnement aux index véridiques ne dérange pas s'il y a un excès dans l'argument de gauche ( J²‘Ṭœṗ⁸ZḢ$ṭ$ŒḂ€Ạ).

Comment?

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

1
Bon sang, j'étais sur le point de répondre à Jelly. Bien que techniquement le mien soit faux et comme deux fois plus long ... beau travail :): P
HyperNeutrino

"notant que le partitionnement à des index véridiques ne me dérange pas s'il y a un excès dans l'argument de gauche" a également remarqué avant de lire.
Erik the Outgolfer

1

Mathematica, 156 octets

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&


contribution

["1101"]


Tu ne peux pas remplacer If[<stuff>, True, False]par juste <stuff>? Et je pense que And@@(...)c'est plus court que Count[...,True]==s, ce qui signifie également que vous n'avez pas à définir scomme variable.
Pas un arbre le

Attendez, est-ce que cela teste réellement les diagonales? Je reçois des faux positifs pour quelques cas de test ( "1202"et "160625052").
Pas un arbre le

tous les problèmes résolus
J42161217


1

Java, 136 octets

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;}

Utilise un MutableList<Character>des collections Eclipse

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;
};

1

Perl 5 , 81 + 1 ( -p) = 82 octets

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

Essayez-le en ligne!

Sorties undef(c'est-à-dire vides, nulles) pour vrai, n'importe quel nombre pour faux


0

Excel VBA, 87 octets

Fonction de fenêtre immédiate VBE anonyme qui prend les entrées de la cellule [A1]et les sorties vers la fenêtre immédiate 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

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.