Thử thách

Một repdigit là một số nguyên không âm có các chữ số đều bằng nhau.

Tạo một hàm hoặc chương trình hoàn chỉnh lấy một số nguyên duy nhất làm đầu vào và xuất giá trị trung thực nếu số đầu vào là một chữ số trong cơ sở 10 và giá trị sai lệch khác.

Đầu vào là đảm bảo được một dương tính số nguyên.

Bạn có thể lấy và sử dụng đầu vào làm đại diện chuỗi trong cơ sở 10 với sự không trừng phạt.

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

Đây là tất cả các chữ số dưới 1000.

1
2
3
4
5
6
7
8
9
11
22
33
44
55
66
77
88
99
111
222
333
444
555
666
777
888
999

Một danh sách lớn hơn có thể được tìm thấy trên OEIS .

Chiến thắng

Mã ngắn nhất tính bằng byte thắng. Điều đó không có nghĩa là câu trả lời thông minh trong các ngôn ngữ dài dòng sẽ không được hoan nghênh.

Brachylog , 1 byte

=

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

Điều này tác động lên số nguyên.

Từ src/predicates.pl#L1151:

brachylog_equal('integer':0, 'integer':0, 'integer':0).
brachylog_equal('integer':0, 'integer':I, 'integer':I) :-
    H #\= 0,
    integer_value('integer':_:[H|T], I),
    brachylog_equal('integer':0, [H|T], [H|T]).

C (gcc) , 33 30 29 byte

f(n){n=n%100%11?9/n:f(n/10);}

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

COBOL , 139 BYTES

Tôi cảm thấy như COBOL không có bất kỳ tình yêu nào trong việc chơi golf mã (có lẽ bởi vì không có cách nào nó có thể giành chiến thắng) nhưng ở đây:

IF A = ALL '1' OR ALL '2' OR ALL '3' OR ALL '4' OR ALL '5' OR
ALL '6' OR ALL '7' OR ALL '8' OR ALL '9' DISPLAY "TRUE" ELSE   
DISPLAY "FALSE".

A được định nghĩa là PIC 9 (4).

05AB1E , 1 byte

Ë

Kiểm tra nếu tất cả các chữ số bằng nhau

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

Python 3, 25, 24 19 byte.

len({*input()})>1>t

Một stdin => biến thể mã lỗi.

Trả về mã lỗi 0 nếu đó là một số kỹ thuật số - hoặc lỗi do lỗi.

Cảm ơn Dennis đã giúp tôi trong các ý kiến.

Toán học, 27 byte

AtomQ@Log10[9#/#~Mod~10+1]&

Nó không đánh bại Equal@@IntegerDigits@#&, nhưng nó đánh bại giải pháp Mathicala dựa trên số học khác.

Các chữ số có dạng n = d (10 ^m -1) / 9 trong đó m là số chữ số và d là chữ số lặp lại. Chúng ta có thể khôi phục d từ n bằng cách lấy modulo 10 (vì nếu là chữ số rep, chữ số cuối cùng sẽ là d ). Vì vậy, chúng ta có thể sắp xếp lại thứ này dưới dạng m = log ₁₀ (9 n / (n% 10) + 1) và kiểm tra xem m có phải là số nguyên hay không.

Haskell , 15 byte

all=<<(==).head

Hãy thử trực tuyến! Đưa đầu vào chuỗi.

Tương đương với \s->all(==head s)s. Thu hẹp các lựa chọn thay thế:

f s=all(==s!!0)s
f s=s==(s!!0<$s)
f(h:t)=all(==h)t
f(h:t)=(h<$t)==t
f s=(s<*s)==(s*>s)
f(h:t)=h:t==t++[h]

C (gcc), 41 byte

f(char*s){s=!s[strspn(s,s+strlen(s)-1)];}

Đây là một hàm lấy đầu vào dưới dạng một chuỗi và trả về 1nếu nó là một chữ số và 0ngược lại.

Nó thực hiện điều này bằng cách sử dụng strspnhàm, lấy hai chuỗi và trả về độ dài của tiền tố dài nhất của chuỗi thứ nhất chỉ bao gồm các ký tự từ chuỗi thứ hai. Ở đây, chuỗi đầu tiên là đầu vào và chuỗi thứ hai là chữ số cuối cùng của đầu vào, thu được bằng cách chuyển một con trỏ đến ký tự cuối cùng của chuỗi đầu vào.

Nếu đầu vào là một chữ số, thì kết quả của cuộc gọi strspnsẽ là strlen(s). Sau đó, lập chỉ mục vào ssẽ trả về một byte null nếu đây là trường hợp ( str[strlen(str)]luôn luôn \0) hoặc chữ số đầu tiên không khớp với chữ số cuối cùng. Phủ định điều này với !kết quả trong việc sđại diện cho một chữ số.

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

Cảm ơn @Dennis đã gián tiếp nhắc nhở tôi về thủ thuật chuyển nhượng thay vì trả lại thông qua câu trả lời cực kỳ ấn tượng của anh ấy , tiết kiệm 4 byte!

PHP, 25 28 25

<?=!chop($argn,$argn[0]);

xóa tất cả các ký tự từ bên phải bằng với 1ký tự đầu tiên và in nếu tất cả các ký tự đã bị xóa.

R, 31 byte

function(x)grepl("^(.)\\1*$",x)

Hàm này hoạt động với đầu vào chuỗi và sử dụng biểu thức chính quy để xác định xem đầu vào có phải là chữ số không.

Thí dụ

> f <- function(x)grepl("^(.)\\1*$",x)
> x <- c("1", "2", "11", "12", "100", "121", "333")
> f(x)
[1]  TRUE  TRUE  TRUE FALSE FALSE FALSE  TRUE

/// , 110 byte

/11/1//22/2//33/3//44/4//55/5//66/6//77/7//88/8//99/9//1/.//2/.//3/.//4/.//5/.//6/.//7/.//8/.//9/.//T..///.//T

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

Ngôn ngữ /// không có bất kỳ khái niệm nào về sự thật và chim ưng, do đó, ngôn ngữ này xuất ra chữ "T" nếu đầu vào là một chữ số và không xuất bất kỳ ký tự nào nếu đầu vào không phải là chữ số.

Thạch , 2 1 byte

E

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

Octave , 11 byte

@(s)s==s(1)

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

Lấy đầu vào là một chuỗi.

Nó kiểm tra tất cả các ký tự cho sự bình đẳng với các ký tự đầu tiên. Nếu tất cả đều bằng nhau, kết quả sẽ là một vectơ chỉ 1(đúng trong Octave), nếu không sẽ có ít nhất một 0(sai trong Octave). Đây là một bằng chứng .

grep, 17 byte

grep -xP '(.)\1*'

Khớp với bất kỳ chuỗi nào là sự lặp lại của ký tự đầu tiên của nó.

C #, 42 33 28 byte

i=>i.Replace(i[0]+"","")==""

i phải là một chuỗi.

Cạo râu rất nhiều nhờ @LethalCoder

Braingolf , 6 byte

iul1-n

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

Thật không may, đầu vào ẩn của Braingolf từ dòng lệnh không thể chấp nhận đầu vào tất cả các chữ số dưới dạng một chuỗi, nó sẽ luôn chuyển nó thành một số, vì vậy thay vào đó, giải pháp là chuyển nó qua STDIN, thêm 1 byte để đọc STDIN ( i)

Giải trình:

iul1-n
i       Read from STDIN as string, push each codepoint to stack
 u      Remove duplicates from stack
  l     Push length of stack
   1-   Subtract 1
     n  Boolean negate, replace each item on stack with 1 if it is a python falsey value
        replace each item on stack with 0 if it is a python truthy value
        Implicit output of last item on stack

Sau đó u, độ dài của ngăn xếp bằng số lượng ký tự duy nhất trong đầu vào, trừ đi 1 có nghĩa là nó sẽ là 0nếu và chỉ khi có chính xác 1 ký tự duy nhất trong đầu vào, 0là số falsey duy nhất trong Python, do đó nsẽ thay thế 0bằng 1, và mọi thứ khác với 0.

Japt , 4 byte

¥çUg

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

JavaScript (ES6), 23 21 byte

Đã lưu 2 byte nhờ Neil

Lấy đầu vào là số nguyên hoặc chuỗi. Trả về một boolean.

n=>/^(.)\1*$/.test(n)

Bản giới thiệu

let f =

n=>/^(.)\1*$/.test(n)

console.log(f(444))
console.log(f(12))

Ồ , 4 byte

Ul2<

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

Giải trình

 Ul2<
 U    # Push uniquified input
  l   # Length
   2< # Is it smaller than 2?

APL, 5 byte

Lưu 2 byte nhờ @KritixiLithos

⍕≡1⌽⍕

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

Java, 21 byte:

l->l.toSet().size()<2

llà một MutableList<Character>từ bộ sưu tập nhật thực.

Kotlin , 28 19 byte

{it.toSet().size<2}

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

Lấy đầu vào là Stringvì

Bạn có thể lấy và sử dụng đầu vào làm đại diện chuỗi trong cơ sở 10 với sự không trừng phạt.

Giải trình

{
    it.toSet()     // create a Set (collection with only unique entries)
                   // out of the characters of this string
        .size < 2  // not a repdigit if the set only has one entry
}

Nếu bạn không thích một thực tế phải mất một String, bạn có thể có một mà phải mất một Intcho 24 byte .

{(""+it).toSet().size<2}

Regex (ECMAScript), 31 byte

^(x{0,9})((x+)\3{8}(?=\3$)\1)*$

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

Đưa đầu vào vào unary, như thường lệ cho các biểu thức toán học (lưu ý rằng vấn đề là không đáng kể với đầu vào thập phân: chỉ ^(.)\1*$).

Giải trình:

^(x{0,9})           # \1 = candidate digit, N -= \1
(                   # Loop the following:
  (x+)\3{8}(?=\3$)  # N /= 10 (fails and backtracks if N isn’t a multiple of 10)
  \1                # N -= \1
)* $                # End loop, assert N = 0

PHP, 30 byte

<?=($a=$argn).$a[0]==$a[0].$a;

Neim , 1 byte

𝐐

Đơn giản chỉ cần kiểm tra rằng tất cả các yếu tố là bằng nhau.

Không có nội dung, 2 byte:

𝐮𝐥

Giải trình:

𝐮     Calculate unique digits
 𝐥    Get the length

Điều này hoạt động vì chỉ 1được coi là sự thật trong Neim, và mọi thứ khác là giả.

Ngoài ra, cho 4 byte:

𝐮𝐣μ𝕃

Giải trình:

𝐮      Calculate unique digits
 𝐣      Join list into an integer
   𝕃   Check that is is less than
  μ    Ten.

Thử nó!

C, 38 byte

f(char*s){return*s^s[1]?!s[1]:f(s+1);}

Đệ quy đi bộ một chuỗi. Nếu hai ký tự đầu tiên khác nhau ( *s^s[1]) thì chúng tôi chỉ thành công nếu chúng tôi ở cuối chuỗi ( !s[1]) nếu không, chúng tôi lặp lại thử nghiệm ở vị trí tiếp theo ( f(s+1)).

Chương trình kiểm tra

#include <stdio.h>
int main(int argc, char **argv)
{
    while (*++argv)
        printf("%s: %s\n", *argv, f(*argv)?"yes":"no");
}

Java, 38 33 23 byte

n->n.matches("(.)\\1*")

nlà một String, tự nhiên.

Lưu ý rằng không cần ^...$trong regex vì nó tự động được sử dụng để khớp chính xác (chẳng hạn như matchphương thức), so với tìm trong chuỗi.

Thử nó!

Tiết kiệm

• -5 byte: được sử dụng Stringvì "Bạn có thể lấy và sử dụng đầu vào dưới dạng một chuỗi không bị trừng phạt."
• -10 byte: regex rõ ràng là phù hợp.

R, 25 byte

grepl("^(.)\\1*$",scan())

Dùng thử trực tuyến

Giải pháp phi regex tốt nhất tôi có thể đưa ra là 36 byte:

is.na(unique(el(strsplit(x,"")))[2])

Khối , 15 byte

uOn@ii?-?;.$@<_

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

    u O
    n @
i i ? - ? ; . $
@ < _ . . . . .
    . .
    . .

Xem nó chạy

Kết quả 1 cho sự thật và không có gì cho falsey

Rất đơn giản chỉ đọc đọc trong một ký tự đầu vào tại một thời điểm. Nó đưa nhân vật hiện tại đi từ trước đó. Nếu một kết quả khác không thì nó dừng lại ngay lập tức. Nếu không, nó tiếp tục nhập và so sánh cho đến khi EOI. Trên EOI (-1), phủ nhận và thoát

QBasic 4.5, 55 byte

INPUT a
FOR x=1TO LEN(STR$(a))
c=c*10+1
NEXT
?a MOD c=0

Tôi đã học nó! Vòng lặp FOR kiểm tra số chữ số trong đầu vào, sau đó tạo c, một chuỗi có độ dài 1 'bằng với đầu vào. Một số sau đó là kỹ thuật số nếu nó điều chỉnh một chuỗi == 0.

Hãy thử trực tuyến! Lưu ý rằng trình thông dịch trực tuyến hơi kỳ quặc và tôi đã phải viết ra một vài tuyên bố rằng IDE QBasic dựa trên DOS sẽ tự động mở rộng.