Eine Zeichenfolge gilt als quadratisch, wenn folgende Bedingungen erfüllt sind:

• Jede Zeile hat die gleiche Anzahl von Zeichen
• Die Anzahl der Zeichen in jeder Zeile entspricht der Anzahl der Zeilen.

Ihre Aufgabe ist es, ein Programm oder eine Funktion zu schreiben, die bestimmt, ob eine bestimmte Eingabezeichenfolge ein Quadrat ist oder nicht.

Möglicherweise müssen Eingaben durch die Auswahl von LF, CR oder CRLF begrenzt werden.

Die Zeilenumbruchzeichen werden nicht als Teil der Zeilenlänge betrachtet.

Möglicherweise muss eine nachgestellte Zeile in der Eingabe vorhanden sein oder nicht, was nicht als zusätzliche Zeile zählt.

Die Eingabe ist eine Zeichenfolge oder ein 1D-Zeichen-Array. Es ist keine Liste von Zeichenfolgen.

Sie können davon ausgehen, dass die Eingabe nicht leer ist und nur druckbare ASCII-Zeichen einschließlich Leerzeichen enthält.

Sie müssen einen Wahrheitswert für quadratische Zeichenfolgen und einen falschen Wert für andere Zeichenfolgen ausgeben.

Wahrheitstestfälle:

foo
Bar
baz

.

.s.
.ss
.s.
(s steht für Leerzeichen)

ss
ss
(s steht für Leerzeichen)

aaaaa
aaaaa
aaaaa
aaaaa
aaaaa

Falsche Testfälle:

..
.

.

.

....


....

4444
333
22

333
333

abc.def.ghi

Beachten Sie in einigen Fällen zusätzliche Leerzeilen.

Das ist Code-Golf - die wenigsten Bytes gewinnen!

Brachylog (2), 3 Bytes

ṇẹṁ

Probieren Sie es online!

Volles Programm. Ausgänge true.für Wahrheit, false.für Falschheit.

Erläuterung

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

Ich war ein bisschen skeptisch, was die Nützlichkeit des ṁeingebauten Codes angeht, als es hinzugefügt wurde, aber ich kann nicht wirklich leugnen, dass es hier hilfreich ist ...

Brachylog (2), 7 Bytes

ṇẹ.\l~l

Probieren Sie es online!

Nicht eingebaute Lösung. Noch schlägt alle anderen Einträge, zum Zeitpunkt des Schreibens. EDIT: Nicht ganz, der gleichlange Jelly-Eintrag ist eingegangen, während ich das geschrieben habe, und schlägt es über den Timestamp-Tiebreak.

Erläuterung

ṇẹ.\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 Bytes

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

Probieren Sie es online! oder Probieren Sie alle Testfälle aus

JavaScript (ES6), 46-45 Byte

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

• Dank ETHproductions 1 Byte gespart

Erläuterung

1. Teilen Sie den String in Zeilenumbrüche auf.
2. Schleife über das Array.
3. Subtrahieren Sie die Länge des Arrays von der Länge jeder Zeile.
4. Wenn für eine Zeile ein Wert ungleich Null (dh wahr) zurückgegeben wird, ist die Zeichenfolge nicht quadratisch.
5. Negiere das Ergebnis der Schleife, um truenach Quadrat und falsenicht nach Nicht zu suchen .

Versuch es

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 Bytes

¶¡€gDgQP

Probieren Sie es online!

-2 Dank Riley ist dies im Grunde seine Antwort ._.

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

Gelee , 7 5 Bytes

Ỵ¬⁼Z$

Probieren Sie es online!

Vielen Dank an FryAmTheEggman für -2

Haskell, 38 34 Bytes

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

Probieren Sie es online!

Pointfree-Version von f s = all ((==length (lines s)).length) (lines s), dh die Eingabe in Zeilen aufteilen und prüfen, ob die Länge jeder Zeile der Anzahl der Zeilen entspricht.

Edit: Danke an @xnor für 4 Bytes.

Gelee , 7 Bytes

ỴµL;L€E

Probieren Sie es online!

Erläuterung

Ỵµ       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 Bytes

=Ur.Q)¥Uy

Online testen!

Erläuterung

 =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

Bei Verwendung einiger Funktionen, die kurz nach dem Veröffentlichen dieser Herausforderung implementiert wurden, können dies 6 Byte sein:

r.Q
¥y

Online testen!

Erläuterung

       // 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 Bytes

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

Probieren Sie es online! Erläuterung: In der ersten Stufe werden einfach alle druckbaren ASCII-Zeichen in dasselbe Zeichen geändert, um die Zuordnung zu vereinfachen. (Dies könnte auch ohne Code-Golf und nicht ohne Code-Challenge geschehen.) Die zweite Stufe entspricht dann mindestens einem Zeichen in der ersten Zeile. Für jedes zusätzliche Zeichen in der ersten Zeile wird dann optional eine neue Zeile gefolgt von einer Kopie der ersten Zeile gefunden. Der letzte Teil des Ausdrucks führt dazu, dass die Übereinstimmung fehlschlägt, wenn mehr Spalten als Zeilen vorhanden sind.

Schale , 6 Bytes

S≡T'a¶

Nimmt einen String und druckt entweder 1oder 0. Probieren Sie es online! Die erste Zeile durchläuft die Testfälle. Entfernen Sie es, wenn Sie einen einzelnen Wert testen möchten.

Erläuterung

Husk ist eine neue funktionale Golfsprache, die von mir und Leo entwickelt wurde . Es fehlen viele Funktionen und die Entwicklung ist noch nicht abgeschlossen. Sein Hauptmerkmal ist ein starres System, mit dem wir Funktionen höherer Ordnung überladen können.

Auf einer hohen Ebene funktioniert das Programm wie folgt:

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.

Die Funktion ≡prüft tatsächlich, ob zwei Arrays dieselbe Form und dieselbe Verteilung wahrer Elemente haben. In Husk sind alle Zeichen mit Ausnahme des Nullbytes wahr, und dies wird in unseren Eingaben nicht vorkommen. Auch Sist der S-combinator , eine Funktion , die als Eingaben zwei Funktionen übernimmt, hier ≡und T'aund gibt eine neue Funktion, die Karten xzu ≡(x)(T'a x). Das Ergebnis von Swird mit zusammengesetzt ¶, und diese Funktion wird implizit auf die Eingabe angewendet.

Woher weiß Husk, dass es für Sdie nächste Funktion gelten soll, aber ¶mit der Funktion auf der linken Seite erstellt werden soll? Einfach: Es wird einfach jede Interpretation ausprobiert und die ausgewählt, bei der die Typen sinnvoll sind. Dies wird in der Husk-Dokumentation näher erläutert .

Pure Bash (keine Dienstprogramme), 55

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

• mapfile Liest die Eingabe in das Array a
• dann wird die Anzahl der Elemente des Arrays mit jeder Zeilenlänge XOR-verknüpft, und die Summe wird genommen. Für ein perfektes Quadrat ist jedes XOR-Ergebnis (und damit die Summe) 0. Für alles andere ist das Ergebnis> 0.

Der umgekehrte Sinn wird als Shell-Returncode zurückgegeben (prüfen mit echo $?) - perfektes Quadrat ist 1, alles andere ist 0.

Versuchen Sie es online (wahr) .

Versuchen Sie es online (falsch) .

Vorherige Antwort mit eval-escape-expansion hell, 78:

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

Versuchen Sie es online (wahr) .

Versuchen Sie es online (falsch) .

Perl 6 , 27 Bytes

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

Prüft, ob die Anzahl der Zeilen in der Eingabezeichenfolge der Anzahl der Zeichen in jeder Zeile entspricht.

Pyth, 7 Bytes

CImL1.z

Probieren Sie es hier aus

Benötigt keinen nachgestellten Zeilenumbruch. Ersetzt die Eingabe durch ein 2D-Array mit 1, wobei eine 1 ein beliebiges Zeichen in der ursprünglichen Eingabe darstellt. Dann prüfen wir, ob das Array nach der Transponierung unverändert ist (Ersetzen von Spalten durch Zeilen). In einer solchen Situation ist nur ein Quadrat wahr.

Java (OpenJDK 8) ,96 91 90 87 Bytes

-5 Bytes dank @KevinCruijssen
-1 Bytes dank @TheLethalCoder
-2 Bytes dank @ OlivierGrégoire

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

Probieren Sie es online!

05AB1E , 7 Bytes

|€gDgQP

Probieren Sie es online!

R , 57 Bytes

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

Eine anonyme Funktion; Teilt sich in Zeilenumbrüche, berechnet die Länge jeder Zeile und überprüft, ob alle Zeilen der Anzahl der Zeilen entsprechen.

Probieren Sie es online!

MATL , 14 12 Bytes

10H&XXot&n=h

Die Eingabezeichenfolge wird mithilfe der Zeichenfolgenverkettung ( [...]) und des Codepunkts 10zur Darstellung von LF definiert. Zum Beispiel ['aaa' 10 'bb']wird in MATL interpretiert als String 'aaa'mit dem Zeichen mit dem Code Punkt konkateniert 10mit Zeichenkette verkettet 'bb'.

Die Ausgabe ist ein nicht leerer numerischer Vektor, der genau dann wahr ist, wenn alle seine Einträge ungleich Null sind.

Probieren Sie es online!

Erläuterung

Betrachten Sie die Eingabe ['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 Bytes

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

Übernimmt die Eingabe von stdin. Überprüft, ob die Anzahl der Zeichen in jeder Zeile der Gesamtzahl der Zeilen entspricht. Rückgabe TRUEoder FALSEentsprechend.

JavaScript (ES6), 48 Byte

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

CJam, 11 Bytes

qN/:,_,f=:*

Probieren Sie es online!

OCaml , 56 Bytes

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

Probieren Sie es online!

Pyth, 12 10 Bytes

!fnl.zlT.z

2 Bytes dank @FryAmTheEggman gespart.

Probieren Sie es online aus

Erläuterung

!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 Bytes

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

Ich bin froh darüber, wie kurz ein QBasic-Derivat für diese Herausforderung sein muss.

Erläuterung:

{_?       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 Bytes

qCC.z.z

Demonstration

Transponieren Sie die Eingabe zweimal mit Kürzung und prüfen Sie dann, ob das Ergebnis mit dem Original übereinstimmt.

Ruby, 50 Bytes

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

Probieren Sie es online!

Erläuterung

1. Teilen Sie die Eingabe in ein Array auf der Newline.
2. Angenommen, ein Array, das nur die Größe dieses Arrays enthält, ist gleich einem Array, das alle uniq-Größen (Vereinigungsmenge mit leerem Array) aller Elemente in diesem Array enthält.

Cheddar , 39 Bytes

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

Probieren Sie es online!

Clojure, 58 Bytes

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

Benötigt einen abschließenden Zeilenumbruch und freut sich darauf, etwas Magischeres zu sehen.

APL (Dyalog) , 17 Bytes

Benötigt, ⎕ML←3was auf vielen Systemen Standard ist. Verwendet CR.

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

Probieren Sie es online!

↓∘⎕FMT [ist] split-in-Linien F oder m eine t ted-in-a-square Argument

≡ identisch mit

⎕TC[2]∘≠ die In-Groups-of-Non-Newline * -Zeichen

⊂ partitioniert

⊢ Streit?

* Das zweite Element der Liste von T erminal C ontrol Zeichen.

In Version 16.0 kann man ↓∘⎕FMT≡⎕TC[3]∘≠⊆⊢mit schreiben ⎕ML←1.

PowerShell, 64 Byte

Der gleiche Ansatz (Aufteilung, Zeilenlänge, Anzahl der Zeilen) wie bei anderen Antworten in anderen Sprachen als Golf, aber es gibt kein nettes map () - Äquivalent. Es handelt sich also um ein Array von Zeilenlängen mit der Anzahl der am Ende markierten Zeilen und dann um dieses Array ist gruppiert. Quadrate kommen heraus wie 3,3,3,3 -> 1 group, all line lengths and line count were equalund Nichtquadrate kommen heraus wie 3,2,1 -> 3 groups, etwas war im Quadrat ungleich:

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

Erfordert Zeilenende im Linux-Stil, kein abschließendes Zeilenende. z.B

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

$Ttests | % { & $f $_ }

(Und Sie können für die falschen Tests Ähnliches tun, aber ich werde es nicht hierher setzen, da es mehr von ihnen gibt). Die paar @Symbole sind erforderlich, wenn die Eingabe die einzige ist, '.'andernfalls wird bei der Aufteilung kein Array aus einer Zeichenfolge erstellt, sondern nur eine Zeichenfolge, und die Array-Verkettung gibt keine 1,1Ausgaben aus 2.

Ich hoffte, es könnte kürzer sein, alle Zeichen durch 'a' zu ersetzen und dann alle Quadrate 'a' mit roher Gewalt von 1 auf Eingabelänge zu setzen und zu prüfen, ob sie mit der Eingabe übereinstimmen. Sobald ich über param () und .Length und -join und -replace hinausgekommen bin, endet es viel länger bei 81 Bytes:

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

Schmutz , 11 Bytes

e`.|_./+/.+

Druckt 1für Quadrate und 0für Nichtquadrate. Probieren Sie es online!

Erläuterung

Eine ausführliche Erklärung finden Sie auf der Grime-Tutorial-Seite , die genau dieses Programm als Beispiel enthält.

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.