Bir dize verilecektir. 0-9 arası 9 benzersiz tam sayı içerecektir. Eksik tamsayıyı döndürmelisiniz. Dize şöyle görünecek:

123456789
 > 0

134567890
 > 2

867953120
 > 4

Python 2 , 18 16 bayt

^{+ Arge Borsch'a + güzellik}

`99066**2`.strip

Çevrimiçi deneyin!

99066**2 0 ~ 9 içeren bir dize oluşturmak için sadece kısa bir yoldur

Python , 22 bayt

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

Çevrimiçi deneyin!

Bir aritmetik çözüm. Giriş dizesini onaltılık olarak yorumlar, olumsuzlar ve sonuç modul 15 alır.

APL (Dyalog) , 4 bayt

Türetilmiş fonksiyonu

⎕D∘~

⎕D D igits

∘ (monadik bir işlev oluşturmak için aşağıdaki argümanla sol argümanı bağlar)

~ [argüman] hariç

Çevrimiçi deneyin!

İşlev treni

⎕D~⊢

⎕D D igits

~ dışında

⊢ doğru argüman

Çevrimiçi deneyin!

Açık program

⎕D~⍞

⎕D D igits

~ dışında

⍞ karakter girişi

Çevrimiçi deneyin!

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

DJMcMayhem sayesinde 10 bayt kurtarıldı!

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

Çevrimiçi deneyin!

açıklama

Ascii'deki tüm rakamların toplamı 525'tir. Bu program girişi toplar ve eksik rakamı elde etmek için 525'ten çıkarır.

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

525'i zorlayacak. Bu, başlangıçta 9 girdi unsuru olacağını bildiğimiz gerçeğinden yararlanıyor. Bu, []525 gibi büyük sayılara hızlı bir şekilde ulaşmamızı sağlayan 9'u değerlendirir.

Sonra biraz var:

                             [{{}}]

Bu girişleri toplayacak ve toplamdan çıkaracaktır.

Haskell , 24 23 bayt

(477-).sum.map fromEnum

Çevrimiçi deneyin! Kullanımı: (477-).sum.map fromEnum $ "123456890". 477, 0 hariç, 1 - 9 arasındaki karakter kodlarının toplamıdır. Bu adsız işlev, eksik olanı bulmak için 477 eksi tüm rakam karakter kodlarının toplamını hesaplar.

Karakter hanelerini ints'a çevirmek bir bayt daha uzun:

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

Çevrimiçi deneyin!

Jöle , 3 bayt

ØDḟ

ḟGiriş dizesini "0123456789" ( ØD) ' den filtreler ( ).

Çevrimiçi deneyin!

Yakut, 14

Ascii kodlarını toplar ve 48 * 9 + 45'ten çıkarır

->s{477-s.sum}

Bu gibi kullanın

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

puts f["123456789"]

JavaScript (ES6), 26

Düzenleme çok daha akıllı hile thx @Neil tasarrufu 1 bayt,

1'den 9'a kadar olan tüm değerleri Xoring, 1'e veya X'e 1 kez daha verir ve sonuç 0 olur. Dolayısıyla, eğer herhangi bir tek değer eksikse, sonuç eksik değer olacaktır.

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

Ölçek

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 bayt

-6 Basic Sunset'e Teşekkürler
-2 Martin Ender'e Teşekkürler

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

1

Çevrimiçi deneyin!

Her rakamı bu kadar _s ve 5 1s ile değiştirin:

.
$*_5$*

Her birini ve hepsini _a 1:

+`_1|1_ 

Kalan 1s sayısını sayın :

1

05AB1E , 6 bayt

45¹SO-

Çevrimiçi deneyin!

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

JavaScript (ES6), 31 29 28 22 bayt

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

@ Xnor'ın Python portu, JavaScript'in sadece bir modulo operatöründen ziyade bir geri kalan operatöre sahip olması haricinde tek bir adımda yapamıyorum. Düzenleme: @Arnauld sayesinde 6 bayt kaydedildi.

Brainfuck, 17 15 bayt

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

Burada dene . Bu çözüm yalnızca standart Brainfuck (8 bit hücreler) üzerinde çalışır, çünkü sarmaya dayanır.

Brainfuck'ın gerçekten rekabet edebileceği nadir bir gün, ancak bu zorluk BF'nin özelliklerine oldukça iyi uyum sağladı!

Bu cevabı bir kenara atmak yerine, aldığım yinelemelere adım atmak istiyorum, çünkü bunun daha anlaşılabilir (ve daha ilginç) olacağını düşünüyorum.
Not: Bu çözüm, büyük ölçüde Buğday Sihirbazı'nın Beyin Flak cevabından ilham almıştır .

açıklama

Adım 1, 26 bayt

Cevaben Buğday Sihirbazı bu değeri 525% 256 = yapar, 0-9 toplamından 525 Ve standart brainfuck beri ASCII değerlerinin toplamı ancak [0,255] kavramını aldığına işaret etti 13 . Başka bir deyişle, girişin ASCII değerlerini 13 ağdan çıkarmak, eksik rakamı gösterir.

Bu programın ilk versiyonu şuydu:
1. İlk hücreye 13 koy
2. Girişleri ikinci hücreye al
3. İkinci hücreyi ilk hücreden çıkar
4. Kalan girişler varsa 2'ye atla
5. İlk hücreyi yazdır

Ve işte basit çözümün kodu:

+++++++++++++ #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  

Adım 2, 19 bayt

Cevabında da belirttiğimiz gibi, girişin tam olarak 9 olacağını biliyoruz, bu değeri sabit olarak kullanabilir ve başlangıçtaki uzun + dizgilerini ortadan kaldırabiliriz.
Ayrıca, hangi noktaya 13 ekleyeceğimiz de önemli değil (teşekkürler, değişmeli özellik!), Bu yüzden çıkarma ve basma adımlarıyla karıştıracağız.

,        #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

Bu benim bu sorunun asıl cevabıydı, ama daha iyisini yapabiliriz.

Adım 3, 17 bayt

İlginçtir ki, önceki cevap a yerine + ile başlasak bile çalışır.

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

Brainfuck bir döngü başlatmak için bir hücrede bir şey gerekli . Saf olarak, ilave 4'ü başka yerlere gidebildiği zaman ekledik.

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

Bazı kasıtlı (okuma: deneme ve yanılma) döngü hileleri ile, programın başlatılması - a ile iki ilginç sonuç doğurur:

1. Biri ikinci hücreye eklenir (sonunda 1 bayt tasarruf sağlar).
2. Döngüler bir defa fazla çalışır, 9 yerine 10 olur (1 bayt daha kaydedilir).

1 + 10 + 2 = 13, ve asıl cevabı buluyoruz.

Geriye bakınca, bu muhtemelen böyle basit bir Brainfuck programı için aşırı bir yazmadır.

Adım 4, 15 bayt

Bu çözümü biraz daha düşündükten sonra 2 baytı kesebildim.

Önceki adımla ilgili bir şeyi açıklığa kavuşturmak istedim:
Döngüye etkili bir şekilde giren eksi 1 ekler, ancak gerçekte yaptığı şey ikinci hücreden 255'i çıkarmaktır (1 ile sonuçlanır).

Geçmişe bakıldığında açıktır, ancak ilk hücreden 1 çıkarılması, ikinci hücreye 1 eklenmesiyle aynıdır (çünkü ilk hücredeki her şey ikinci hücreden çıkarılır).

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

İlk döngünün başına "-" ekleyerek "> + <" harfini kaldırabildim. Oraya gitmeli ve "> + <" olduğu yere gitmemeli, çünkü program sonsuz şekilde döngülenecek.

Octave , 22 bayt

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

Çevrimiçi deneyin!

Mathematica, 25 bayt

477-Tr@ToCharacterCode@#&

Girdi olarak bir dize alarak ve bir tamsayı döndüren saf işlev. Mathematica'nın uzun komut isimleri vardır ve dizgiler ve tamsayılar arasında dönüşüm yapmak konusunda isteksizdir, bu da onu bu zorlukla özellikle kötüleştirir. Bulabildiğim en iyi şey , giriş dizesinin ASCII kodlarının toplamını temel alan bir hesaplama yapan Level River St'in Ruby cevabındaki algoritma ; Mathematica'da bu sadece bir uzun komut adı kullanır.

PHP, 27

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

tüm rakamları içeren bir dize oluşturmak için Rod'un cevabındaki hileyi kullanır, sonra eksik olan hariç tüm rakamları kaldırır.

PHP, 41

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

Bu xor kullanıyor, çünkü henüz görmedim.

Bash + coreutils, 19 bayt

İlginç bir sağlama toplamı yaklaşımı kullanan daha kısa bir bash çözümü buldum :

sum -s|dc -e524?--P

Çevrimiçi deneyin!

Açıklama:

sumKomut bir sağlama ve bir blok sayısını yazdırır. Çok fazla ayrıntı bilmiyorum, ancak seçeneği kullanmak -s(Sistem V algoritması) sağlama toplamını her giriş karakter kodunun ASCII toplamına eşit hale getirir. Bu durumda, aynı giriş karakterlerinin sırası değiştiğinde sağlama toplamı sabit kalır.

867953120Test olayı olarak verildiğinde (son örnek), kodun nasıl çalıştığı şöyle:

• sum -sçıktılar 473 1. Tam sayı yoksa, sağlama toplamı 525 olur.
• dc -e524?524 ve ardından boru girişine basar. Yığın: 1 473 524. Buradaki fikir toplamı 525'ten çıkarmak, ancak toplam 1 de çıktı verdiğinden, onunla çalışmam gerekiyor.
• --P. İki çıkarmalar (524- (473-1)) uygulandıktan sonra, yığın: 52. 'P' ile karakteri ASCII koduyla yazdırıyorum: 4eksik rakam.

Fortran 95, 146 128 bayt

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

Çok kısa değil, korkarım.

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

CJam , 5 bayt

A,sq-

Çevrimiçi deneyin!

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 bayt

İçin +1 içerir -r

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

Çevrimiçi deneyin!

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

Brachylog (2), 5 bayt

ẹ:Ị↔x

Çevrimiçi deneyin!

Muhtemelen daha kısa olmalı (neden hala kafam karıştı ẹ gerekli ), ama bu yapabileceğimin en iyisi.

açıklama

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

Ortak Lisp, 47 bayt

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

Ungolfed:

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

Açıklama:

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

Bu, içindeki karakterlerin arasında dolaşır s, bunları sayılara dönüştürür ve ekler. Digit-char-p, uygun bir şekilde char sayısını "true" değeri olarak döndürür, böylece bir test veya dönüşüm olarak kullanılabilir.

(- 45 ...)

45'ten çıkarma, girişte eksik olan rakamı geri verir.

Cubix , 18 Bayt

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

Expanded

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

Burada dene

Bu beyin lafı gibi aynı yöntemi kullanır cevabı .

5, 2, birleştirmek, 5 tuşuna basmak, birleştirmek ve olumsuzlamak için yığında -525 değerini oluşturun.
Ardından tekrar tekrar giriş yapın ve girişin sonuna kadar ekleyin.
Son girişi kaldırın, son ekleme sonucunu negatifleyin (pozitif olun), karakteri çıkartın ve durdurun.

-525'ten yukarı çalışmanın nedeni, her giriş yinelemesi için karakter çıkışına isabet etmesidir. Değer negatif olduğundan, döngüden çıkılana ve negatif değer pozitif hale getirilene kadar hiçbir şey çıkmaz.

PHP, 37 bayt

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

Bash (+ yardımcı programları), 22, 19 bayt

• seqAyraç genişletme yerine kullanın , -3 bayt (Thx @Riley!)

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

Ölçek

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

Çevrimiçi Deneyin!

Google Sayfaları, 39 33 bayt

Giriş hücreye girilir A1.

Kod:

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

Steve Kass sayesinde 6 bayt kaydedildi.

Önceki kod:

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

Sonuç:

Befunge 98, 14 12 bayt

Daha iyi bir matematik yaparak programı 1 satır ve 1 bayta taşıyarak 1 bayt kurtardım.

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

Çevrimiçi deneyin!

açıklama

ASCII değerlerinin toplamı, hangi sayının eksik olduğuna bağlı olarak 477 ile 468 arasındadır. Bunu 7'den çıkartarak -470 - -461 aralığını elde ederiz. Bu sayıyı 10'a göre değiştirerek, daha sonra yazdırabileceğimiz 0 - 9 aralığını elde ederiz.

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

Tamsayı girişi yerine ASCII değerlerini kullanmamın nedeni, &Çevrimiçi Deneyin komutunun EOF üzerinde durmasıdır (IP'yi ters çevirmesi gerekse bile). ~Gerçi, düzgün çalışır.

Eski Program , 14 bayt

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

10 hanenin tümünün ASCII değerlerinin toplamı 525'tir. Verilen hanelerin toplamını 525'ten çıkartarak eksik karakterin ASCII değerini alırız.

#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 bayt

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

Çevrimiçi deneyin!

Girdiyi alır $n, bir aralık oluşturur 0..9(yani 0, 1, 2 ... 9), ardından regex yapan sayıyı çıkarmak için bir Where-Objectcümle ( |?{...}) kullanır -notmatch. Boru hattında kalan, çıktının kapalı.

Röda , 28 bayt

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

Çevrimiçi deneyin!

Pyth, 5 Bayt

-jkUT

dene!

açıklama

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

"-jUT" da işe yarıyor ama her int için yeni satırlar üretiyor.

05AB1E , 5 bayt

žhISK

Çevrimiçi deneyin!

açıklama

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