Anda akan diberikan string. Ini akan berisi 9 bilangan bulat unik dari 0-9. Anda harus mengembalikan bilangan bulat yang hilang. String akan terlihat seperti ini:
@ striker Itu sepertinya tentang menemukan nomor yang hilang secara berurutan. Ini sepertinya tentang menemukan digit yang hilang dari suatu set.
DJMcMayhem
10
@Riker Saya tidak akan berpikir itu adalah duplikat, mengingat bahwa tantangan terkait memiliki urutan peningkatan ketat (dari nomor multi-digit berpotensi), sedangkan di sini dalam urutan acak.
AdmBorkBork
3
Hai Josh! Karena tidak ada orang lain yang menyebutkannya sejauh ini, saya akan mengarahkan Anda ke Sandbox tempat Anda dapat memposting ide tantangan di masa depan dan mendapatkan umpan balik yang berarti sebelum memposting ke utama. Itu akan membantu menyelesaikan semua detail (seperti STDIN / STDOUT) dan menyelesaikan dilema duplikat sebelum Anda menerima downvote di sini.
AdmBorkBork
1
Sayang sekali bahwa 9-x% 9 berfungsi untuk angka apa pun kecuali 0. Mungkin seseorang yang lebih pintar dari saya akan menemukan cara untuk membuatnya bekerja.
Bijan
2
Beberapa jawaban menggunakan integer sebagai input fungsi. Apakah itu diizinkan?
32043 dapat diubah ke angka yang lebih indah. 99066 adalah pusat-simetris (tidak berubah jika diputar 180 derajat di sekitar tengah) atau mungkin 97779 (palindrom, dua digit berbeda)
Sarge Borsch
1
Jika OP memungkinkan untuk mencetak nomor dua kali, 764**4dapat menghemat dua byte.
@KarlKastor, modulo 15 pada basis 16 bekerja secara analog dengan modulo 9 pada basis 10. Modulo basis-1 adalah konstan ketika mengambil jumlah digit, hanya karena 10 ≡ 1 (mod basis-1). Jumlah semua digit yang mungkin adalah konstan, jadi digit yang hilang adalah perbedaan dari konstanta ini dan nomor input (modulo base-1).
Jumlah semua digit di Ascii adalah 525. Program ini merangkum input dan mengurangi dari 525 untuk mendapatkan digit yang hilang.
((([]())[]{}){()()({}[()])}{} )
Will push 525. This takes advantage of the fact that we know there will be 9 elements of input to begin with. This means that [] evaluates to 9 which allows us to get to large numbers like 525 quickly.
Next we have the bit:
[{{}}]
which will sum up the inputs and subtract it from the total.
If you move the negative(sum(input())) to the end, you can abuse the stack-height nilad to push 525 easier. (([][][]()()()){()()({}[()])}{}[{{}}]) should save you 10 bytes
Try it online! Usage: (477-).sum.map fromEnum $ "123456890". 477 is the sum of the character codes of the digits 1 to 9, excluding 0. This anonymous function computes 477 minus the sum of all digit character codes to find the missing one.
Turning the char digits to ints is one byte longer:
I like the way that all the golfing languages (and even some non-golfing languages) are using the same algorithm, but Jelly manages to have the shortest names for the builtins it uses, and the least boilerplate for reversing the arguments to ḟ.
1
@ais523 APL is letter by letter the same (except that it would be an APL snippet rather than a function/program): Ø=⎕, D=D, ḟ=~, as in ⎕D~'867953120'.
Adám
3
Me, while scrolling through the answers: "I'm predicting 3 characters in Jelly." Bingo. :^D
Edit 1 byte save thx @Neil, with a much more smarter trick
Xoring all the values from 1 to 9 gives 1. Xor 1 one more time and the result is 0. So, if any single value is missing, the result will be the missing value.
Port of @xnor's Python answer, except that JavaScript only has a remainder operator rather than a modulo operator, so I can't do it in a single step. Edit: Saved 6 bytes thanks to @Arnauld.
@Arnauld I don't see that working when s[0]!='0', but there's already an answer that uses eval.
Neil
Could you do s=>(15-`0x${s}`%15)%15?
Arnauld
@Arnauld Bah, and I'd already done that for the Batch port too...
Neil
6
Brainfuck, 17 15 bytes
-[-[->-<],]>++.
Try it out here.
This solution works on standard Brainfuck (8-bit cells) only, as it relies on wrapping.
It's a rare day when Brainfuck can actually compete, but this challenge just happened to line up with the BF spec pretty well!
Instead of straight-up breaking down this answer, I'd like to step through the iterations I took, because I think it would be more understandable (and more interesting).
Note: this solution is inspired largely by Wheat Wizard's Brain-Flak answer.
Explanation
Step 1, 26 bytes
In his answer, Wheat Wizard pointed out that the sum of the ASCII values from 0-9 sum to 525. And since standard Brainfuck only has a notion of [0,255], this makes the value 525 % 256 = 13. That is to say, subtracting the ASCII values of the input from 13 nets you the missing digit.
The first version of this program was:
1. Put 13 in the first cell
2. Take inputs into the second cell
3. Subtract the second cell from the first cell
4. Jump to 2 if there are inputs remaining
5. Print the first cell
And here's the code for the simple solution:
+++++++++++++ #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
Step 2, 19 bytes
As pointed out in his answer, since we know the input will be exactly length 9, we can use that value as a constant, and eliminate that long string of +'s right at the beginning.
It also doesn't matter at what point we add 13 (thanks, commutative property!), so we'll mix it in with the subtraction and printing steps.
, #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
This was my original answer to this problem, but we can do better.
Step 3, 17 bytes
Interestingly enough, the previous answer works even if we begin with a + instead of a ,
+[[->-<],>+<]>++++.
Brainfuck required something in a cell in order to begin a loop. We naively added that extra 4 in the end, when it could have gone in other places.
-[[->-<],>+<]>++.
With some totally intentional (read: trial and error) loop trickery, starting off the program with a - leads to two interesting results:
One gets added to the second cell (saving 1 byte at the end).
The loops runs one extra time, totaling 10 instead of 9 (saving another 1 byte).
1 + 10 + 2 = 13, and we end up with the original answer.
Looking back on it, this is probably an excessive write-up for such a simple Brainfuck program.
Step 4, 15 bytes
After thinking about this solution a bit more, I was able to cut off 2 bytes.
I wanted to clarify something about the previous step:
The minus to enter the loop effectively adds 1, but what it's actually doing is subtracting 255 from the second cell (resulting in 1).
It's obvious in retrospect, but subtracting 1 from the first cell is the same as adding 1 to the second cell (because everything in the first cell gets subtracted from the second cell.)
-[-[->-<],]>++.
I was able to remove the ">+<" by adding a "-" at the beginning of the first loop. It has to go there, and not where the ">+<" was, because the program will loop infinitely otherwise.
Pure function taking a string as input and returning an integer.
Mathematica has long command names and is reluctant to convert between strings and integers, which makes it particularly bad at this challenge. The best I could find was the algorithm from Level River St's Ruby answer, which does a computation based on the total of the ASCII codes of the input string; in Mathematica, this uses only one long command name.
Nice I have not think about trim. Alternatives values 32043,32286,33144,35172,35337,35757,35853,37176,37905,38772,39147,39336,40545,42744,43902,44016,45567,45624,46587,48852,49314,49353,50706,53976,54918,55446,55524,55581,55626,56532,57321,58413,58455,58554,59403,60984,61575,61866,62679,62961,63051,63129,65634,65637,66105,66276,67677,68763,68781,69513,71433,72621,75759,76047,76182,77346,78072,78453,80361,80445,81222,81945,83919,84648,85353,85743,85803,86073,87639,88623,89079,89145,89355,89523,90144,90153,90198,91248,91605,92214,94695,95154,96702,97779,98055,98802,99066
Jörg Hülsermann
5
Bash + coreutils, 19 bytes
I found a shorter bash solution, that uses an interesting checksum approach:
The sum command prints a checksum and a block count. I don't know many details, but using the option -s (System V algorithm) will make the checksum equal to the ASCII sum of each input character code. As such, the checksum remains constant when the order of the same input characters changes.
Given 867953120 as test case (last example), here is how the script works:
sum -s outputs 473 1. If no integer was missing, the checksum would have been 525.
dc -e524? pushes 524 and then the pipe input. The stack is: 1 473 524. The idea is to subtract the checksum from 525, but since sum outputs 1 as well, I need to work with it.
--P. After applying the two subtractions (524-(473-1)), the stack is: 52. With 'P' I print the character with that ASCII code: 4, the missing digit.
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
Not very short, I'm afraid.
Ungolfed:
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
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
x implementation is old and pretty buggy, which is why you need ẹ.
Fatalize
You can actually make an argument that something like ¬∋ℕ should work in only 3 characters – that's what I tried first – but there's multiple reasons why it doesn't, and I don't think there's any plausible way to change Brachylog so that it would.
Having ¬∋ℕ work like that is not even possible in Prolog, unless specifically programming what you mean by not not in. ¬ in Brachylog is equivalent to \+ in Prolog, and its meaning is that of "not provable under the closed-world assumption", rather than "give me choice points for everything that does not verify this" (which is almost always an infinite number of things)
Fatalize
The only way to do it in Prolog would be to "labelize" the ℕ in advance, but that would mean tinkering with Brachylog's evaluation order based on the content of the predicates. That's only one of the problems it has, though; there are a ton of others.
3
Common Lisp, 47 bytes
(lambda(s)(- 45(reduce'+ s :key'digit-char-p)))
Ungolfed:
(lambda (s) (- 45 (reduce '+ s :key 'digit-char-p)))
Explaination:
(reduce '+ s :key 'digit-char-p)
This loops through the chars in s, converts them to digits, and adds them. Digit-char-p, conveniently, return the number of the char as its "true" value, so it can be used as a test or a conversion.
(- 45 ...)
Subtract from 45 gives back the digit that was missing from the input.
Uses the same sort of method as this brain-flak answer.
Create the value -525 on the stack by pushing 5, 2, concatenate, push 5, concatenate and negate.
Then repeatably get input and add until end of input is hit.
Remove the last input, negate(make positive) the last add result, output the character and halt.
The reason for working from -525 up is that the character output is hit for each input iteration. Since the value is negative, nothing is output until the loop is exited and the negative value is made positive.
The sum of the ASCII values range from 477 to 468 depending on which number is missing. By subtracting this from 7, we get the range -470 to -461. By modding this number by 10, we get the range 0 - 9, which we can then print.
~+; ;# 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
The reason I use the ASCII values instead of taking integer input is because the & command in Try it Online halts on EOF (Even though it should reverse the IP). The ~ works correctly, though.
The sum of the ASCII values of all 10 digits is 525. By subtracting the sum of the given digits from 525, we get the ASCII value of the missing character.
#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
Takes input $n, constructs a range 0..9 (i.e., 0, 1, 2 ... 9), then uses a Where-Object clause (the |?{...}) to pull out the number that does regex -notmatch. That's left on the pipeline, output is implicit.
I like it because you can say it out loud. '"žhISK", he cried, as he waved his wand over the top-hat and a small white rabbit appeared in a puff of smoke'.
Jawaban:
Python 2 ,
1816 byte+ kecantikan berkat @Sarge Borsch
Cobalah online!
99066**2
hanyalah cara yang lebih singkat untuk menghasilkan string yang berisi 0 ~ 9sumber
764**4
dapat menghemat dua byte.764**4
hilang5
,8
dan9
763**4
=338920744561
Python , 22 byte
Cobalah online!
Solusi aritmatika. Menafsirkan string input sebagai hex, meniadakannya, dan mengambil hasil modulo 15.
sumber
APL (Dyalog) , 4 byte
Fungsi turunan
⎕D
D igits∘
(mengikat argumen kiri ke fungsi diad berikut untuk membuat fungsi monadik)~
kecuali [argumen]Cobalah online!
Kereta fungsi
⎕D
D igits~
kecuali⊢
argumen yang benarCobalah online!
Program eksplisit
⎕D
D igits~
kecuali⍞
input karakterCobalah online!
sumber
Brain-Flak ,
483836 + 3 = 39 byte10 byte disimpan berkat DJMcMayhem!
Cobalah online!
Penjelasan
Jumlah semua digit di Ascii adalah 525. Program ini merangkum input dan mengurangi dari 525 untuk mendapatkan digit yang hilang.
Will push 525. This takes advantage of the fact that we know there will be 9 elements of input to begin with. This means that
[]
evaluates to 9 which allows us to get to large numbers like 525 quickly.Next we have the bit:
which will sum up the inputs and subtract it from the total.
sumber
negative(sum(input()))
to the end, you can abuse the stack-height nilad to push 525 easier.(([][][]()()()){()()({}[()])}{}[{{}}])
should save you 10 bytesHaskell,
2423 bytesTry it online! Usage:
(477-).sum.map fromEnum $ "123456890"
. 477 is the sum of the character codes of the digits 1 to 9, excluding 0. This anonymous function computes 477 minus the sum of all digit character codes to find the missing one.Turning the char digits to ints is one byte longer:
Try it online!
sumber
Jelly, 3 bytes
Simply filters (
ḟ
) the input string from “0123456789” (ØD
).Try it online!
sumber
ḟ
.Ø
=⎕
,D
=D
,ḟ
=~
, as in⎕D~'867953120'
.Ruby, 14
Sums the ascii codes and subtracts from 48*9+45
Use like this
sumber
JavaScript (ES6), 26
Edit 1 byte save thx @Neil, with a much more smarter trick
Xoring all the values from 1 to 9 gives 1. Xor 1 one more time and the result is 0. So, if any single value is missing, the result will be the missing value.
Test
sumber
s=>eval([1,...s].join`^`)
saves a byte.Retina,
27 2119 bytes-6 Thanks to Basic Sunset
-2 Thanks to Martin Ender
Try it online!
Replace every digit with that many
_
s and 51
s:Remove all of the
_
s and a1
for each:Count the number of
1
s left:sumber
.
.^
5
^.
$*9¶
.
$*_
+`_¶_
¶
_
_
to1
to save a byte.)05AB1E, 6 bytes
Try it online!
sumber
JavaScript (ES6),
31292822 bytesPort of @xnor's Python answer, except that JavaScript only has a remainder operator rather than a modulo operator, so I can't do it in a single step. Edit: Saved 6 bytes thanks to @Arnauld.
sumber
s=>[...s].map(c=>r-=c,r=45)|r
;-)reduce
. +1 anyways[0]!='0'
, but there's already an answer that useseval
.s=>(15-`0x${s}`%15)%15
?Brainfuck,
1715 bytesTry it out here. This solution works on standard Brainfuck (8-bit cells) only, as it relies on wrapping.
It's a rare day when Brainfuck can actually compete, but this challenge just happened to line up with the BF spec pretty well!
Instead of straight-up breaking down this answer, I'd like to step through the iterations I took, because I think it would be more understandable (and more interesting).
Note: this solution is inspired largely by Wheat Wizard's Brain-Flak answer.
Explanation
Step 1, 26 bytes
In his answer, Wheat Wizard pointed out that the sum of the ASCII values from 0-9 sum to 525. And since standard Brainfuck only has a notion of [0,255], this makes the value 525 % 256 = 13. That is to say, subtracting the ASCII values of the input from 13 nets you the missing digit.
The first version of this program was:
1. Put 13 in the first cell
2. Take inputs into the second cell
3. Subtract the second cell from the first cell
4. Jump to 2 if there are inputs remaining
5. Print the first cell
And here's the code for the simple solution:
Step 2, 19 bytes
As pointed out in his answer, since we know the input will be exactly length 9, we can use that value as a constant, and eliminate that long string of +'s right at the beginning.
It also doesn't matter at what point we add 13 (thanks, commutative property!), so we'll mix it in with the subtraction and printing steps.
This was my original answer to this problem, but we can do better.
Step 3, 17 bytes
Interestingly enough, the previous answer works even if we begin with a + instead of a ,
Brainfuck required something in a cell in order to begin a loop. We naively added that extra 4 in the end, when it could have gone in other places.
With some totally intentional (read: trial and error) loop trickery, starting off the program with a - leads to two interesting results:
1 + 10 + 2 = 13, and we end up with the original answer.
Looking back on it, this is probably an excessive write-up for such a simple Brainfuck program.
Step 4, 15 bytes
After thinking about this solution a bit more, I was able to cut off 2 bytes.
I wanted to clarify something about the previous step:
The minus to enter the loop effectively adds 1, but what it's actually doing is subtracting 255 from the second cell (resulting in 1).
It's obvious in retrospect, but subtracting 1 from the first cell is the same as adding 1 to the second cell (because everything in the first cell gets subtracted from the second cell.)
I was able to remove the ">+<" by adding a "-" at the beginning of the first loop. It has to go there, and not where the ">+<" was, because the program will loop infinitely otherwise.
sumber
Octave, 22 bytes
Try it online!
sumber
Mathematica, 25 bytes
Pure function taking a string as input and returning an integer. Mathematica has long command names and is reluctant to convert between strings and integers, which makes it particularly bad at this challenge. The best I could find was the algorithm from Level River St's Ruby answer, which does a computation based on the total of the ASCII codes of the input string; in Mathematica, this uses only one long command name.
sumber
PHP, 27
uses the trick from Rod's answer to generate a string containing all digits then removes all digits except for the missing one.
PHP, 41
This one uses xor because I haven't seen it yet.
sumber
32043,32286,33144,35172,35337,35757,35853,37176,37905,38772,39147,39336,40545,42744,43902,44016,45567,45624,46587,48852,49314,49353,50706,53976,54918,55446,55524,55581,55626,56532,57321,58413,58455,58554,59403,60984,61575,61866,62679,62961,63051,63129,65634,65637,66105,66276,67677,68763,68781,69513,71433,72621,75759,76047,76182,77346,78072,78453,80361,80445,81222,81945,83919,84648,85353,85743,85803,86073,87639,88623,89079,89145,89355,89523,90144,90153,90198,91248,91605,92214,94695,95154,96702,97779,98055,98802,99066
Bash + coreutils, 19 bytes
I found a
shorterbash solution, that uses an interesting checksum approach:Try it online!
Explanation:
The
sum
command prints a checksum and a block count. I don't know many details, but using the option-s
(System V algorithm) will make the checksum equal to the ASCII sum of each input character code. As such, the checksum remains constant when the order of the same input characters changes.Given
867953120
as test case (last example), here is how the script works:sum -s
outputs473 1
. If no integer was missing, the checksum would have been 525.dc -e524?
pushes 524 and then the pipe input. The stack is:1 473 524
. The idea is to subtract the checksum from 525, but since sum outputs 1 as well, I need to work with it.--P
. After applying the two subtractions (524-(473-1)), the stack is:52
. With 'P' I print the character with that ASCII code:4
, the missing digit.sumber
Fortran 95,
146128 bytesNot very short, I'm afraid.
Ungolfed:
sumber
CJam, 5 bytes
Try it online!
sumber
GNU sed, 36 bytes
Includes +1 for
-r
Try it online!
sumber
Brachylog (2), 5 bytes
Try it online!
Arguably should be shorter (I'm still confused as to why the
ẹ
is necessary), but this is the best I could do.Explanation
sumber
x
implementation is old and pretty buggy, which is why you needẹ
.¬∋ℕ
should work in only 3 characters – that's what I tried first – but there's multiple reasons why it doesn't, and I don't think there's any plausible way to change Brachylog so that it would.¬∋ℕ
work like that is not even possible in Prolog, unless specifically programming what you mean by notnot in
.¬
in Brachylog is equivalent to\+
in Prolog, and its meaning is that of "not provable under the closed-world assumption", rather than "give me choice points for everything that does not verify this" (which is almost always an infinite number of things)ℕ
in advance, but that would mean tinkering with Brachylog's evaluation order based on the content of the predicates. That's only one of the problems it has, though; there are a ton of others.Common Lisp, 47 bytes
Ungolfed:
Explaination:
This loops through the chars in
s
, converts them to digits, and adds them. Digit-char-p, conveniently, return the number of the char as its "true" value, so it can be used as a test or a conversion.Subtract from 45 gives back the digit that was missing from the input.
sumber
Cubix, 18 Bytes
Expanded
Try it here
Uses the same sort of method as this brain-flak answer.
Create the value -525 on the stack by pushing 5, 2, concatenate, push 5, concatenate and negate.
Then repeatably get input and add until end of input is hit.
Remove the last input, negate(make positive) the last add result, output the character and halt.
The reason for working from -525 up is that the character output is hit for each input iteration. Since the value is negative, nothing is output until the loop is exited and the negative value is made positive.
sumber
PHP, 37 bytes
sumber
Bash (+utilities),
22, 19 bytesseq
instead of brace expansion, -3 bytes (Thx @Riley !)Test
Try It Online!
sumber
$1
it would be more obvious...seq
instead ofecho
:seq 0 9|tr -d \\n$1
Google Sheets,
3933 bytesCode:
Saved 6 bytes thanks to Steve Kass.
Previous Code:
Result:
sumber
=REGEXEXTRACT(0&49^9,"[^"&A1&"]")
is also a valid solution, given similar logic. Updated answer.Befunge 98,
1412 bytesI saved 1 byte by moving the program onto 1 line and 1 byte by doing some better math
Try it online!
Explanation
The sum of the ASCII values range from 477 to 468 depending on which number is missing. By subtracting this from 7, we get the range -470 to -461. By modding this number by 10, we get the range 0 - 9, which we can then print.
The reason I use the ASCII values instead of taking integer input is because the
&
command in Try it Online halts on EOF (Even though it should reverse the IP). The~
works correctly, though.Old Program, 14 bytes
The sum of the ASCII values of all 10 digits is 525. By subtracting the sum of the given digits from 525, we get the ASCII value of the missing character.
sumber
PowerShell, 30 bytes
Try it online!
Takes input
$n
, constructs a range0..9
(i.e.,0, 1, 2 ... 9
), then uses aWhere-Object
clause (the|?{...}
) to pull out the number that does regex-notmatch
. That's left on the pipeline, output is implicit.sumber
Röda, 28 bytes
Try it online!
sumber
Pyth, 5 Bytes
try it!
explanation
"-jUT" also kinda works but produces newlines for every int.
sumber
05AB1E, 5 bytes
Try it online!
Explanation
sumber