Cho một danh sách hữu hạn khác rỗng của số nguyên, sản lượng một truthy giá trị nếu có chính xác hai mục bình đẳng và tất cả các mục khác là khác biệt, và một falsey giá trị khác.

Ví dụ

truthy:
[1,1]
[1,2,1]
[1,6,3,4,4,7,9]

falsey:
[0]
[1,1,1]
[1,1,1,2]
[1,1,2,2]
[2,1,2,1,2]
[1,2,3,4,5]

Python 3, 30 28 byte

lambda m:len({*m})+1==len(m)

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

{*m}đưa danh sách vào một setđối tượng, một danh sách các mục không có thứ tự mà không trùng lặp. Làm điều này sẽ luôn giảm độ dài của danh sách theo số lượng trùng lặp trong đó. Bằng cách tính toán độ dài đã thay đổi, chúng ta có thể dễ dàng biết được danh sách có trùng lặp hay không và trả về kết quả của bài kiểm tra.

^{-2 byte nhờ vào các lò nướng.}

Husk , 4 byte

εṠ-u

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

Giải trình

εṠ-u  Implicit input.
   u  Unique elements.
 Ṡ-   Delete them from input, counting multiplicities.
ε     Is the result a singleton list?

MATL , 7 , 6 byte

&=sp4=

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

Một byte được lưu nhờ vào @Guiseppe!

Giải trình:

&=  % Table of pair-wise equality comparisons
    %
    % [1 0 0 0 0 0 0
    %  0 1 0 0 0 0 0
    %  0 0 1 0 0 0 0
    %  0 0 0 1 1 0 0
    %  0 0 0 1 1 0 0
    %  0 0 0 0 0 1 0
    %  0 0 0 0 0 0 1]
    %
s   % Sum each Column. Stack:
    %
    % [1 1 1 2 2 1 1]
    %
p   % Product of the array. Stack:
    %
    % [4]
    %
4=  % Compare the stack to '4'

Haskell , 34 byte

f x=[1|a<-x,b<-x,a==b]==1:1:(1<$x)

Hãy thử trực tuyến! Dựa trên câu trả lời của H.PWiz .

Thạch , 8 5 byte

QL‘=L

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

Giải trình

QL‘=L  - Main link, argument L (a list)   e.g [1,6,3,4,4,7,9]
Q      - Deduplicated elements                [1,6,3,4,7,9]
 L     - Length                               6
  ‘    - Increment                            7
    L  - Length of the input                  7 ([1,6,3,4,4,7,9])
   =   - Are they equal?                      1

Nếu các giá trị đầu ra có thể là bất kỳ giá trị nhất quán nào, thì nó QL_Lhoạt động, đầu ra -1cho sự thật và bất kỳ số không tích cực nào khác cho falsey (cảm ơn @JonathanAllan)

JavaScript (ES6), 30 byte

a=>new Set(a).size==a.length-1

Dùng thử trực tuyến

Pushy , 8 byte

Thực hiện đơn giản kiểm tra xem len(set(list)) == len(list)-1:

LtvuL^=#

Giải trình:

       \ Implicit: Put all input on stack
Ltv    \ Get the stack length - 1, save in auxiliary stack
u      \ Remove non-unique elements
L      \ Get the new length
^=     \ Compare with the previously saved length
#      \ Print result

Điều này hoạt động vì độ dài sẽ chỉ giảm 1 nếu chỉ có chính xác 1 số nguyên không phân biệt trong danh sách ban đầu.

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

Octave , 25 byte

Đây không phải là sử dụng một grouphoặc uniquetiếp cận như nhiều câu trả lời khác, mà là "sản phẩm cartesian" của tất cả các so sánh có thể.

@(x)nnz(triu(x==x',1))==1

Giải trình

             x==x'        %create a matrix where the entry at (i,j) compares whether x(i) == x(ju)
        triu(x==x',1)     %only consider the strict upper triangular matrix
    nnz(triu(x==x',1))    %count the number of nonzero entries
@(x)nnz(triu(x==x',1))==1 %check whether this number is actually 1

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

Và bởi vì sẽ không có chương trình nào hoàn thành nếu không có tích chập (cảm ơn @LuisMendo vì đã sửa lỗi):

Octave , 40 byte

@(x)nnz(~conv(sort(x),-1:2:1,'same'))==1

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

J , 7 6 byte

=&#0,=

=kiểm tra mọi phần tử cho sự bằng nhau với mọi phần tử duy nhất, tạo một ma trận với m hàng cho  m  phần tử duy nhất.
0,thêm một hàng trống trên đầu trang
=&#số lượng hàng bằng chiều dài của đầu vào?

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

Võng mạc , 15 12 11 byte

Cảm ơn Neil vì đã tiết kiệm 1 byte.

D`
Mm2`^$
1

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

Đầu vào được phân tách theo dòng. (Bộ kiểm tra sử dụng phân tách dấu phẩy để thuận tiện.)

Giải trình

D`

Không lặp lại các dòng trong đầu vào, loại bỏ bất kỳ số nguyên nào đã xuất hiện trước đó (nhưng để lại các nguồn cấp dữ liệu xung quanh).

Mm2`^$

Đếm số lượng dòng trống, bằng với số lượng trùng lặp chúng tôi đã xóa, nhưng chỉ xem xét hai trận đấu đầu tiên. Vì vậy, đầu ra sẽ chỉ là 0(không trùng lặp), 1(một bản sao), 2(hai hoặc nhiều bản sao).

1

Hãy chắc chắn rằng chính xác một bản sao đã được gỡ bỏ.

05AB1E , 4 byte

{¥_O

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

Đầu ra 1là trung thực, bất kỳ số nguyên không âm nào khác là giả. Trong 05AB1E, 1là con số trung thực duy nhất (cảm ơn @Emigna vì cái nhìn sâu sắc!).

Giải trình

{       Implicit input. Sort
 ¥      Consecutive differences
  _     Boolean negate
   O    Sum. Implicit display

Ruby, 32 byte

->(s){s.uniq.length==s.length-1}

C # (.NET Core) , 35 + 18 byte

+18 để sử dụng System.Linq.

n=>n.Distinct().Count()==n.Length-1

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

Thay thế 67 byte mà không có Linq:

n=>new System.Collections.Generic.HashSet<int>(n).Count==n.Length-1

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

Excel, 42 byte

Phiên bản tiếng Đan Mạch

=TÆLV(A:A)=SUM(--(FREKVENS(A:A,A:A)>0))+1

Giả sử mỗi số nguyên từ danh sách trong ô riêng biệt trong cột A.
Nếu chúng tôi được phép cho các giá trị falsey không nhất quán , chúng tôi có thể lưu 3 byte:

=TÆLV(A:A)+SUM(-(FREKVENS(A:A,A:A)>0))

Phiên bản tiếng Anh (44 byte)

=COUNTA(A:A)=SUM(--(FREQUENCY(A:A,A:A)>0))+1

R , 32 31 byte

-1 byte nhờ @JarkoDubbeldam

cat(sum(duplicated(scan()))==1)

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

Đọc từ stdin, viết đến stdout.

duplicatedlặp qua danh sách, thay thế các giá trị lbằng TRUEnếu giá trị đó xảy ra sớm hơn trong danh sách và FALSEnếu không. Nếu có một cặp bạn tâm hồn duy nhất, cần có chính xác một TRUEgiá trị, vì vậy tổng số phải là 1.

PowerShell , 40 37 byte

($args|sort -u).count-eq$args.count-1

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

Các Sort-Objectlệnh (bí danh sort) với -ucờ nique kéo ra chỉ những thành phần độc đáo của các đầu vào. Ví dụ, đối với đầu vào @(1,3,3,2), điều này sẽ dẫn đến @(1,2,3).

Vì vậy, chúng ta chỉ cần đảm bảo rằng .countđối tượng này (nghĩa là có bao nhiêu phần tử) có liên quan -eqđến .countmảng đầu vào của chúng ta -1(nghĩa là chúng ta có chính xác một mục nhập trùng lặp).

Đã lưu 3 byte nhờ Sinusoid.
Đã sửa lỗi nhờ TessellatingHeckler.

Perl 5 , 36 + 1 ( -a) = 37 byte

map$k{$_}++,@F;@a=keys%k;say@a+1==@F

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

Haskell , 37 byte

f x=sum[1|a<-x,b<-x,a==b]==2+length x

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

Octave / MATLAB (với gói / hộp công cụ Thống kê), 21 byte

@(x)nnz(~pdist(x))==1

Chức năng ẩn danh. Đầu vào là một vectơ cột. Đầu ra là true(hiển thị dưới dạng 1) hoặc false(hiển thị dưới dạng 0).

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

Giải trình

pdist(x)tính toán một vectơ khoảng cách Euclide giữa tất cả các cặp hàng từ x. Nó chỉ xem xét mỗi cặp một lần (thứ tự của hai hàng không quan trọng) và không xem xét các cặp được tạo bởi cùng một hàng hai lần.

Trong trường hợp của chúng tôi xlà một vectơ cột, vì vậy khoảng cách Euclide giữa hai hàng chỉ là sự khác biệt tuyệt đối giữa hai số.

~là phủ định logic (Boolean), nnzlà số lượng khác không và ==1so sánh với 1. Vì vậy, kết quả là truenếu và chỉ khi chỉ có một cặp cho khoảng cách bằng không.

Jq 1.5 , 53 25 byte

length-(unique|length)==1

Lấy cảm hứng từ câu trả lời của Riley và ngắn hơn nhiều so với giải pháp ban đầu của tôi.

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

Julia, 39 26 byte

!a=sum(a.==a')==endof(a)+2

Giải trình

Mã này tạo ra một bảng booleans 2 chiều, sau đó được thu thập bằng hàm sum, đếm số cặp phần tử giống nhau trong bình phương cartesian của A. Sau đó, giá trị này được so sánh với độ dài của chuỗi cộng với hai và số lượng chỉ bằng nhau khi có chính xác một ký tự lặp lại.

Mã này xác định lại toán tử KHÔNG.

Bình thường , 6 byte

qtlQl{

Xác nhận tất cả các trường hợp thử nghiệm.

• l{ - Được số lượng các yếu tố độc đáo.

• tlQ - Lấy chiều dài của danh sách đầu vào, giảm dần.

• q - Kiểm tra sự bình đẳng.

7 byte

q1l.-Q{

Xác nhận tất cả các trường hợp thử nghiệm

Octave , 23 26 byte

@(x)prod(sum(x==x'))==4

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

Phần x==x'được lấy cảm hứng từ câu trả lời của flawr . Câu này dài hơn câu trả lời của Luis, nhưng nó không sử dụng bất kỳ hộp công cụ nào.

Giải trình:

Đây là một hàm ẩn danh lấy một vectơ xlàm đầu vào và so sánh nó với chính nó được hoán vị. Điều này sẽ đưa ra một ma trận trong đó tất cả các phần tử đường chéo 1và bất kỳ phần tử đường chéo nào báo hiệu rằng có các phần tử trùng lặp.

Tổng dọc theo bất kỳ cột đã cho nào có bao nhiêu số trùng lặp của số đó. Chúng tôi muốn hai trong số các số có một bản sao, vì vậy chúng tôi có hai giá trị bằng hai và phần còn lại không bằng hai.

Nếu chúng ta lấy sản phẩm của ma trận này, chúng ta sẽ nhận được 4nếu chỉ có hai phần tử bằng nhau ( 2*2*1*1*1*1*...) và một cái gì đó khác hơn là 4nếu không có bản sao hoặc nhiều hơn hai.

PHP, 46 byte

<?=count(array_unique($argv))==count($argv)-1;

Đếm số lượng mục nhập $argvvà so sánh nó với số lượng mục duy nhất. Nếu cái trước cao hơn cái sau 1 thì thật, khác falsey.

Hãy thử nó trên eval.in!

05AB1E , 6 5 byte

{¥>ΘO

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

{¥>ΘO   # example input:               [1, 6, 3, 4, 4, 7, 9]
{       # sort                      -> [1, 3, 4, 4, 6, 7, 9]
 ¥      # get deltas                -> [  2, 1, 0, 2, 1, 2 ]
  >     # increment                 -> [  3, 2, 1, 3, 2, 3 ]
   Θ    # truthify (only 1 gives 1) -> [  0, 0, 1, 0, 0, 0 ]
    O   # sum                       -> 1

1là giá trị trung thực duy nhất trong 05AB1E, chúng ta có thể dừng ở đây. (Cảm ơn @Emigna đã chỉ ra điều đó.)

Để chỉ nhận hai giá trị riêng biệt, chúng tôi có thể tùy chọn thêm:

     Θ  # equals 1?                 -> 1

APL (Dyalog Unicode) , 7 byte ^SBCS

1=≢-≢∘∪

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

Giải trình:

1=≢-≢∘∪  ⍝ Monadic function train
    ≢∘∪  ⍝ Generate a list of unique items in the input,
         ⍝ and return the length of that list
  ≢-     ⍝ Take the length of the input and subtract the above
1=       ⍝ If the difference is 1, true, otherwise false

Thạch , 10 byte

ċ@€`QṢ⁼1,2

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

một cách tiếp cận dài hơn nhưng khác

Japt, 7 byte

â ʶUÊÉ

Thử nó

Giải trình

Loại bỏ trùng lặp ( â), lấy độ dài ( Ê) và so sánh đẳng thức ( ¶) với độ dài ( Ê) của đầu vào ( U) trừ đi 1 ( É).

Haskell , 37 byte

f x=sum[1|0<-(-)<$>x<*>x]==2+length x

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

05AB1E , 5 byte

gIÙg-

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

g     # Get number of elements in input
 IÙg  # Get number of unique elements in input
    - # Subtract

Trong 05AB1E 1 là giá trị trung thực duy nhất, vì vậy, để có kết quả trung thực, phải có chính xác 1 phần tử trùng lặp được xóa bởi uniquify.