Chúng tôi nói rằng một chuỗi không phân biệt đối xử nếu mỗi ký tự của chuỗi xuất hiện cùng một số lần và ít nhất hai lần.

Ví dụ

• "aa!1 1 !a !1"là không phân biệt đối xử vì mỗi người trong số các nhân vật , !, avà 1xuất hiện ba lần.
• "abbaabb"không phải là không phân biệt đối xử vì bxuất hiện thường xuyên hơn a.
• "abc"cũng không phải là không phân biệt đối xử vì các nhân vật không xuất hiện ít nhất hai lần.

Bài tập, nhiệm vụ

Viết không phân biệt đối xử chương trình hoặc chức năng mà trả về một truthy giá trị nếu một chuỗi nhất định là không phân biệt đối xử , và một falsy giá trị khác.

Đó là, chương trình chạy trên mã nguồn riêng của nó sẽ trả về một giá trị trung thực.

Mỗi lần gửi phải có khả năng xử lý các chuỗi không trống chứa ASCII có thể in được , cũng như tất cả các ký tự xuất hiện trong mã nguồn của nội dung gửi.

Các trường hợp thử nghiệm

Sự thật:

<your program's source code>
"aaaa"
"aa!1 1 !a !1"
"aabbccddeeffgg"
"1Q!V_fSiA6Bri{|}tkDM]VjNJ=^_4(a&=?5oYa,1wh|R4YKU #9c!#Q T&f`:sm$@Xv-ugW<P)l}WP>F'jl3xmd'9Ie$MN;TrCBC/tZIL*G27byEn.g0kKhbR%>G-.5pHcL0)JZ`s:*[x2Sz68%v^Ho8+[e,{OAqn?3E<OFwX(;@yu]+z7/pdqUD"

Giả mạo:

"a"
"abbaabb"
"abc"
"bQf6ScA5d:4_aJ)D]2*^Mv(E}Kb7o@]krevW?eT0FW;I|J:ix %9!3Fwm;*UZGH`8tV>gy1xX<S/OA7NtB'}c u'V$L,YlYp{#[..j&gTk8jp-6RlGUL#_<^0CCZKPQfD2%s)he-BMRu1n?qdi/!5q=wn$ora+X,POzzHNh=(4{m`39I|s[+E@&y>"

Brachylog , 10 byte

=ᵍbᵐbᵐlᵍ=l

Hãy thử trực tuyến!

Giải trình

=ᵍ                Group all equal elements together
  bᵐbᵐ            Remove the first element of each group twice. This fails if
                  there are fewer than 2 elements
      lᵍ          Group elements together that have the same length
        =         Are all elements of that list equal? This only succeeds if the
                  list has one element
         l        Length. This will always succeed

Java 8, 198 192 186 174 168 165 160 byte (số đếm 6 5)

o->{byte x[]=new byte[+333-3|2],u=-0,i,fe,fi,w; s:w:no0r3sswwyyy:for(int s:o){{u=++x[s];}};for(int b:x){if(!!!(2>b||u==b)|2>u|2>2){x[0]++;}}return!!(0>--x[0]);}

Hãy thử trực tuyến.
Mã được sử dụng để xác minh sự xuất hiện của các nhân vật , đó là câu trả lời của tôi cho thử thách này .

-5 byte nhờ @ OlivierGrégoire một lần nữa bằng cách loại bỏ nhận xét và tạo ra một mớ hỗn độn. ;)

Câu trả lời cũ 168 byte (char-Count 6) :

o->{int w[]=new int[2222],u=0,f=0;for(int r:o)u=++w[r];for(int e:w)if(!(2>e|u==e)|2>u)f++;return!(f>0);}//[[[]]]  !!!!e(i)++,,,,-----oo////000tuww::::{{{{{;;||||}}}}}>>

Hãy thử trực tuyến.
Mã được sử dụng để xác minh sự xuất hiện của các ký tự không bao gồm nhận xét , đó là câu trả lời của tôi cho thử thách này .

-6 byte nhờ @ OliverGrégoire xóa <bằng cách hoán đổi các kiểm tra sang >.

Giải thích về chương trình chơi gôn cơ sở (98 byte):
Hãy thử trực tuyến.

s->{                     // Method with character-array parameter and boolean return-type
  int a[]=new int[256],  //  Occurrences integer-array containing 256 zeroes
      t=0,               //  Temp integer, starting at 0
      f=0;               //  Flag integer, starting at 0
  for(int c:s)           //  Loop over the input
    t=++a[c];            //   Increase the occurrence-counter of the current character
                         //   And set the temp integer to this value
  for(int i:a)           //  Loop over the integer-array
    if(i>1               //   If the value is filled (not 0) and at least 2,
       &i!=t             //   and it's not equal to the temp integer
       |t<2)             //   Or the temp integer is lower than 2
      f++;               //    Increase the flag-integer by 1
  return f<1;}           //  Return whether the flag integer is still 0

Một số điều tôi đã làm để giảm số lượng ký tự được sử dụng:

• Tên biến o, w, u, f, r, và eđược chọn vào mục đích nhân vật để tái sử dụng, chúng tôi đã có (nhưng không quá 6).
• 2222được sử dụng thay vì 256.
• Thay đổi nếu kiểm tra e>0&u!=e|u<2để !(e<2|u==e)|u<2loại bỏ 6x &.
• Đã xóa hai trả về tách biệt và sử dụng một cờ f, và chúng tôi trả về cho dù cuối cùng vẫn là 0 (điều này có nghĩa là tôi có thể xóa 6x bykể từ bytebây giờ mà chúng tôi chỉ sử dụng ntrong int6 lần thay vì 8).
• e<2và u<2thay đổi thành 2>evà 2>uloại bỏ 6x <.

Tôi đã làm gì để giảm số đếm từ 6 xuống còn 5:

• 2x intđể bytesố lượng nsử dụng là 4 thay vì 6.
• Được sử dụng x[0]thay cho một biến mới f=0nên lượng =sử dụng là 5 thay vì 6.
• Thay đổi 2222thành 3333số lượng 2sử dụng là 2 thay vì 6.
• Thay đổi biến fvà rmột lần nữa để chúng không còn 6 nữa.

Những gì @ OlivierGrégoire đã làm để thoát khỏi bình luận, và do đó 5x /:

• Thêm các biến không sử dụng ,i,fe,fi,w;.
• Thêm nhãn không sử dụng : s:w:no0r3sswwyyy:.
• Thêm không sử dụng |2>2
• Thêm {}xung quanh các vòng lặp for và ifs, và thêm một {}-block không sử dụng .
• Đổi !sang !!!.
• Đổi |sang ||.
• Thay đổi 333để +333-3|2loại bỏ các toán tử số học còn sót lại +-|và 2.
• Đổi !(x[0]>0)sang !!(0>--x[0]).

Thạch , 18 16 12 10 byte

Ġ¬zḊḊ¬zĠȦȦ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Ġ¬zḊḊ¬zĠȦȦ  Main link. Argument: s (string)

Ġ           Group the indices of s by their corresponding elements.
            "abcba" -> [[1, 5], [2, 4], [3]]

 ¬          Take the logical NOT of each 1-based(!) index.
            [[1, 5], [2, 4], [3]] -> [[0, 0], [0, 0], [0]]

   Ḋ        Dequeue; yield s without its fist element.
            "abcba" -> "bcba"

  z         Zip-longest; zip the elements of the array to the left, using the
            string to the right as filler.
            ([[0, 0], [0, 0], [0]], "bcba") -> [[0, 0, 0], [0, 0, "bcba"]]

    Ḋ       Dequeue; remove the first array of the result.
            This yields an empty array if s does not contain duplicates.
            [[0, 0, 0], [0, 0, "bcba"]] -> [[0, 0, "bcba"]]

    ¬       Take the logical NOT of all zeros and characters.
            [[0, 0, "bcba"]] -> [[1, 1, [0, 0, 0, 0]]]

      Ġ     Group.

     z      Zip-longest. Since all arrays in the result to the left have the same
            number of elements, this is just a regular zip.
            [[1, 1, [0, 0, 0, 0]]] -> [[1], [1], [[0, 0, 0, 0]]

       Ȧ    Any and all; test if the result is non-empty and contains no zeroes,
            at any depth. Yield 1 if so, 0 if not.
            [[1], [1], [[0, 0, 0, 0]] -> 0

        Ȧ   Any and all.
            0 -> 0

Brachylog , 14 12 byte

ọtᵐℕ₂ᵐ==tℕ₂ọ

Hãy thử trực tuyến!

Giải trình

ọ   Occurrences. Gives a list of [char, count] pairs for the entire input.
tᵐ  Map "tail" over this list, giving each character count.
ℕ₂ᵐ Make sure that each count is at least 2.
=   Make sure that all counts are equal.
    At this point we're done with the actual code, but we need another copy
    of each character (except ᵐ). We can just put them after this, as long as
    we make sure that they can never cause the predicate to fail.
=   Make sure that all counts are equal, again...
t   Extract the last count.
ℕ₂  Make sure that it's at least 2, again...
ọ   Get the digit occurrences in that count, this can't fail.

Giải pháp 12 byte tthay thế sử dụng lại thay vì ᵐ:

ọtᵐ==tℕ₂ℕ₂ọᵐ

T-SQL, 320 byte (32 ký tự x 10 mỗi ký tự)

Đầu vào là thông qua bảng có sẵn FILLvới trường varchar STEW, theo tiêu chuẩn IO của chúng tôi .

WITH BUMPF AS(SeLeCT GYP=1
UNION ALL
SeLeCT GYP+1FROM BUMPF
WHeRe GYP<=1000)SeLeCT
IIF(MIN(WAXBY)<MAX(WAXBY)OR
MAX(WAXBY)<=1,+0,+1)FROM(SeLeCT
WAXBY=COUNT(1),WHICH=+1+0,HEXCHANGE=+01,HUNG=+0+1,CHLUB=+0,GEFF=+0FROM
BUMPF,FILL WHERE
GYP<=LEN(STEW)GROUP BY
SUBSTRING(STEW,GYP,1))CHEXX
OPTION(MAXRECURSION 0)----------<<<<<<

Tôi chưa bao giờ hài lòng hơn, nhưng kinh hoàng, bởi một đoạn mã.

Phải được chạy trên máy chủ hoặc cơ sở dữ liệu được đặt thành đối chiếu phân biệt chữ hoa chữ thường. Có 10 trong số 32 ký tự khác nhau, bao gồm cả chữ hoa và chữ thường E(các lệnh SQL không phân biệt chữ hoa chữ thường, vì vậy hãy lật một số khi cần thiết), dấu cách và tab (các tab được hiển thị dưới dạng ngắt dòng trong mã ở trên, để dễ đọc).

Tôi đã tìm ra cách để bao gồm 10 ký hiệu khác + = ,trong mã, nhưng không may là không thể tìm ra cách để làm điều đó <, vì vậy tôi phải thêm ký tự nhận xét -.

Đây là mã được định dạng trước khi tôi nhồi nhét vào tất cả các phần bổ sung:

WITH b AS (SELECT g=1 UNION ALL SELECT g+1 FROM b WHERE g<1000)
SELECT IIF(MIN(w)<MAX(w) OR MAX(w)<1+1,0,1)
FROM(
    SELECT w=COUNT(1), --extra constant fields here are ignored
    FROM b, fill
    WHERE g < 1+LEN(stew)
    GROUP BY SUBSTRING(stew,g,1)
)a OPTION(MAXRECURSION 0)

Dòng trên cùng là một CTE đệ quy tạo ra một bảng số b, chúng ta nối với chuỗi nguồn để phân tách theo ký tự. Các ký tự đó được nhóm và tính, và IIFcâu lệnh trả về 0 hoặc 1 tùy thuộc vào việc chuỗi đầu vào không phân biệt đối xử.

C (gcc) ,  333  168 byte

Cảm ơn @Kevin Cruijssen vì đã tiết kiệm 9 byte và cảm ơn @Laikoni vì đã tiết kiệm 45 byte!

f(r,h,a){char*o=r,c[222]={!o};for(a=!o;*o;)++c[*o++];for(h=!o;222/++h;c[h]&&c[h]!=a&&(a=!*c))!a&&c[h]&&(a=c[h]);r=!(2/2/a);}/////!(())****++,,,,,[[]]fffffrr{{{{{{}}}}}}

Hãy thử trực tuyến!

C, 333 byte

i,v;f(S){char*s=S,L[128]={0};for(v=0;*s;)++L[*s++];for(i=-1;++i<128;L[i]&&L[i]-v?v=-1:0)!v&&L[i]?v=L[i]:0;return-v<-1;}/////////!!!!!!!!&&&&&(((((())))))******+++,,,,,,,----00000111122222228888888:::::::<<<<<<<===???????LLLSSSSSSS[[[]]]aaaaaaaacccccccceeeeeeeeffffffhhhhhhhhiinnnnnnnnooooooorrrrssssssttttttttuuuuuuuuvv{{{{{{{}}}}}}}

Ngay cả bytecount là không phân biệt đối xử!

Hãy thử trực tuyến!

05AB1E , 20 18 16 14 byte

S¢Z≠sË*sZ¢≠SË*

Hãy thử trực tuyến!

Chương trình về cơ bản được chia thành 2 phần trong đó mục tiêu của phần đầu tiên là thực hiện nhiệm vụ thực tế và mục tiêu của phần thứ hai là sử dụng các chức năng tương tự như phần đầu tiên mà không làm thay đổi kết quả.

Giải thích (phần đầu tiên)

S          # push input split into list of chars
 ¢         # count the occurrence of each char in input
  Z≠       # check that the max count is not 1
    sË     # check if all counts are equal
      *    # multiply

Giải thích (phần thứ hai)

s          # swap input to top of stack
 Z¢        # count the number of occurrences of the largest element
   ≠       # check that the count isn't 1
    SË     # split into list and check that each element are equal (always true)
      *    # multiply (as it is with 1, the original result is left unchanged)

Husk , 14 byte

§<ε#εu§m#u
m
<

Hãy thử trực tuyến!

Giải trình

Hai dòng ngắn là no-op, vì hàm chính không bao giờ gọi chúng.

§<ε#εu§m#u  Implicit input, say S = "asasdd"
         u  Remove duplicates: "asd"
      §m#   For each, get number of occurrences in S: [2,2,2]
     u      Remove duplicates: L = [2]
   #ε       Number of elements in L that are at most 1: 0
  ε         1 if L is a singleton, 0 otherwise: 1
§<          Is the former value smaller than the latter?

Python 2 , 75 69 byte

def f(s):len({2<<s.count(c)-2for c,in s})<2or{{e.dil:-tu,r.dil:-tu,}}

Đầu ra là thông qua sự hiện diện hoặc vắng mặt của một lỗi. Lỗi là ValueError (một hoặc nhiều ký tự chỉ xảy ra một lần) hoặc NameError (số lượng ký tự không bằng nhau).

Hãy thử trực tuyến!

Brachylog v2, 8 byte (trong bộ ký tự của Brachylog)

oḅ\k\koḅ

Hãy thử trực tuyến!

Có vẻ như đã có một cuộc chiến golf xảy ra với câu hỏi này trong Brachylog, vì vậy tôi nghĩ rằng tôi đã tham gia, tiết kiệm một vài byte cho câu trả lời hay nhất tiếp theo.

Đây là một chương trình đầy đủ lấy đầu vào làm danh sách mã ký tự. (Điều này một phần là do Brachylog dường như có một số lỗi rất kỳ quái liên quan đến dấu gạch chéo ngược trong chuỗi và một phần vì \lệnh không hoạt động trên danh sách các chuỗi.)

Giải trình

oḅ\k\koḅ
o          Sort {standard input}
 ḅ         Group identical adjacent values
  \        Assert rectangular; if it is, swap rows and columns
   k       Delete last element
    \      Assert rectangular; (rest of the program is irrelevant)

Các koḅcuối cùng là không thích hợp; ksẽ luôn có một yếu tố để hành động ovà ḅkhông thể thất bại nếu được đưa ra một danh sách làm đầu vào.

Lý do cho sự khởi đầu oḅnên rõ ràng; nó phân vùng danh sách đầu vào theo giá trị, ví dụ [1,2,1,2,4,1]sẽ trở thành [[1,1,1],[2,2],[4]]. Để mỗi ký tự xuất hiện cùng một số lần, mỗi danh sách này phải có cùng độ dài, tức là danh sách kết quả là một hình chữ nhật. Chúng ta có thể khẳng định hình chữ nhật này bằng cách sử dụng \, cũng chuyển đổi các hàng và cột làm hiệu ứng phụ.

Bây giờ chúng ta có một giá trị hiện tại bao gồm nhiều bản sao của bộ ký tự, ví dụ: nếu đầu vào là [4,2,1,2,4,1]giá trị hiện tại sẽ là [[1,2,4],[1,2,4]]. Nếu chúng ta xóa một bản sao, ma trận kết quả vẫn là hình chữ nhật, vì vậy chúng ta có thể quay lại bằng cách sử dụng \. Tuy nhiên, nếu nguyên nhân ma trận là hình chữ nhật là tất cả các ký tự đầu vào là khác nhau, ma trận kết quả sẽ không có trái yếu tố, và \không không đối xử với một "0 × 0" ma trận là hình chữ nhật (đúng hơn, nó không thành công). Vì vậy, oḅ\k\khẳng định một cách hiệu quả rằng mỗi ký tự xuất hiện trong đầu vào xuất hiện cùng một số lần và số lần đó không phải là 1.

Đó là toàn bộ chức năng của chương trình của chúng tôi (như một chương trình đầy đủ, chúng tôi nhận được truenếu không có lỗi xác nhận nào xảy ra, falsenếu một số đã xảy ra ). Tuy nhiên, chúng tôi phải tuân theo các hạn chế bố cục nguồn, vì vậy tôi đã thêm một bổ sung koḅkhông có mục đích nhưng không thể thất bại (không giống như \, ovà ḅrất vui khi hành động trong danh sách trống).

Python 2 , 84 80 byte

x=input()
c=map(x.count,x)
print max(c)==min(c)>1
1. or our>ram>>utopia,
1., 1.,

Hãy thử trực tuyến!

JavaScript (Node.js) , 144 ... 100 96 byte

o=>!(a=o.split``.map(i=>o.split(i||aeehhhlmmnnnpst)[`length`]-1)).some(g=>![g>1][-!1]||a[-!1]-g)

Hãy thử trực tuyến!

24 ký tự khác nhau * 6 lần mỗi ký tự

28 ký tự khác nhau * 5 lần mỗi ký tự

27 ký tự khác nhau * 5 lần mỗi ký tự

27 ký tự khác nhau * 4 lần mỗi ký tự

26 ký tự khác nhau * 4 lần mỗi ký tự

25 ký tự khác nhau * 4 lần mỗi ký tự

24 ký tự khác nhau * 4 lần mỗi ký tự

Giải trình

o=>!(
 a=o.split``.map(                            // Split the input into character array and
  i=>o.split(i||aeehhhlmmnnnpst)[`length`]-1 // count the occurrences of each character.
 )
).some(                                      // Then check
 g=>![g>1][-!1]                              // If each character appears at least twice
 ||a[-!1]-g                                  // and the counts are all the same number.
)                                            

More to add:
1. Using {s.split``} instead of {[...s]} is to reduce the number of {.} that dominates
   the count.
2. Using {!c.some} instead of {c.every} to reduce the number of inefficient characters 
   (v,r,y in every)
3. Still one unavoidable inefficient character left ({h}).

Update:
1. Got rid of one {.} by replacing {.length} by {["length"]}.
2. Got rid of one {=} by replacing {c[-!1]!=g} by {c[-!1]-g}.
3. Got rid of one {()} by replacing {!(g>1)} by {![g>1][-!1]}.
4. Finally, because count per character is now 4, the backslashes can be taken out.

Update:
1. Got rid of all {"} by replacing {"length"} by {`length`} and exploiting shortcut
   evaluation. 
   {aaaeehhhlmmnnnpst} is not defined but is not evaluated either because of {c} which
   must be evaluated to true.

Update:
1. Got rid of all {c} by shortcutting the undefined variable at {split(i)} and replacing 
   all {c} by {a}.
   Since {i} is never an empty string, it is always evaluated true (except compared 
   directly to true).

Update:
1. Got rid of all {,} by moving the assignment after the argument list. The {()} at the
   front can therefore be moved to the assignment, retaining same number of {()}s.

PowerShell , 104 byte

($qe=$args[0]| group |sort count|% count)[0]-eq$qe[-1]-and$qe[0]-gt1####((()))%%%pppddd===aaccss11nu|0gr

Hãy thử trực tuyến!

Đây là niềm vui lớn để chơi gôn. Giới hạn là $, chúng ta cần tối thiểu bốn điểm (một cho đầu vào $args, một để gán kết quả tính toán $qe, một để kiểm tra ký tự cuối cùng $qe[-1]và một để kiểm tra ký tự đầu tiên $qe[0], vì vậy đó là số ký tự tối đa hoạt động.

Từ đó, vấn đề chơi golf (và không chơi gôn, giống như có một tên biến gồm hai chữ cái) để có được chương trình chia hết cho bốn. Lưu ý rằng chúng tôi có một nhận xét nhỏ (mọi thứ theo sau #) để tính đến một số yếu tố còn thiếu, nhưng tôi đã cố gắng giữ bình luận nhỏ nhất có thể.

Haskell, 90 75 72 byte

a[i]|d:n<-[[i|n<-i,n==a]|a<-i]=and[[i]<d,[d|i<-n]==n]--aadd,,,,:::::<=||

Mỗi nhân vật xuất hiện 6 lần. Chuỗi đầu vào được lấy dưới dạng danh sách đơn .

Hãy thử trực tuyến!

Để tham khảo, phiên bản cũ:

75 byte, mỗi char 5 lần

n(l)|d<-[[0|n<-l,n==a]|a<-l]=and[[0]<d!!0,all(==d!!0)d]--an!((())),,,0<[]||

Hãy thử trực tuyến!

90 byte, mỗi char 3 lần:

a x|h:u<-[sum[1|d<-x,not(d/=c)]|c<-x],"  \"\\&,../1::>acdlmmnosst">[]=h>1&&all(not.(/=h))u

Hãy thử trực tuyến!

Python 2 , 108 104 92 88 byte

-12 byte nhờ Rod
-4 byte nhờ Kevin Cruijssen

s=input();c=s.count;print[all(c(s[[]>[1]])==c(o)>1. for o in s)];aaafffillpprrtuu>1.>1.;

Hãy thử trực tuyến!

MATL , 12 byte

q&=sqt&=tsvv

Đầu vào là một chuỗi được bao trong các dấu ngoặc đơn. Dấu ngoặc đơn trong chuỗi được thoát bằng cách nhân đôi.

Đầu ra là một ma trận không trống, đó là truthy nếu nó không chứa số không, và là falsy nếu nó chứa ít nhất một số không.

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp kiểm tra , bao gồm kiểm tra tính trung thực / giả mạo tiêu chuẩn để thuận tiện.

Làm thế nào nó hoạt động

Các câu lệnh được đánh dấu (*)là không cần thiết cũng không có hại và chỉ được đưa vào để làm cho mã nguồn không phân biệt đối xử.

q     % Implicit input. Convert chars to code points and subtract 1 from each (*)
&=    % Square matrix of all pairwise equality comparisons
s     % Sum of each column. Gives a row vector
q     % Subtract 1 from each value. An entry equal to 0 indicates the input string
      % is discriminating because some character appears only once
t     % Duplicate
&=    % Square matrix of all pairwise equality comparisons. An entry equal to 0
      % indicates the input string is discriminating because some character is
      % more repeated than some other
t     % Duplicate (*)
s     % Sum of each column (*) (all those sums will be positive if the previous
      % matrix doesn't contain zeros)
v     % Vertically concatenate the matrix and the vector of its column sums
v     % Vertically concatenate the resulting matrix with nothing (*)
      % Implicit display

Perl 5 , -p57 byte

Mỗi nhân vật xuất hiện 3 lần. Chỉ một người 1không làm gì cả

12 byte được thêm vào giải pháp 45 ký tự cơ bản để không phân biệt đối xử

s{.}[@m[@1{$&}+=$.].=g]eg;$\=s()(e@m;1)&&m[e(\sg+)\1+;]}{

Hãy thử trực tuyến!

R , 90 byte

"?"=`u\164f8ToI\x6Et`;'!'=prod;!{y<-xtabs(~?readLines())}%in%{z<-y[1]}&z>T##&[]>~48bEfILpu

Hãy thử trực tuyến!

Đầu ra TRUEcho một chuỗi không phân biệt đối xử và FALSEcho một chuỗi phân biệt đối xử. Tôi đã viết rất nhiều mã xấu cho các thử thách trên trang web này, nhưng tôi nghĩ rằng đây là mã xấu nhất cho đến nay.

45 ký tự, được sử dụng hai lần mỗi ký tự (bao gồm một vài trong một nhận xét). Câu trả lời R tốt nhất trước đó là 116 byte , với 29 ký tự được sử dụng 4 lần mỗi ký tự; Tôi đang đăng bài này một cách riêng biệt vì nó là khác nhau đáng kể.

Mã tương đương với

y = table(utf8ToInt(readLines()))
z = y[1]
all(y == z) & (z > 1)

trong đó chuyển đổi đầu vào thành một vectơ số nguyên, tính toán bảng dự phòng ycủa các giá trị, sau đó kiểm tra xem tất cả các số trong bảng đó có bằng số đếm đầu tiên không và số đếm đầu tiên lớn hơn 1.

Khó khăn ban đầu là chỉ sử dụng 2 cặp dấu ngoặc. Điều này đạt được bằng cách xác định lại chức năng unary !và ?được utf8ToIntvà prodtương ứng. (Tôi không thể sử dụng allvì tôi cần a). Có bốn bài tập: hai với =và hai với <-. Điều này có nghĩa là kiểm tra đẳng thức giữa yvà zkhông thể sử dụng y==zcũng không y-z; y%in%zđến giải cứu.

Việc xác định các hàm này sử dụng hết tất cả các trích dẫn có thể có: hai trích dẫn kép, hai trích dẫn đơn và tôi sẽ cần hai backticks trong đoạn tiếp theo, vì vậy tôi phải dùng đến readLines()thay vì scan(,""). (Các tùy chọn khác, chẳng hạn như scan(,letters)hoặc scan(,month.abb)tất cả đều sử dụng một thứ quý giá t mà tôi không thể dự phòng.)

Tại thời điểm này, tôi đã có hầu hết các khối xây dựng: utf8ToInt, prod, table, readLines, %in%. Ba ký tự xuất hiện ba lần trong các tên đó : ent. Đầu tiên, tôi phát hiện ra rằng table(foo)tương đương với xtabs(~foo), tiết kiệm e. Tôi có thể giải cứu nvà tvới thủ thuật mã hex / bát phân ; giải pháp tốt nhất là sử dụng u\164f8ToI\x6Et(trong backticks) cho utf8ToInt.

Brachylog , 18 byte

oḅlᵐ=h≥2
oḅlᵐ=h≥2

Hãy thử trực tuyến!

Thật không may, tôi không thể loại bỏ các nguồn cấp dữ liệu, vì ḅtrên một số kích hoạt thất bại.

Ruby , 87 78 byte

c=->m{y=m.chars;x=y.map{|d|y.count d}|[];x[-1]>1and not x[1]};->{pushrortpush}

26 ký tự lặp lại 3 lần mỗi ký tự

Hãy thử trực tuyến!

R, 132 116 byte

crudcardounenforceableuploads<-function(b){{pi&&pi[[1-!1]];;;"";{1<{f<<-table(strsplit(b,"",,,)[[1]])}}&&!!!sd(-f)}}

Nó cũng không chứa bất kỳ bình luận hoặc chuỗi thừa nào, mặc dù đây có lẽ sẽ là lần duy nhất của tôi trong việc gọi mã golf crudcardounenforceableuploads. Có lẽ có một đảo chữ tuyệt vời ở đâu đó cho tên hàm! Cảm ơn John Dvorak đã chỉ ra một trình giải đảo chữ đẹp, mà tôi đã sử dụng cho tên này.

Bảng nhân vật:

- , ; ! " ( ) [ ] { } & < 1 a b c d e f i l n o p r s t u 
4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4

ví dụ:

> crudcardounenforceableuploads("aaabbbccc")
[1] TRUE
> crudcardounenforceableuploads("aaabbbcc")
[1] FALSE
> crudcardounenforceableuploads("abc")
[1] FALSE
> crudcardounenforceableuploads("crudcardounenforceableuploads<-function(b){{pi&&pi[[1-!1]];;;\"\";{1<{f<<-table(strsplit(b,\"\",,,)[[1]])}}&&!!!sd(-f)}}")
[1] TRUE

BASH 144 byte

grep -o .|sort|uniq -c|awk '{s=$1}{e[s]=1}END{print((s>1)*(length(e)==1))}##>>>#|'#wwwuuutrqqqppooNNNnlllkkkiihhhggEEEDDDcccaaa1***{}[[[]]]...--''

Dòng mã này lấy một chuỗi stdin làm đầu vào. "grep -o." đặt mỗi nhân vật trên một dòng mới. "uniq -c" đếm số lần sử dụng của vi khuẩn. Tập lệnh awk tạo một mảng với mỗi cách sử dụng là một phần tử khác nhau và xuất ra đúng khi chỉ có 1 chỉ số mảng và giá trị ít nhất là 2. Mỗi ký tự được sử dụng 4 lần, vì vậy nguồn này trả về đúng

Stax , 26 24 18 byte

:u{m*_{y#m:u_hy#h*

Hãy thử trực tuyến!

Giải pháp ngắn nhất cho đến nay chỉ sử dụng ASCII có thể in được BeatL bởi MATL.

Đoán tôi đã tiếp cận vấn đề sai cách. Lặp đi lặp lại một khối làm việc không phải là golf hay thú vị. Bây giờ ít nhất nó có vẻ tốt hơn ...

Giải trình

:u{m* tạo ra một số rác không ảnh hưởng đến đầu ra.

_{y#m:u_hy#h*
_{y#m           map each character to its number of occurences in the string
     :u         all counts are equal (result 1)
       _hy#     get the count of appearance for the first character
           h    halve it and take the floor, so that 1 becomes 0(result 2)
            *   multiply the two results

Pip , 22 byte

I1&MY$=_Y_NaMa$=y&1NIy

Hãy thử trực tuyến!

Giải trình

Mỗi nhân vật xảy ra hai lần.

                        a is first command-line argument
I1&MY$=_                No-ops to make the program non-discriminating
            Ma          Map this function to the characters of a:
         _Na             Count occurrences of each character in a
        Y               Yank the result into y
              $=y       Fold y on equals: truthy if all elements are equal
                 &      Logical and
                  1NIy  1 is not in y
                        Autoprint the result of the last expression

Phiên bản 22 byte thay thế có ít no-op hơn:

$&MY_Y_NaMa$=y&--1=1Ny

SmileBASIC, 164 152 148 140 byte

DeF M(X)DIM W[#R]WHILE""<X
INC w[ASC(x)]X[n]=""wEND
FOR F=e#TO--nOT-LEN(W)U=w[F]H=H||U&&U<MAx(W)neXT-!!!AASSS#&&Oxx||CCLL<<wIM#
RETURN!H
enD

35 nhân vật khác nhau, lặp lại 4 lần mỗi.

Không có bình luận nào được sử dụng (nhưng biểu thức sau neXTkhông bao giờ thực sự được đánh giá)

Kịch bản để kiểm tra câu trả lời:

//javascript is a convenient language that I love using!
var input=document.getElementById("input");
var button=document.getElementById("button");
var output=document.getElementById("output");

button.onclick=function(){
  var text=input.value;
  var freqs={};
  for(var i=0;i<text.length;i++){
    var letter=text.charAt(i);
    if (freqs[letter]==undefined) freqs[letter]=0
    freqs[letter]++
  }
  sorted=Object.keys(freqs).sort(function(a,b){return freqs[b]-freqs[a]})
  var out="";
  var min=Infinity,max=0;
  for (var i in sorted) {
    var letter=sorted[i];
    var count=freqs[letter];
    if(count<min)min=count;
    if(count>max)max=count;
    out+="\n"+letter+":"+count;
  }
  output.textContent="min:"+min+"\nmax:"+max+"\nunique:"+sorted.length+"\nlength:"+text.length+out;
}

<textarea id="input" placeholder="code here"></textarea>
<button id="button"butt>count</button>
<pre id="output">...</pre>

Võng mạc 0.8.2 , 168 90 byte

Đầu ra sẽ trống nếu sai hoặc không trống nếu đúng.

***???;;;;```!!$$$$MMMMOOOO..1111ssss222{{{{\^^^^

s;{O`.
M!*\`^((.)\2(?!\2))*$
(.)(?!\1)

Dùng thử trực tuyến

Chương trình lõi (39 byte)

s;{O`.
M!*\`^((.)\2(?!\2))*$
(.)(?!\1)

Giải trình

Toàn bộ chương trình cốt lõi là trong một vòng lặp im lặng. Giai đoạn đầu tiên sắp xếp đầu vào. Giai đoạn thứ hai sẽ in chuỗi hiện tại nếu nó bao gồm các cặp ký tự khác nhau liên tiếp. Giai đoạn thứ ba loại bỏ sự xuất hiện cuối cùng của mỗi ký tự (loại bỏ một trong mỗi ký tự trong chuỗi).

Về rác ở đầu: thứ tự là quan trọng. Ngoài việc cần phải có giá trị về mặt cú pháp, một dấu chấm phẩy phải nằm sau dấu hoa thị và trước các backticks, miễn *là trong chuỗi cấu hình, để nó không được in.

CoffeeScript 1 , 96 93 90 byte

(q,a=q.split(h).length-1for h in[q][0])->a.every (w,s,pplitnggffoorsvvyy)->w>1&&a[0&10]==w

Hãy thử trực tuyến!

Bắt đầu từ câu trả lời ES6 của tôi nhưng quay lại sử dụng Array.every. 32 31 30 mã thông báo @ 3 mỗi

Bình thường, 30 byte

  "&8<MQSlqr{"&q1lJ{hMrSz8<1hJ

Không gian hàng đầu cần thiết.

Hãy thử trực tuyến!

Chương trình thực tế chỉ là &q1lJ{hMrSz8<1hJ. Tôi chỉ chuẩn bị chuỗi "&8<MQSlqr{"để làm cho nó không phân biệt đối xử. Nhưng để làm cho chuỗi không tự in, tôi phải thêm một khoảng trắng, vì vậy tôi đã thêm 2 khoảng trắng.

&q1lJ{hMrSz8<1hJ

 q1l                (1 == len(
    J{                  J = deduplicate(
      hM                  map(lambda a: a[0],
        r  8                length_encode(
         Sz                   sorted(input())
                            )
                          )
                        )
                    )
&                     and
            <1hJ    (1 < J[0])

length_encodeở đây ( r <any> 8) lấy một chuỗi và xuất độ dài của mỗi lần chạy của cùng một ký tự, ví dụ. "aaabbcc"trở thành [[3, "a"], [2, "b"], [2, "c"]].

Vì vậy, cái này lấy đầu vào, sắp xếp nó để mã hóa độ dài và lấy phần tử đầu tiên của mỗi danh sách trong danh sách kết quả (ví dụ ví dụ trước đó sẽ trở thành [3, 2, 2]). Điều này cho biết số lần nhân vật xảy ra. Sau đó, nó được lặp lại (ví dụ trước đó sẽ trở thành [3, 2]) và J được đặt thành đó.

Sau đó, nó kiểm tra xem độ dài có phải là 1 hay không, tức là chỉ có 1 số lần duy nhất một ký tự xuất hiện và nếu đó là> 1, tức là> = 2.

Có thể có một tích hợp để thay thế rSz8hoặc hMrSz8nhưng tôi không thể tìm thấy.

C (gcc) , 153 byte

f(h,a,c,f){{{{{{{char*o=f=h,*r;for(a=!h;*o;o++){for(c=!h,r=h;*r;c+=!(*r++^*o)){}f*=!!(c^!!h)*(!a+!(a^c));a=c;}(a^c^c^f^f^h)+o,a+r,o,o,+h^*r;(a=f);}}}}}}}

Hãy thử trực tuyến!

Trả về địa chỉ của chuỗi là giá trị trung thực và bằng 0 là sai.

f(
h,                              Address of string.
a,                              # instances of previous character
c,                              # instances of current character
f                               Return value
){{{{{{{                        
char*o=f=h,*r;                  Point o to string, while giving f a non-zero value.
for(a=!h;*o;o++){               Set previous char count to 0, and then traverse the string.
for(c=!h,r=h;*r;                Set current char count to 0 and r to string,
                                and start counting instances of current character.
c+=!(*r++^*o))                  Add to counter if current character matches.
{}                              Lower the amount of semi-colons
f*=                             Multiply (AND) return value with:
   !!(c^!!h)                    Is current count not 1? (Must be 2 or above.)
            *(!a+!(a^c));       AND, is previous count valid (meaning this is not the first
                                character counted), and matches current count?
a=c;}                           Previous count = current count.
(a^c^c^f^f^h)+o,a+r,o,o,+h^*r;  Spend surplus characters to make source code valid.
(a=f);}}}}}}}                   Return value.

Perl 6 , 58 57 byte

{.max==.min>()**()}o{(bag .comb){*}}###=>>abccggiinnoxx  

Hãy thử trực tuyến!

Hóa ra phiên bản ba nhân vật ngắn hơn một chút so với hai nhân vật một.