Podaj brakującą liczbę całkowitą


34

Otrzymasz ciąg znaków. Będzie zawierał 9 unikatowych liczb całkowitych od 0 do 9. Musisz zwrócić brakującą liczbę całkowitą. Ciąg będzie wyglądał następująco:

123456789
 > 0

134567890
 > 2

867953120
 > 4

5
@riker Wygląda na to, że chodzi o znalezienie numeru brakującego w sekwencji. Wydaje się, że chodzi o odnalezienie brakującej cyfry w zestawie.
DJMcMayhem

10
@Riker Nie sądzę, że jest to duplikat, biorąc pod uwagę, że połączone wyzwanie ma ściśle rosnącą sekwencję (potencjalnie wielocyfrowych liczb), podczas gdy tutaj jest w dowolnej kolejności.
AdmBorkBork

3
Cześć Josh! Ponieważ nikt jeszcze o tym nie wspominał, skieruję cię do piaskownicy, gdzie możesz opublikować pomysły na przyszłe wyzwania i uzyskać znaczącą opinię przed wysłaniem do main. Pomogłoby to rozwiązać wszelkie szczegóły (takie jak STDIN / STDOUT) i rozwiązało dubler dylematu, zanim otrzymano tutaj opinie negatywne.
AdmBorkBork

1
Szkoda, że ​​9-x% 9 działa na dowolną cyfrę oprócz 0. Może ktoś sprytniejszy ode mnie znajdzie sposób, aby to zadziałało.
Bijan

2
Kilka odpowiedzi przyjmuje liczbę całkowitą jako dane wejściowe funkcji. Czy to jest dozwolone?
Dennis

Odpowiedzi:


36

Python 2 , 18 16 bajtów

+ piękno dzięki @Sarge Borsch

`99066**2`.strip

Wypróbuj online!

99066**2 jest tylko krótszym sposobem na wygenerowanie ciągu zawierającego 0 ~ 9


7
32043 można zmienić na piękniejszą liczbę. 99066 jest symetryczny centralnie (nie zmienia się, jeśli jest obrócony o 180 stopni wokół środka), a może 97779 (palindrom, dwie wyraźne cyfry)
Sarge Borsch

1
Jeśli PO pozwala wydrukować numer dwa razy, 764**4można zapisać dwa bajty.
Tytus

@Titus 764**4zaginął 5, 8a9
Rod

1
Literówka ... Miałem na myśli 763**4=338920744561
Tytus

25

Python , 22 bajty

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

Wypróbuj online!

Rozwiązanie arytmetyczne. Interpretuje ciąg wejściowy jako szesnastkowy, neguje go i przyjmuje wynik modulo 15.


2
Czy możesz wyjaśnić, dlaczego to działa?
KarlKastor

1
@KarlKastor, modulo 15 w bazie 16 działa analogicznie do modulo 9 w bazie 10. Modulo base-1 jest stały przy pobieraniu sumy cyfr, tylko dlatego, że 10 ≡ 1 (mod base-1). Suma wszystkich możliwych cyfr jest stała, więc brakująca cyfra jest różnicą tej stałej i liczby wejściowej (modulo base-1).
mik

16

APL (Dyalog) , 4 bajty

Funkcja pochodna

D∘~

⎕DD igits

 (łączy lewy argument z następującą funkcją dyadyczną, aby utworzyć funkcję monadyczną)

~ oprócz [argumentu]

Wypróbuj online!


Pociąg funkcji

D~⊢

⎕DD igits

~ z wyjątkiem

 właściwy argument

Wypróbuj online!


Jawny program

D~⍞

⎕DD igits

~ z wyjątkiem

 wprowadzanie znaków

Wypróbuj online!


12

Brain-Flak , 48 38 36 + 3 = 39 bajtów

10 bajtów zapisanych dzięki DJMcMayhem!

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

Wypróbuj online!

Wyjaśnienie

Suma wszystkich cyfr w Ascii wynosi 525. Ten program sumuje dane wejściowe i odejmuje je od 525, aby uzyskać brakującą cyfrę.

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

Popchnie 525. Wykorzystuje to fakt, że wiemy, że na początku będzie 9 elementów danych wejściowych. Oznacza to, że []ocenia na 9, co pozwala nam szybko dostać się do dużych liczb, takich jak 525.

Następnie mamy bit:

                             [{{}}]

który sumuje dane wejściowe i odejmuje je od sumy.


Jak to działa?
Pavel

@ ГригорийПерельман Wyjaśnienie zostało dodane!
Wheat Wizard

2
Jeśli przesuniesz negative(sum(input()))koniec, możesz wykorzystać nilad o wysokości stosu, aby łatwiej pchnąć 525. (([][][]()()()){()()({}[()])}{}[{{}}])powinien zaoszczędzić 10 bajtów
DJMcMayhem

30 bajtów przez odjęcie 477 zamiast
Jo King

12

Haskell , 24 23 bajty

(477-).sum.map fromEnum

Wypróbuj online! Stosowanie:(477-).sum.map fromEnum $ "123456890" . 477 to suma kodów znaków cyfr od 1 do 9, z wyłączeniem 0. Ta anonimowa funkcja oblicza 477 minus suma wszystkich cyfr znaków w celu znalezienia brakującego kodu.

Zamiana cyfr znakowych na ints jest dłuższa o jeden bajt:

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

Wypróbuj online!


10

Galaretka , 3 bajty

ØDḟ

Po prostu filtruje ( ) ciąg wejściowy z „0123456789” ( ØD).

Wypróbuj online!


3
Podoba mi się sposób, w jaki wszystkie języki gry w golfa (a nawet niektóre języki inne niż golfowe) używają tego samego algorytmu, ale Jelly udaje się mieć najkrótsze nazwy wbudowanych funkcji i najmniejszą liczbę elementów do odwrócenia argumentów .

1
@ ais523 APL jest taki sam litera po literze (z wyjątkiem tego, że byłby to fragment kodu APL zamiast funkcji / programu): Ø= , D= D, = ~, jak w ⎕D~'867953120'.
Adám

3
Ja, przewijając odpowiedzi: „Przewiduję 3 postacie w galarecie”. Bingo : ^ D
DLosc

9

Ruby, 14

Sums the ascii codes and subtracts from 48*9+45

->s{477-s.sum}

Użyj w ten sposób

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

puts f["123456789"]

9

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.

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

Test

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>


s=>eval([1,...s].join`^`) saves a byte.
Neil

@Neil ... and it's much more interesting too
edc65

I feel this tip came suspiciously short after my answer :D anyway nice golf +1.
Christoph

1
@Christoph Well it sounded as if you wanted to spread the word...
Neil

@Neil absolutly :) Nice to see that it helped!
Christoph

8

Retina, 27 21 19 bytes

-6 Thanks to Basic Sunset
-2 Thanks to Martin Ender

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

1

Try it online!

Replace every digit with that many _s and 5 1s:

.
$*_5$*

Remove all of the _s and a 1 for each:

+`_1|1_ 


Count the number of 1s left:

1

The first line of the second answer can be just ..
Neil

You can save a few bytes by using deduplication instead of replacement: Try it online
Business Cat

Oh well, and here was I just getting the second answer down to the old byte count of the first answer... ^ 5 ^. $*9¶ . $*_ +`_¶_ _
Neil

@Neil I got it to one less than the original.
Riley

(Huh, that looks suspiciously similar to my answer, the only difference is that you switched from _ to 1 to save a byte.)
Neil


6

JavaScript (ES6), 31 29 28 22 bytes

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

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.


s=>[...s].map(c=>r-=c,r=45)|r ;-)
ETHproductions

3
You are too much in love with reduce. +1 anyway
edc65

@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:

  1. One gets added to the second cell (saving 1 byte at the end).
  2. 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.



5

Mathematica, 25 bytes

477-Tr@ToCharacterCode@#&

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.


5

PHP, 27

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

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

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

This one uses xor because I haven't seen it yet.


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:

sum -s|dc -e524?--P

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 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.

4

Fortran 95, 146 128 bytes

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

3

CJam, 5 bytes

A,sq-

Try it online!

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

3

GNU sed, 36 bytes

Includes +1 for -r

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

Try it online!

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

3

Brachylog (2), 5 bytes

ẹ:Ị↔x

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

ẹ:Ị↔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

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.


3

Cubix, 18 Bytes

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

Expanded

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

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.



3

Bash (+utilities), 22, 19 bytes

  • Use seq instead of brace expansion, -3 bytes (Thx @Riley !)
seq 0 9|tr -d \\n$1 

Test

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

Try It Online!


If you moved the space before the $1 it would be more obvious...
Neil

@Neil, yep, that's a nice idea ! Thx !
zeppelin

You could use seq instead of echo: seq 0 9|tr -d \\n$1
Riley

3

Google Sheets, 39 33 bytes

Input is entered into cell A1.

Code:

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

Saved 6 bytes thanks to Steve Kass.

Previous Code:

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

Result:

enter image description here


The number 2^29 has all the digits but 4, so 33 bytes: =REGEXEXTRACT(4&2^29,"[^"&A4&"]")
Steve Kass

@SteveKass Nice. =REGEXEXTRACT(0&49^9,"[^"&A1&"]") is also a valid solution, given similar logic. Updated answer.
Grant Miller

3

Befunge 98, 14 12 bytes

I saved 1 byte by moving the program onto 1 line and 1 byte by doing some better math

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

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.

~+;       ;#    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.

Old Program, 14 bytes

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

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

2

PowerShell, 30 bytes

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

Try it online!

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.



2

Pyth, 5 Bytes

-jkUT

try it!

explanation

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

"-jUT" also kinda works but produces newlines for every int.


2

05AB1E, 5 bytes

žhISK

Try it online!

Explanation

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

6
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'.
Penguino
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.