Aşağıdaki koşullar yerine getirildiğinde bir dize kare olarak kabul edilir:

• Her satırda aynı sayıda karakter var
• Her satırdaki karakter sayısı, satır sayısına eşittir.

Göreviniz verilen bir giriş dizesinin bir kare olup olmadığını belirleyen bir program veya işlev yazmaktır.

Seçtiğiniz LF, CR veya CRLF ile sınırlandırılmış olarak girmeniz gerekebilir.

Yeni satır karakterleri, satır uzunluğunun bir parçası olarak kabul edilmez.

Girişte ek bir satır sayılmayan takip eden bir yeni satır olmanız veya olmamanız gerekebilir.

Giriş bir dize veya 1D karakter dizisidir; dizelerin listesi değildir.

Girişin boş olmadığını ve boşluklar dahil yalnızca yazdırılabilir ASCII içerdiğini varsayabilirsiniz.

Kare dizeler için bir truthy, diğer dizeler için ise sahte bir değer vermelisiniz.

Truthy test durumları:

varsayılan değer
bar
baz

.

.s.
.SS
.s.
(s, alanı temsil ediyor)

ss
ss
(s, alanı temsil ediyor)

aaaaa
aaaaa
aaaaa
aaaaa
aaaaa

Sahte test durumları:

..
.

.

.

....


....

4444
333
22

333
333

abc.def.ghi

Bazı sahte durumlarda ekstra boş satırlar olduğunu unutmayın.

Bu kod golf - en az bayt kazanıyor!

Brachylog (2), 3 bayt

ṇẹṁ

Çevrimiçi deneyin!

Tam program true.Gerçekliğin çıktıları , falsey false.için.

açıklama

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

ṁEklendiğinde yerleşimin yararlılığı konusunda biraz şüpheliydim , ama burada gerçekten yararlı olduğunu inkar edemiyorum…

Brachylog (2), 7 bayt

ṇẹ.\l~l

Çevrimiçi deneyin!

Yerleşik olmayan çözüm. Yazma zamanından itibaren hala tüm diğer girişleri atıyor. EDIT: Tam olarak değil, ben bunu yazarken eşit uzunlukta Jelly girişi içeri girdi ve zaman damgası tiryaki üzerinden atıyor.

açıklama

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

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

Çevrimiçi deneyin! veya Tüm test durumlarını deneyin

JavaScript (ES6), 46 45 bayt

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

• ETHproductions'a 1 bayt kazandı

açıklama

1. Dize yeni satırlardaki bir diziye bölün.
2. Dizinin üzerinden döngü.
3. Dizinin uzunluğunu her çizginin uzunluğundan çıkarın.
4. Herhangi bir satır için sıfır olmayan (yani truthy) bir değer döndürülürse, dize kare değil.
5. Döngünün sonucunu truekare için olsun ve falseolmasın için olumsuzlayın .

Dene

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 bayt

¶¡€gDgQP

Çevrimiçi deneyin!

-2 Riley sayesinde, bu temelde onun cevabı.

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

Jöle , 7 5 bayt

Ỵ¬⁼Z$

Çevrimiçi deneyin!

FryAmTheEggman'a -2 için teşekkürler

Haskell, 38 34 bayt

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

Çevrimiçi deneyin!

Noktasız versiyonu f s = all ((==length (lines s)).length) (lines s), yani girişi satırlara bölün ve her satırın uzunluğunun satır sayısına eşit olup olmadığını kontrol edin.

Düzenleme: 4 bayt için @xnor teşekkürler.

Jöle , 7 bayt

ỴµL;L€E

Çevrimiçi deneyin!

açıklama

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

=Ur.Q)¥Uy

Çevrimiçi test edin!

açıklama

 =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

Bu zorluk gönderildikten kısa bir süre sonra uygulanan bazı özellikleri kullanarak, bu 6 bayt olabilir:

r.Q
¥y

Çevrimiçi test edin!

açıklama

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

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

Çevrimiçi deneyin! Açıklama: İlk aşama, eşleştirmeyi kolaylaştırmak için yazdırılabilir tüm ASCII'leri aynı karakterde değiştirir. (Bu olmadan yapılabilir, ancak bu kod golf, kod mücadelesi değil.) İkinci aşama, ilk satırdaki en az bir karakterle eşleşir. Ancak, ilk satırdaki her ek karakter için, isteğe bağlı olarak ilk satırın bir kopyasını izleyen yeni bir satırla eşleşir. İfadenin son kısmı, satırdan daha fazla sütun varsa eşleşmenin başarısız olmasına neden olur.

Kabuğu , 6 bayt

S≡T'a¶

Bir dize alır ve ya 1da yazdırır 0. Çevrimiçi deneyin! İlk satır, test durumlarını tekrar eder; Tek bir değer üzerinde test etmek istiyorsanız bunu kaldırın.

açıklama

Husk, ben ve Leo tarafından yaratılmış yeni bir fonksiyonel golf dilidir . Pek çok özelliği eksik ve geliştirme devam ediyor. Başlıca özelliği, yüksek dereceli fonksiyonları aşırı yüklememize izin veren sert tip bir sistemdir.

Yüksek düzeyde, program şöyle çalışır:

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.

İşlev ≡aslında, iki dizinin aynı şekle ve aynı truthy elementlerinin dağılımına sahip olup olmadığını kontrol eder. Husk'ta, boş byte dışındaki tüm karakterler truthy'dir ve bu girdilerimizde gerçekleşmez. Ayrıca, Sbir S-combinator , girişler iki burada fonksiyonları gibi götüren bir fonksiyon ≡ve T'ave iadeler haritalar bu yeni işlevi xiçin ≡(x)(T'a x). Bunun sonucu Soluşur ¶ve bu işlev girişe dolaylı olarak uygulanır.

Husk S, bir sonraki işleve uygulanması gerektiğini , ancak ¶soldaki işleve sahip olması gerektiğini nasıl biliyor ? Basit: sadece her yorumu dener ve türlerin anlamlı olduğu yeri seçer. Bu, Husk belgelerinde daha ayrıntılı olarak açıklanmaktadır .

Saf bash (yardımcı program yok), 55

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

• mapfile diziye girişi okur a
• daha sonra dizinin elemanlarının sayısı, her bir çizgi uzunluğunda ve toplanan toplamda XORed'dir. Mükemmel bir kare için, her bir XOR sonucu (ve dolayısıyla toplam) 0 olacaktır. Başka bir şey için, sonuç> 0 olur.

Bunun tam tersi bir kabuk dönüş kodu olarak döndürülür (inceleyin echo $?) - mükemmel kare 1, başka bir şey 0'dır.

Çevrimiçi deneyin (gerçek) .

Çevrimiçi deneyin (sahte) .

Eval-escape-genişleme cehennemini kullanarak önceki cevap, 78:

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

Çevrimiçi deneyin (gerçek) .

Çevrimiçi deneyin (sahte) .

Perl 6 , 27 bayt

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

Giriş dizesindeki satır sayısının her satırdaki karakter sayısına eşit olup olmadığını test eder.

Pyth, 7 bayt

CImL1.z

Burada dene

Sondaki hiçbir yeni satır gerektirmez. Girdiyi, 1'lerin orijinal girişteki herhangi bir karakteri temsil ettiği 1'li 2D dizisi ile değiştirir. Ardından, aktardıktan sonra dizinin değişip değişmediğini kontrol ederiz (sütunları satırlarla değiştiririz). Böyle bir durumda sadece bir kare gerçek olur.

Java (OpenJDK 8) ,96 91 90 87 bayt

@KevinCruijssen
-1 bayt sayesinde -5 bayt @TheLethalCoder
-2 bayt sayesinde @ OlivierGrégoire sayesinde

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

Çevrimiçi deneyin!

05AB1E , 7 bayt

|€gDgQP

Çevrimiçi deneyin!

R , 57 bayt

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

Anonim bir işlev; Yeni satırlara böler, her satırın uzunluğunu hesaplar ve hepsinin satır sayılarıyla aynı olup olmadığını kontrol eder.

Çevrimiçi deneyin!

Matl , 14 12 bayt

10H&XXot&n=h

Giriş dizgisi string bitiştirme ( [...]) kullanılarak ve LF'yi 10temsil etmek için kod noktasıyla tanımlanır . Örneğin, ['aaa' 10 'bb']MATL'de, string ile 'aaa'birleştirilen kod noktası olan karakterle 10birleştirilmiş string olarak yorumlanır 'bb'.

Çıktı boş olmayan bir sayısal vektördür, eğer ve sadece tüm girişleri sıfır olmayansa , gerçek değildir .

Çevrimiçi deneyin!

açıklama

Girişi düşünün ['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 bayt

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

Stdin'den girdi alır. Her satırdaki karakter sayısının toplam satır sayısına eşit olduğunu kontrol eder. İade TRUEveya FALSEuygun şekilde.

JavaScript (ES6), 48 bayt

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

CJam, 11 bayt

qN/:,_,f=:*

Çevrimiçi deneyin!

OCaml , 56 bayt

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

Çevrimiçi deneyin!

Pyth, 12 10 bayt

!fnl.zlT.z

@ FryAmTheEggman sayesinde 2 bayt kaydedildi.

Çevrimiçi deneyin

açıklama

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

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

Ben, bir QBasic türevinin bu zorlukta ne kadar kısa sürdüğü konusunda mutluyum.

Açıklama:

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

qCC.z.z

gösteri

Girdiyi iki kez keserek çevirin ve sonucun orijinal ile aynı olup olmadığını kontrol edin.

Ruby, 50 bayt

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

Çevrimiçi deneyin!

açıklama

1. Girişi yeni satırda diziye bölme.
2. Bu dizinin yalnızca boyutunu içeren bir dizinin, bu dizideki tüm öğelerin tüm uniq (boş dizili set birliği) boyutlarını içeren bir diziye eşit olduğunu kabul edin.

Çedar , 39 bayt

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

Çevrimiçi deneyin!

Clojure, 58 bayt

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

Daha büyülü bir şey görmeyi dört gözle bekleyen, yeni bir satır gerektirir.

APL (Dyalog) , 17 bayt

⎕ML←3Birçok sistemde varsayılan olanı gerektirir . CR kullanır.

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

Çevrimiçi deneyin!

↓∘⎕FMT Bölünmüş içine hatları [olup] F ya da m bir t ted-içine-a-kare argüman

≡ aynı

⎕TC[2]∘≠ newline olmayan grupların * karakterleri

⊂ bölmeli

⊢ argüman?

* T erminal C kontrol karakterleri listesinin ikinci elemanı .

Sürümünde 16.0, bir yazabilir ↓∘⎕FMT≡⎕TC[3]∘≠⊆⊢ile ⎕ML←1.

PowerShell, 64 bayt

Golf sahası dışındaki diğer dil cevaplarıyla aynı (bölünmüş, satır uzunluğu, satır sayısı) yaklaşır, ancak güzel bir harita () eşdeğeri yoktur, bu yüzden sonundan etiketlenen satır sayısıyla, sonra o dizi ile satır uzunluğu dizisidir. gruplandırılmış. Kareler gibi 3,3,3,3 -> 1 group, all line lengths and line count were equalve kareler gibi çıkmaz 3,2,1 -> 3 groups, karede eşit olmayan bir şey vardı:

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

Newline Linux tarzı sonlar gerektirir, sonunda yeni satır yok. Örneğin

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

$Ttests | % { & $f $_ }

(Sahte testler için de benzer şeyler yapabilirsiniz, ama daha fazlası olduğu için buraya koymuyorum). Çift @sembolleri girişi tek olduğunda için gerekli olan '.'o sadece bir dize yapar ve sonra dizi birleştirme çıkışı Bilmeyen dize dizisi yapmaz aksi bölme 1,1o çıkarır 2.

Tüm karakterleri 'a' ile değiştirmenin daha kısa olacağını ve daha sonra 'a' ile Girilen Uzunluk 'a' arasındaki toplam kuvvetin ve girişle eşleşen olup olmadığını görmeyi umuyordum. Param () ve .Length ve -joine and -replace'yi geçtikten sonra 81 baytta çok daha uzun biter:

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

Kiri , 11 bayt

e`.|_./+/.+

1Kareler ve kareler 0olmayanlar için yazdırır . Çevrimiçi deneyin!

açıklama

Bu tam programı örnek olarak içeren Grime eğitim sayfasında ayrıntılı bir açıklama bulunabilir .

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.