Une chaîne est considérée comme carrée si les conditions suivantes sont remplies:

• Chaque ligne a le même nombre de caractères
• Le nombre de caractères sur chaque ligne est égal au nombre de lignes.

Votre tâche consiste à écrire un programme ou une fonction qui détermine si une chaîne d'entrée donnée est un carré.

Vous pouvez avoir besoin que l’entrée soit délimitée par votre choix de LF, CR ou CRLF.

Les caractères de nouvelle ligne ne sont pas considérés comme faisant partie de la longueur de la ligne.

Vous pouvez avoir besoin d’être ou non une nouvelle ligne en fin de ligne, ce qui ne compte pas comme une ligne supplémentaire.

L'entrée est une chaîne ou un tableau de caractères 1D; ce n'est pas une liste de chaînes.

Vous pouvez supposer que l'entrée est non vide et ne contient que de l'ASCII imprimable, espaces compris.

Vous devez indiquer une valeur de vérité pour les chaînes carrées et une valeur falsifiée pour les autres chaînes.

Cas de test de vérité:

foo
bar
baz

.

.s.
.ss
.s.
(s représente l'espace)

ss
ss
(s représente l'espace)

aaaaa
aaaaa
aaaaa
aaaaa
aaaaa

Cas de tests de fausseté:

..
.

.

.

....


....

4444
333
22

333
333

abc.def.ghi

Notez les lignes vierges supplémentaires dans certains cas de fausseté.

C'est du code-golf - le moins d'octets gagne!

Brachylog (2), 3 octets

ṇẹṁ

Essayez-le en ligne!

Programme complet. Sorties true.pour la vérité, false.pour Falsey.

Explication

ṇẹṁ
ṇ     Split {standard input} into lines
 ẹ    Split {each line} into basic elements {in this case, characters}
  ṁ   Assert that the result is square

J'étais un peu sceptique quant à l'utilité de la fonction ṁintégrée lorsqu'elle a été ajoutée, mais je ne peux vraiment pas nier que c'est utile ici…

Brachylog (2), 7 octets

ṇẹ.\l~l

Essayez-le en ligne!

Solution non intégrée. Bat encore toutes les autres entrées, au moment de l'écriture. EDIT: Pas tout à fait, l’entrée de longueur égale de Jelly est entrée pendant que j’écrivais ceci, et le bat via le tie-break de l’horodatage.

Explication

ṇẹ.\l~l
ṇ         Split {standard input} into lines
 ẹ        Split {each line} into basic elements {in this case, characters}
   \l     Assert that the result is rectangular, and the number of columns
  .  ~l     is equal to the number of rows

Python 2 , 52 octets

x=input().split('\n')
print{len(x)}==set(map(len,x))

Essayez-le en ligne! ou Essayez tous les cas de test

JavaScript (ES6), 46 45 octets

s=>!(s=s.split`
`).some(x=>x.length-s.length)

• 1 octet économisé grâce à ETHproductions

Explication

1. Fractionner la chaîne en un tableau sur les nouvelles lignes.
2. Boucle sur le tableau.
3. Soustrayez la longueur du tableau de la longueur de chaque ligne.
4. Si une valeur non nulle (c'est-à-dire une vérité) est renvoyée pour une ligne, la chaîne n'est pas carrée.
5. Annulez le résultat de la boucle pour obtenir truecarré et falsenon.

L'essayer

f=
s=>!(s=s.split`
`).some(x=>x.length-s.length)
oninput=_=>o.innerText=f(i.value)
o.innerText=f(i.value=`foo
bar
baz`)

<textarea id=i></textarea><pre id=o>

05AB1E , 10 à 8 octets

¶¡€gDgQP

Essayez-le en ligne!

-2 grâce à Riley, voici en gros sa réponse ._.

Code       # Explanation                  | Truthy Example          | Falsy Example
-----------#------------------------------+-------------------------+--------------
¶¡         # Split on newlines            | [['aaa','aaa','aaa']]   | [['aa']]
  €g       # Get length of each           | [[3,3,3]]               | [[2]]
    D      # Dupe                         | [[3,3,3],[3,3,3]]       | [[2],[2]]
     g     # Get length                   | [[3,3,3],3]             | [[2],1]
      Q    # Check equality               | [[1,1,1]]               | [[0]]
       P   # Take product                 | 1                       | 0

Gelée , 7 5 octets

Ỵ¬⁼Z$

Essayez-le en ligne!

Merci à FryAmTheEggman pour -2

Haskell, 38 à 34 octets

l=length
(all=<<(.l).(==).l).lines

Essayez-le en ligne!

Version sans pointes de f s = all ((==length (lines s)).length) (lines s), c’est-à-dire scinder l’entrée en lignes et vérifier si la longueur de chaque ligne est égale au nombre de lignes.

Edit: Merci à @xnor pour 4 octets.

Gelée , 7 octets

ỴµL;L€E

Essayez-le en ligne!

Explication

Ỵµ       Split the input on newline and use as input in the second link     
  L      Get the number of list items
   ;     And append to that
    L€   A list with the legth of each list item
      E  Check to see if all items are equal.

Japt , 9 octets

=Ur.Q)¥Uy

Testez-le en ligne!

Explication

 =Ur.Q)¥ Uy
U=Ur.Q)==Uy
             // Implicit: U = input string, Q = quotation mark
U=    )      // Set U to
  Ur.Q       //   U with each non-newline (/./g) replaced with a quotation mark.
       ==Uy  // Return U == U transposed. U is padded to a rectangle with spaces before
             // transposing; if U was not a rectangle before, or the sides are not of
             // equal length, the result will not be the same as U.
             // Implicit: output result of last expression

En utilisant certaines fonctionnalités implémentées peu de temps après la publication de ce défi, il peut s'agir de 6 octets:

r.Q
¥y

Testez-le en ligne!

Explication

       // Implicit: U = input string
r.Q    // Replace each non-newline (/./g) in U with a quotation mark.
       // Newline: set U to the result.
¥      // Return U ==
 y     //   U transposed.
       // Implicit: output result of last expression

Retina , 33 31 octets

.
.
^(.(.)*)(?<-2>¶\1)*$(?(2).)

Essayez-le en ligne! Explication: La première étape consiste simplement à remplacer tous les caractères ASCII imprimables par le même caractère, afin de faciliter la correspondance. (Cela pourrait se faire sans, mais c'est du code golf, pas du défi du code.) La deuxième étape correspond alors à au moins un caractère sur la première ligne. Toutefois, pour chaque caractère supplémentaire de la première ligne, il correspond éventuellement à une nouvelle ligne suivie d'une copie de la première ligne. La dernière partie de l'expression entraîne l'échec de la correspondance s'il y a plus de colonnes que de lignes.

Husk , 6 octets

S≡T'a¶

Prend une ficelle et imprime soit 1ou 0. Essayez-le en ligne! La première ligne itère sur les cas de test; supprimez-le si vous souhaitez tester sur une seule valeur.

Explication

Husk est un nouveau langage de golf fonctionnel créé par Leo et moi-même . Il manque beaucoup de fonctionnalités et le développement est en cours. Sa principale caractéristique est un système de type rigide qui nous permet de surcharger des fonctions d'ordre supérieur.

À haut niveau, le programme fonctionne comme suit:

S≡T'a¶  Define a function:
     ¶  split on newlines,
  T'a   transpose and pad to rectangle using character 'a',
 ≡      check if this has the same shape as
S       the split input.

La fonction ≡vérifie réellement si deux tableaux ont la même forme et la même distribution d'éléments de vérité. Dans Husk, tous les caractères sauf l'octet nul sont la vérité et cela ne se produira pas dans nos entrées. De plus, Sest le S-Combinator , une fonction qui prend en entrée deux fonctions, ici ≡et T'a, et retourne une nouvelle fonction qui xà ≡(x)(T'a x). Le résultat de Sest composé avec ¶, et cette fonction est appliquée implicitement à l'entrée.

Comment Husk sait-il qu'il devrait s'appliquer Sà la fonction suivante, mais ¶devrait être composé avec la fonction à sa gauche? Simple: il essaie toutes les interprétations et choisit celle où les types ont un sens. Ceci est expliqué plus en détail dans la documentation Husk .

Pure bash (no utilities), 55

mapfile -t a
for l in ${a[@]};{
((c+=${#l}^${#a[@]}))
}

• mapfile lit l'entrée dans le tableau a
• alors le nombre d'éléments du tableau est XORed avec chaque longueur de ligne, et la somme est prise. Pour un carré parfait, chaque résultat XOR (et donc la somme) sera 0. Pour toute autre chose, le résultat sera> 0.

Le sens opposé de ceci est renvoyé sous la forme d'un code de retour de shell (examiner avec echo $?) - le carré parfait vaut 1, tout le reste vaut 0.

Essayez-le en ligne (vérité) .

Essayez-le en ligne (faux) .

Réponse précédente utilisant eval-escape-expansion hell, 78:

mapfile -t a
echo $[0$(eval eval echo +\\$\{#a[{0..$[${#a[@]}-1]}]}^${#a[@]})]

Essayez-le en ligne (vérité) .

Essayez-le en ligne (faux) .

Perl 6 , 27 octets

{.lines==all .lines».comb}

Teste si le nombre de lignes dans la chaîne d'entrée est égal au nombre de caractères sur chaque ligne.

Pyth, 7 octets

CImL1.z

Essayez ici

Ne nécessite pas de nouvelle ligne. Remplace l'entrée par un tableau 2D de 1, où 1 représente n'importe quel caractère de l'entrée d'origine. Ensuite, nous vérifions si ce tableau est inchangé après l'avoir transposé (en remplaçant les colonnes par des lignes). Seul un carré reviendra vrai dans une telle situation.

Java (OpenJDK 8) ,96 91 90 87 octets

-5 octets grâce à @KevinCruijssen
-1 octet grâce à @TheLethalCoder
-2 octets grâce à @ OlivierGrégoire

a->java.util.Arrays.stream(a.split("\n")).allMatch(x->x.length()==a.split("\n").length)

Essayez-le en ligne!

05AB1E , 7 octets

|€gDgQP

Essayez-le en ligne!

R , 57 octets

function(s)all(nchar(n<-strsplit(s,'
')[[1]])==length(n))

Une fonction anonyme; Fractionner sur les nouvelles lignes, calcule la longueur de chaque ligne et vérifie si toutes sont identiques au nombre de lignes.

Essayez-le en ligne!

MATL , 14 12 octets

10H&XXot&n=h

La chaîne d'entrée est définie à l'aide de la concaténation de chaînes ( [...]) et avec le point de code 10pour représenter LF. Par exemple, ['aaa' 10 'bb']est interprété en MATL comme une chaîne 'aaa'concaténée avec le caractère avec un point de code 10concaténé avec une chaîne 'bb'.

La sortie est un vecteur numérique non vide, qui est véridique si et seulement si toutes ses entrées sont non nulles.

Essayez-le en ligne!

Explication

Considérez l'entrée ['4444' 10 '333' 10 '22'].

10H   % Push 10 (code point of LF). Push 2
      % STACK: 10, 2
&XX   % Regexp with three arguments. First argument is implicit input (string);
      % second is 2, which indicates that we want to split the input; third is
      % 10, which is the character to split on. The result is a cell array of
      % matched strings
      % STACK: {'4444', '333', '22'}
o     % Concatenate into a numeric 2D array of code points, right-padding with
      % zeros if needed
      % STACK: [52 52 52 52; 51 51 51 0; 50 50 0 0]
t&n   % Duplicate. Push number of rows and number of columns
      % STACK: [52 52 52 52; 51 51 51 0; 50 50 0 0], 3, 4
=     % Are they equal?
      % STACK: [52 52 52 52; 51 51 51 0; 50 50 0 0], 0
h     % Concatenate into a row vector (in column-major order). Implicit display
      % STACK: [52 51 50 52 51 50 52 51 0 52 0 0 0]

R, 35 octets

all(nchar(x<-scan(,""))==length(x))

Prend la contribution de stdin. Vérifie que le nombre de caractères de chaque ligne est égal au nombre total de lignes. Retours TRUEou FALSEselon le cas.

JavaScript (ES6), 48 octets

s=>(a=s.split`
`,a.every(l=>l.length==a.length))

CJam, 11 octets

qN/:,_,f=:*

Essayez-le en ligne!

OCaml , 56 octets

let f t=List.(for_all(fun l->String.length l=length t)t)

Essayez-le en ligne!

Pyth, 12 à 10 octets

!fnl.zlT.z

2 octets sauvés grâce à @FryAmTheEggman.

Essayez-le en ligne

Explication

!fnl.zlT.z
 f     T.z     Filter lines of the input
  nl.zl        whose length is not the number of lines
!              and return whether there are no such lines.

QBIC , 43 octets

{_?~_lA||h=h+1┘g=g+_lA|~g%_lA||_Xp]\_xg/h=h

Moi, je suis heureux de la brièveté d'un dérivé de QBasic pour relever ce défi.

Explication:

{_?       DO infinitely: ask the user for input, store as A$
~    |    IF
 _lA|       The length of A$   (implicitly <> 0)
h=h+1     Add 1 to our line counter
┘         (syntactic linebreak)
g=g+_lA|  Add the length of this line to the running total of line lengths
~      |  IF
 g%_lA|     The length of the running total modulo the length of the last string
            yields anything but 0, there is a discrepancy between earlier line
            lengths and this one.
_Xp]      THEN QUIT, printing 0, end IF
\         ELSE (refers to the LEN(A$), user didn't input anything.
_xg/h=h   QUIT (the inf. loop) printing -1 if the root of the chars is the row count
            or 0 if not.

Pyth, 7 octets

qCC.z.z

Manifestation

Transposez l’entrée avec la troncature deux fois, puis vérifiez si le résultat est identique à l’original.

Ruby, 50 octets

s=$<.read.split $/,-1;p [s.size]==s.map(&:size)|[]

Essayez-le en ligne!

Explication

1. Fractionner l'entrée dans un tableau sur une nouvelle ligne.
2. Affirmer qu'un tableau contenant uniquement la taille de ce tableau est égal à un tableau contenant toutes les tailles uniq (set union with empty array) de tous les éléments de ce tableau.

Cheddar , 39 octets

@.split("
").all((i,j,k)->i.len==k.len)

Essayez-le en ligne!

Clojure, 58 octets

#(let[s(re-seq #"[^\n]+"%)c count](apply =(c s)(map c s)))

Nécessite un retour à la ligne, impatient de voir quelque chose de plus magique.

APL (Dyalog) , 17 octets

Nécessite ⎕ML←3ce qui est la valeur par défaut sur de nombreux systèmes. Utilise CR.

↓∘⎕FMT≡⎕TC[2]∘≠⊂⊢

Essayez-le en ligne!

↓∘⎕FMT [est le] split-en-ligne F ou m a t ted-en-a-carré argumentation

≡ identique à

⎕TC[2]∘≠ les caractères en-groupes-de-non-nouvelle-ligne

⊂ cloisonné

⊢ argument?

* Le deuxième élément de la liste de T erminal C personnages de.

Dans la version 16.0, on peut écrire ↓∘⎕FMT≡⎕TC[3]∘≠⊆⊢avec ⎕ML←1.

PowerShell, 64 octets

La même approche (fractionnée, longueur de ligne, nombre de lignes) est la même que pour les autres réponses en langage autre que le golf, mais il n’existe pas d’équivalent valable pour map (); est groupé. Les carrés sortent comme les 3,3,3,3 -> 1 group, all line lengths and line count were equalnon-carrés 3,2,1 -> 3 groups, il y avait quelque chose d'inégal dans le carré:

$f={@(@(($L="$args"-split"`n")|% le*)+$L.Count|group).Count-eq1}

Requiert des terminaisons newline de style Linux, pas de nouvelle ligne. par exemple

$Ttests = @(@'
foo
bar
baz
'@,
'.',
@'
aaaaa
aaaaa
aaaaa
aaaaa
aaaaa
'@
)
$Ttests = $Ttests | foreach {$_ -replace "`r"}

$Ttests | % { & $f $_ }

(Et vous pouvez faire la même chose pour les faux tests, mais je ne vais pas le dire ici car il y en a plus). Les deux @symboles sont nécessaires lorsque l'entrée est le seul '.'sinon le fractionnement , il ne fait pas un tableau d'une chaîne , il est tout simplement une chaîne, puis la concaténation de tableau ne délivre pas 1,1qu'il émet 2.

J'espérais qu'il serait peut-être plus court de remplacer tous les caractères par «a», puis par la force brute de 1 à la longueur indiquée par tous les carrés «a» et de voir si l'un d'eux correspondait à l'entrée. Une fois que j'ai passé param () et .Length et -join and-place, il se termine beaucoup plus longtemps à 81 octets:

$f={param($s)!!(1..$s.Length|?{,('a'*$_)*$_-join"`n"-eq($s-replace"[^`n]",'a')})}

Grime , 11 octets

e`.|_./+/.+

Imprime 1pour les carrés et 0pour les non-carrés. Essayez-le en ligne!

Explication

Une explication détaillée peut être trouvée sur la page du tutoriel Grime , qui contient ce programme exact à titre d'exemple.

e`.|_./+/.+
e`            Match entire input against pattern:
  .           A single character
   |          OR
    _         a recursive match of this pattern
     ./+      with one column of characters on its right
        /     and below that
         .+   one row of characters.