Bạn sẽ được cung cấp một chuỗi. Nó sẽ chứa 9 số nguyên duy nhất từ ​​0-9. Bạn phải trả về số nguyên còn thiếu. Chuỗi sẽ trông như thế này:

123456789
 > 0

134567890
 > 2

867953120
 > 4

Python 2 , 18 16 byte

^{+ làm đẹp nhờ @Sarge Borsch}

`99066**2`.strip

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

99066**2 chỉ là một cách ngắn hơn để tạo một chuỗi chứa 0 ~ 9

Python , 22 byte

lambda s:-int(s,16)%15

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

Một giải pháp số học. Giải thích chuỗi đầu vào là hex, phủ định nó và lấy modulo kết quả 15.

APL (Dyalog) , 4 byte

Hàm xuất phát

⎕D∘~

⎕D D igits

∘ (liên kết một đối số bên trái với hàm dyadic sau để tạo một hàm đơn âm)

~ ngoại trừ [đối số]

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

Tàu chức năng

⎕D~⊢

⎕D D igits

~ ngoại trừ

⊢ lập luận đúng

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

Chương trình rõ ràng

⎕D~⍞

⎕D D igits

~ ngoại trừ

⍞ nhập ký tự

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

Brain-Flak , 48 38 36 + 3 = 39 byte

10 byte được lưu nhờ DJMcMayhem!

((([]())[]{}){()()({}[()])}{}[{{}}])

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

Giải trình

Tổng của tất cả các chữ số trong Ascii là 525. Chương trình này tổng hợp đầu vào và trừ nó từ 525 để lấy chữ số còn thiếu.

((([]())[]{}){()()({}[()])}{}      )

Sẽ đẩy 525. Điều này lợi dụng thực tế là chúng ta biết sẽ có 9 yếu tố đầu vào để bắt đầu. Điều này có nghĩa rằng[] đến 9 cho phép chúng tôi nhanh chóng đạt được số lượng lớn như 525.

Tiếp theo chúng ta có bit:

                             [{{}}]

sẽ tổng hợp các đầu vào và trừ nó khỏi tổng số.

Haskell , 24 23 byte

(477-).sum.map fromEnum

Hãy thử trực tuyến! Cách sử dụng : (477-).sum.map fromEnum $ "123456890". 477 là tổng mã ký tự của các chữ số từ 1 đến 9, ngoại trừ 0. Hàm ẩn danh này tính 477 trừ tổng của tất cả các mã ký tự chữ số để tìm số còn thiếu.

Biến các chữ số char thành ints dài hơn một byte:

(45-).sum.map(read.pure)
foldl(\a b->a-read[b])45

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

Thạch , 3 byte

ØDḟ

Đơn giản chỉ cần lọc ( ḟ) chuỗi đầu vào từ Số 0123456789 Lần ( ØD).

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

Hồng ngọc, 14

Tính tổng mã ascii và trừ từ 48 * 9 + 45

->s{477-s.sum}

Sử dụng như thế này

f=->s{477-s.sum}

puts f["123456789"]

JavaScript (ES6), 26

Chỉnh sửa 1 byte lưu thx @Neil, với thủ thuật thông minh hơn nhiều

Xored tất cả các giá trị từ 1 đến 9 cho 1. Xor 1 thêm một lần nữa và kết quả là 0. Vì vậy, nếu bất kỳ giá trị đơn lẻ nào bị thiếu, kết quả sẽ là giá trị bị thiếu.

s=>eval([1,...s].join`^`)

Kiểm tra

f=s=>eval([1,...s].join`^`)

function go() {

  var i=I.value;
  O.textContent = f(i)
}  

go()

<input oninput='go()' value='012987653' id=I>
<pre id=O></pre>

Retina , 27 21 19 byte

-6 Cảm ơn Hoàng hôn cơ bản
-2 Cảm ơn Martin Ender

.
$*_5$*
+`_1|1_

1

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

Thay thế mọi chữ số bằng nhiều _s và 5 1s:

.
$*_5$*

Xóa tất cả các _s và a 1cho mỗi:

+`_1|1_ 

Đếm số 1s còn lại:

1

05AB1E , 6 byte

45¹SO-

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

45     # Push 45
  ¹    # push input
   S   # Split
    O  # Sum
     - # Subtract (45 - sum)

JavaScript (ES6), 31 29 28 22 byte

s=>(15-`0x${s}`%15)%15

Câu trả lời Python của cổng @ xnor, ngoại trừ JavaScript chỉ có toán tử còn lại chứ không phải toán tử modulo, vì vậy tôi không thể thực hiện trong một bước. Chỉnh sửa: Đã lưu 6 byte nhờ @Arnauld.

Brainfuck, 17 15 byte

-[-[->-<],]>++.

Hãy thử nó ở đây . Giải pháp này chỉ hoạt động trên Brainfuck tiêu chuẩn (các ô 8 bit), vì nó phụ thuộc vào việc bọc.

Đó là một ngày hiếm hoi khi Brainfuck thực sự có thể cạnh tranh, nhưng thử thách này chỉ xảy ra để phù hợp với thông số BF khá tốt!

Thay vì thẳng thắn phá vỡ câu trả lời này, tôi muốn bước qua các lần lặp mà tôi đã thực hiện, bởi vì tôi nghĩ nó sẽ dễ hiểu hơn (và thú vị hơn).
Lưu ý: giải pháp này được lấy cảm hứng chủ yếu từ câu trả lời Brain-Flak của Wheat Wizard .

Giải trình

Bước 1, 26 byte

Trong câu trả lời của mình, Wheat Wizard đã chỉ ra rằng tổng các giá trị ASCII từ 0-9 tổng đến 525. Và vì Brainfuck tiêu chuẩn chỉ có một khái niệm là [0,255], điều này làm cho giá trị 525% 256 = 13 . Điều đó có nghĩa là, trừ đi các giá trị ASCII của đầu vào từ 13 lưới cho bạn chữ số còn thiếu.

Phiên bản đầu tiên của chương trình này là:
1. Đặt 13 vào ô đầu tiên
2. Đưa đầu vào vào ô thứ hai
3. Trừ ô thứ hai khỏi ô thứ nhất
4. Nhảy lên 2 nếu còn lại đầu vào
5. In ô đầu tiên

Và đây là mã cho giải pháp đơn giản:

+++++++++++++ #Set the first cell to 13  
>,            #Take inputs into the second cell  
[[<->-],]     #Subtract the second cell from the first cell and repeat until inputs are over  
<.            #Print the first cell  

Bước 2, 19 byte

Như đã chỉ ra trong câu trả lời của anh ấy, vì chúng tôi biết đầu vào sẽ có độ dài chính xác 9, chúng tôi có thể sử dụng giá trị đó như một hằng số và loại bỏ chuỗi dài của + ngay từ đầu.
Nó cũng không thành vấn đề tại thời điểm chúng tôi thêm 13 (cảm ơn, thuộc tính giao hoán!), Vì vậy chúng tôi sẽ kết hợp nó với các bước trừ và in.

,        #Take input to enter the loop
[[->-<], #Subtract the first cell from the second cell 
>+<]     #Add 1 for each input; totaling 9
>++++    #Add the missing 4 to make 13
.        #And print

Đây là câu trả lời ban đầu của tôi cho vấn đề này, nhưng chúng ta có thể làm tốt hơn.

Bước 3, 17 byte

Thật thú vị, câu trả lời trước hoạt động ngay cả khi chúng ta bắt đầu bằng dấu + thay vì a,

+[[->-<],>+<]>++++.

Brainfuck yêu cầu một cái gì đó trong một tế bào để bắt đầu một vòng lặp. Chúng tôi ngây thơ nói thêm rằng cuối cùng có thêm 4, khi nó có thể đã đi ở những nơi khác.

-[[->-<],>+<]>++.

Với một số thủ thuật lặp hoàn toàn có chủ ý (đọc: dùng thử và lỗi), bắt đầu chương trình với một - dẫn đến hai kết quả thú vị:

1. Một được thêm vào ô thứ hai (lưu 1 byte ở cuối).
2. Các vòng lặp chạy thêm một lần nữa, tổng cộng 10 thay vì 9 (tiết kiệm thêm 1 byte).

1 + 10 + 2 = 13, và chúng tôi kết thúc với câu trả lời ban đầu.

Nhìn lại nó, đây có lẽ là một bài viết quá mức cho một chương trình Brainfuck đơn giản như vậy.

Bước 4, 15 byte

Sau khi suy nghĩ về giải pháp này thêm một chút, tôi đã có thể cắt bỏ 2 byte.

Tôi muốn làm rõ điều gì đó về bước trước:
Các trừ để nhập vòng lặp có hiệu quả bổ sung thêm 1, nhưng những gì nó thực sự làm được trừ 255 từ tế bào thứ hai (kết quả là 1).

Rõ ràng khi nhìn lại, nhưng trừ 1 từ ô thứ nhất cũng giống như thêm 1 vào ô thứ hai (vì mọi thứ trong ô thứ nhất sẽ bị trừ khỏi ô thứ hai.)

-[-[->-<],]>++.

Tôi đã có thể xóa "> + <" bằng cách thêm "-" vào đầu vòng lặp đầu tiên. Nó phải đến đó, và không phải là nơi "> + <", bởi vì chương trình sẽ lặp lại vô hạn.

Octave , 22 byte

@(x)setdiff('0':'9',x)

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

Toán học, 25 byte

477-Tr@ToCharacterCode@#&

Hàm thuần túy lấy một chuỗi làm đầu vào và trả về một số nguyên. Mathematica có tên lệnh dài và miễn cưỡng chuyển đổi giữa các chuỗi và số nguyên, điều này làm cho nó đặc biệt tệ ở thử thách này. Điều tốt nhất tôi có thể tìm thấy là thuật toán từ câu trả lời Ruby của Level River St , tính toán dựa trên tổng số mã ASCII của chuỗi đầu vào; trong Mathematica, điều này chỉ sử dụng một tên lệnh dài.

PHP, 27

<?=trim(32043**2,$argv[1]);

sử dụng mẹo từ câu trả lời của Rod để tạo ra một chuỗi chứa tất cả các chữ số sau đó loại bỏ tất cả các chữ số ngoại trừ chuỗi bị thiếu.

PHP, 41

for($b=1;$i<9;$b^=$argv[1][$i++]);echo$b;

Cái này sử dụng xor vì tôi chưa thấy nó.

Bash + coreutils, 19 byte

Tôi tìm thấy một giải pháp bash ngắn hơn , sử dụng phương pháp kiểm tra thú vị:

sum -s|dc -e524?--P

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

Giải trình:

Các sumlệnh in một checksum và một số khối. Tôi không biết nhiều chi tiết, nhưng sử dụng tùy chọn -s(thuật toán System V) sẽ làm cho tổng kiểm tra bằng tổng ASCII của mỗi mã ký tự đầu vào. Như vậy, tổng kiểm tra không đổi khi thứ tự của các ký tự đầu vào thay đổi.

Được đưa ra 867953120như trường hợp thử nghiệm (ví dụ cuối cùng), đây là cách tập lệnh hoạt động:

• sum -sđầu ra 473 1. Nếu không có số nguyên nào bị thiếu, tổng kiểm tra sẽ là 525.
• dc -e524?đẩy 524 và sau đó đầu vào đường ống. Ngăn xếp là : 1 473 524. Ý tưởng là trừ tổng kiểm tra từ 525, nhưng vì tổng đầu ra là 1, tôi cần phải làm việc với nó.
• --P. Sau khi áp dụng hai phép trừ (524- (473-1)), ngăn xếp là : 52. Với 'P', tôi in ký tự với mã ASCII đó : 4, chữ số bị thiếu.

Fortran 95, 146 128 byte

function m(s)
character(len=10)::s,t
t='0123456789'
do j=1,10
k=0
do i=1,9
if(s(i:i)==t(j:j))k=1
end do
if(k==0)m=j-1
end do
end

Không ngắn lắm, tôi sợ.

Ung dung:

integer function m(s)
    implicit none

    character(len=9)::s
    character(len=10)::t
    integer:: i, j, k

    t='0123456789'
    do j=1,10
        k=0
        do i=1,9
            if (s(i:i) == t(j:j)) k=1
        end do
        if (k==0) m=j-1
    end do

end function m

CJam , 5 byte

A,sq-

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

A,     e# The range from 0 to 9: [0 1 2 3 4 5 6 7 8 9]
  s    e# Cast to a string: "0123456789"
   q   e# The input
    -  e# Remove all characters from the range that are in the input
       e# Implicit output

GNU sed , 36 byte

Bao gồm +1 cho -r

s/$/0123456789/
:
s/(.)(.*)\1/\2/
t

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

s/$/0123456789/ # Append 0123456789
:               # Start loop
s/(.)(.*)\1/\2/ # remove a duplicate character
t               # loop if something changed

Brachylog (2), 5 byte

ẹ:Ị↔x

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

Có thể cho rằng nên ngắn hơn (tôi vẫn bối rối không biết tại sao điều đó lại ẹcần thiết), nhưng đây là điều tốt nhất tôi có thể làm.

Giải trình

ẹ:Ị↔x
ẹ      Split the input into a list of characters
 :Ị    Pair that list with the string "0123456789"
   ↔x  Remove all elements of the list from the string

Lisp thông thường, 47 byte

(lambda(s)(- 45(reduce'+ s :key'digit-char-p)))

Ung dung:

(lambda (s) (- 45 (reduce '+ s :key 'digit-char-p)))

Giải thích:

(reduce '+ s :key 'digit-char-p)

Vòng lặp này thông qua các ký tự trong s, chuyển đổi chúng thành chữ số và thêm chúng. Digit-char-p, một cách thuận tiện, trả về số char là giá trị "thật" của nó, vì vậy nó có thể được sử dụng như một thử nghiệm hoặc chuyển đổi.

(- 45 ...)

Trừ từ 45 trả lại chữ số bị thiếu từ đầu vào.

Cubix , 18 byte

5v&;52/ni?@.>!&oW+

Mở rộng

    5 v
    & ;
5 2 / n i ? @ .
> ! & o W + . .
    . .
    . .

Hãy thử nó ở đây

Sử dụng cùng một loại phương pháp như câu trả lời não này .

Tạo giá trị -525 trên ngăn xếp bằng cách đẩy 5, 2, nối, đẩy 5, nối và phủ định.
Sau đó lặp lại nhận đầu vào và thêm cho đến khi kết thúc đầu vào.
Xóa đầu vào cuối cùng, phủ định (tạo tích cực) kết quả thêm cuối cùng, xuất ký tự và tạm dừng.

Lý do để làm việc từ -525 trở lên là đầu ra ký tự được nhấn cho mỗi lần lặp đầu vào. Vì giá trị là âm, không có gì là đầu ra cho đến khi vòng lặp được thoát và giá trị âm được làm cho dương.

PHP, 37 byte

<?=45-array_sum(str_split($argv[1]));

Bash (+ tiện ích), 22, 19 byte

• Sử dụng seqthay vì mở rộng dấu ngoặc, -3 byte (Thx @Riley!)

seq 0 9|tr -d \\n$1 

Kiểm tra

$seq 0 9|tr -d \\n123456789
0

Dùng thử trực tuyến!

Google Sheets, 39 33 byte

Đầu vào được nhập vào ô A1.

Mã số:

=REGEXEXTRACT(4&2^29,"[^"&A1&"]")

Đã lưu 6 byte nhờ Steve Kass.

Mã trước:

=REGEXEXTRACT("0123456789","[^"&A1&"]")

Kết quả:

Befunge 98, 14 12 byte

Tôi đã lưu 1 byte bằng cách di chuyển chương trình lên 1 dòng và 1 byte bằng cách thực hiện một số phép toán tốt hơn

~+;@.%a--7;#

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

Giải trình

Tổng các giá trị ASCII nằm trong khoảng từ 477 đến 468 tùy thuộc vào số nào bị thiếu. Bằng cách trừ đi số này từ 7, chúng ta có được phạm vi -470 đến -461. Bằng cách sửa đổi số này bằng 10, chúng ta sẽ có được phạm vi 0 - 9, sau đó chúng ta có thể in.

~+;       ;#    Sums the ASCII values of all characters to stdIn
~          #    The # doesn't skip over the ~ because it's on the end of a line
~               Once EOF is hit, the ~ reverses the IP's direction
          ;#    Jump the ; that was used before
       --7      Subtract the sum from 7 (really just 0 - (sum - 7))
     %a         Mod it by 10
   @.           Print and exit

Lý do tôi sử dụng các giá trị ASCII thay vì lấy đầu vào số nguyên là vì &lệnh trong Dùng thử trực tuyến tạm dừng trên EOF (Mặc dù nó sẽ đảo ngược IP). Các ~công trình chính xác, mặc dù.

Chương trình cũ , 14 byte

#v~+
@>'i5*--,

Tổng các giá trị ASCII của tất cả 10 chữ số là 525. Bằng cách trừ tổng các chữ số đã cho từ 525, chúng tôi nhận được giá trị ASCII của ký tự bị thiếu.

#v~+         Sums the ASCII values of all characters on stdIn
             Moves to the next line when this is done
 >'i5*       Pushes 525 (105 * 5)
      --     Subtracts the sum from 525
@       ,    Prints and exits

PowerShell , 30 byte

param($n)0..9|?{$n-notmatch$_}

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

Lấy đầu vào $n, xây dựng một phạm vi 0..9(nghĩa là 0, 1, 2 ... 9), sau đó sử dụng Where-Objectmệnh đề (the |?{...}) để lấy ra số mà regex -notmatch. Đó là còn lại trên đường ống, đầu ra là ẩn.

Röda , 28 byte

{(_/"")|ord _|sum|chr 525-_}

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

Bình, 5 byte

-jkUT

thử nó!

giải trình

-jkUT
    T   # 10
   U    # The unary range of ten: [0,1,..,9]
 jk     # join that on the empty string
-       # set minus

"-JUT" cũng hoạt động nhưng tạo ra dòng mới cho mọi int.

05AB1E , 5 byte

žhISK

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

Giải trình

žh     # from the string "0123456789"
    K  # remove
  IS   # each digit of the input