Una stringa è considerata quadrata se sono soddisfatte le seguenti condizioni:

• Ogni riga ha lo stesso numero di caratteri
• Il numero di caratteri su ogni riga è uguale al numero di righe.

Il tuo compito è scrivere un programma o una funzione che determina se una determinata stringa di input è o meno un quadrato.

Potrebbe essere necessario delimitare l'input a scelta tra LF, CR o CRLF.

I caratteri di nuova riga non sono considerati parte della lunghezza della linea.

Potrebbe essere necessario che ci sia o meno una nuova riga finale nell'input, che non conta come una riga aggiuntiva.

L'input è una stringa o array di caratteri 1D; non è un elenco di stringhe.

È possibile supporre che l'input non sia vuoto e contenga solo ASCII stampabili, inclusi gli spazi.

Devi generare un valore di verità per le stringhe quadrate e uno di falsa per le altre stringhe.

Casi di prova veritieri:

foo
bar
baz

.

.S.
.SS
.S.
(s rappresenta lo spazio)

ss
ss
(s rappresenta lo spazio)

AAAAA
AAAAA
AAAAA
AAAAA
AAAAA

Casi di prova falsi:

..
.

.

.

....


....

4444
333
22

333
333

abc.def.ghi

Nota righe vuote extra in alcuni casi falsi.

Questo è code-golf - vince meno byte!

Brachylog (2), 3 byte

ṇẹṁ

Provalo online!

Programma completo. Uscite true.per la verità, false.per la falsità.

Spiegazione

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

Ero un po 'scettico sull'utilità del ṁbuiltin quando è stato aggiunto, ma non posso davvero negare che sia utile qui ...

Brachylog (2), 7 byte

ṇẹ.\l~l

Provalo online!

Soluzione non integrata. Batte ancora tutte le altre voci, al momento della scrittura. EDIT: Non del tutto, la voce Jelly di uguale lunghezza è entrata mentre stavo scrivendo questo, e lo batte attraverso il tiebreak del timestamp.

Spiegazione

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

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

Provalo online! oppure Prova tutti i casi di test

JavaScript (ES6), 46 45 byte

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

• 1 byte salvato grazie a ETHproductions

Spiegazione

1. Dividi la stringa in un array su newline.
2. Passa sopra l'array.
3. Sottrai la lunghezza dell'array dalla lunghezza di ogni riga.
4. Se viene restituito un valore diverso da zero (ovvero, true) per qualsiasi riga, la stringa non è quadrata.
5. Annulla il risultato del loop per ottenere il truequadrato e falseper no.

Provalo

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 byte

¶¡€gDgQP

Provalo online!

-2 grazie a Riley, questa è sostanzialmente la sua risposta ._.

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

Gelatina , 7 5 byte

Ỵ¬⁼Z$

Provalo online!

Grazie a FryAmTheEggman per -2

Haskell, 38 34 byte

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

Provalo online!

Versione senza punti di f s = all ((==length (lines s)).length) (lines s), cioè dividere l'input in righe e verificare se la lunghezza di ciascuna riga è uguale al numero di righe.

Modifica: grazie a @xnor per 4 byte.

Gelatina , 7 byte

ỴµL;L€E

Provalo online!

Spiegazione

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

=Ur.Q)¥Uy

Provalo online!

Spiegazione

 =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

Utilizzando alcune funzionalità implementate poco dopo la pubblicazione di questa sfida, questo può essere di 6 byte:

r.Q
¥y

Provalo online!

Spiegazione

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

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

Provalo online! Spiegazione: Il primo passaggio modifica semplicemente tutte le ASCII stampabili nello stesso carattere per semplificarne la corrispondenza. (Si potrebbe fare a meno, ma questo è il golf del codice, non la sfida del codice.) Il secondo livello corrisponde quindi ad almeno un personaggio sulla prima riga. Tuttavia, per ogni carattere aggiuntivo sulla prima riga, corrisponde facoltativamente a una nuova riga seguita da una copia della prima riga. La parte finale dell'espressione fa fallire la corrispondenza se ci sono più colonne che righe.

Buccia , 6 byte

S≡T'a¶

Prende una stringa e stampa 1o 0. Provalo online! La prima riga scorre i casi di test; rimuoverlo se si desidera testare su un singolo valore.

Spiegazione

Husk è un nuovo linguaggio funzionale per il golf creato da me e Leo . Manca molte funzionalità e lo sviluppo è in corso. La sua caratteristica principale è un sistema di tipo rigido che ci consente di sovraccaricare le funzioni di ordine superiore.

Ad alto livello, il programma funziona in questo modo:

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 funzione ≡controlla effettivamente se due array hanno la stessa forma e la stessa distribuzione di elementi di verità. In Husk, tutti i caratteri tranne il byte null sono veritieri e ciò non si verifica nei nostri input. Inoltre, Sè il S-combinatore , una funzione che prende come input due funzioni, qui ≡e T'a, e restituisce una nuova funzione che le mappe xa ≡(x)(T'a x). Il risultato di Sè composto con ¶e quella funzione viene applicata implicitamente all'input.

Come fa Husk a sapere che dovrebbe applicarsi Salla funzione successiva, ma ¶dovrebbe essere composto con la funzione alla sua sinistra? Semplice: prova ogni interpretazione e sceglie quella in cui i tipi hanno un senso. Questo è spiegato in maggior dettaglio nella documentazione di Husk .

Bash puro (nessuna utility), 55

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

• mapfile legge l'input nell'array a
• quindi il numero di elementi dell'array viene XORed con ogni lunghezza di linea e la somma presa. Per un quadrato perfetto, ogni risultato XOR (e quindi la somma) sarà 0. Per qualsiasi altra cosa, il risultato sarà> 0.

Il senso opposto di questo viene restituito come codice di ritorno della shell (esaminare con echo $?) - il quadrato perfetto è 1, tutto il resto è 0.

Provalo online (verità) .

Provalo online (falsy) .

Risposta precedente utilizzando eval-escape-espansione hell, 78:

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

Provalo online (verità) .

Provalo online (falsy) .

Perl 6 , 27 byte

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

Verifica se il numero di righe nella stringa di input è uguale al numero di caratteri su ciascuna riga.

Pyth, 7 byte

CImL1.z

Provalo qui

Non richiede newline finali. Sostituisce l'input con una matrice 2D di 1s in cui un 1 rappresenta qualsiasi carattere nell'input originale. Quindi controlliamo se quell'array è invariato dopo averlo trasposto (sostituendo le colonne con le righe). Solo una casella tornerà vera in una situazione del genere.

Java (OpenJDK 8) ,96 91 90 87 byte

-5 byte grazie a @KevinCruijssen
-1 byte grazie a @TheLethalCoder
-2 byte grazie a @ OlivierGrégoire

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

Provalo online!

05AB1E , 7 byte

|€gDgQP

Provalo online!

R , 57 byte

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

Una funzione anonima; Si divide su newline, calcola la lunghezza di ogni riga e controlla se tutti sono uguali al numero di righe.

Provalo online!

MATL , 14 12 byte

10H&XXot&n=h

La stringa di input viene definita utilizzando la concatenazione di stringhe ( [...]) e con il punto di codice 10per rappresentare LF. Ad esempio, ['aaa' 10 'bb']viene interpretato in MATL come stringa 'aaa'concatenata al carattere con punto di codice 10concatenato con stringa 'bb'.

L'output è un vettore numerico non vuoto, che è vero se e solo se tutte le sue voci sono diverse da zero.

Provalo online!

Spiegazione

Considera l'input ['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 byte

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

Riceve input dallo stdin. Verifica che il numero di caratteri in ciascuna riga sia uguale al numero totale di righe. Resi TRUEo FALSEcome appropriato.

JavaScript (ES6), 48 byte

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

CJam, 11 byte

qN/:,_,f=:*

Provalo online!

OCaml , 56 byte

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

Provalo online!

Pyth, 12 10 byte

!fnl.zlT.z

Salvato 2 byte grazie a @FryAmTheEggman.

Provalo online

Spiegazione

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

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

Sono contento di quanto sia corto un derivato di QBasic per affrontare questa sfida.

Spiegazione:

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

qCC.z.z

Dimostrazione

Trasponi due volte l'input con troncamento, quindi controlla se il risultato è lo stesso dell'originale.

Rubino, 50 byte

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

Provalo online!

Spiegazione

1. Dividi input in array su newline.
2. Asserire che un array contenente solo le dimensioni di questo array è uguale a un array che contiene tutte le dimensioni uniq (imposta unione con array vuoto) di tutti gli elementi in questo array.

Cheddar , 39 byte

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

Provalo online!

Clojure, 58 byte

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

Richiede una nuova riga finale, in attesa di vedere qualcosa di più magico.

APL (Dyalog) , 17 byte

Richiede il ⎕ML←3valore predefinito su molti sistemi. Usa CR.

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

Provalo online!

↓∘⎕FMT [è] l' argomento diviso in righe F o m a t ted-in-a-square

≡ uguale a

⎕TC[2]∘≠ i caratteri-in-gruppi-di-non-newline *

⊂ partizionato

⊢ discussione?

* Il secondo elemento della lista dei T erminal C caratteri ontrol.

Nella versione 16.0, si può scrivere ↓∘⎕FMT≡⎕TC[3]∘≠⊆⊢con ⎕ML←1.

PowerShell, 64 byte

Lo stesso approccio (diviso, lunghezza delle linee, numero di linee) delle altre risposte non linguistiche, ma non esiste un bel map () equivalente, quindi è una matrice di lunghezze di linea con il numero di linee taggate alla fine, quindi quella matrice è raggruppato. I quadrati escono come 3,3,3,3 -> 1 group, all line lengths and line count were equale i non quadrati escono come 3,2,1 -> 3 groups, qualcosa era ineguale nella piazza:

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

Richiede terminazioni in stile Linux newline, nessuna newline finale. per esempio

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

$Ttests | % { & $f $_ }

(E puoi fare lo stesso per i falsi test, ma non lo metterò qui perché ce ne sono altri). La coppia di @simboli è necessaria per quando l'input è il singolo '.'altrimenti la divisione non crea una matrice di una stringa ma solo una stringa, e quindi la concatenazione della matrice non 1,1genera output 2.

Speravo che potesse essere più breve sostituire tutti i caratteri con 'a', quindi forza bruta da 1 a Lunghezza input tutti i quadrati 'a' e vedere se qualcuno corrispondeva all'input. Una volta superato param () e .Length e -join e -replace, finisce molto più a lungo a 81 byte:

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

Grime , 11 byte

e`.|_./+/.+

Stampa 1per quadrati e 0per non quadrati. Provalo online!

Spiegazione

Una spiegazione dettagliata può essere trovata nella pagina del tutorial di Grime , che sembra contenere questo esatto programma come esempio.

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.