ท้าทาย

ให้ตัวเลขทั้งหมดหารด้วย 9 และหนึ่งหลักที่ขาดหายไปหาตัวเลขที่หายไป

ตัวเลขที่หายไปอาจแสดงด้วยอักขระอื่นนอกเหนือจากตัวเลข 0-9 ตราบใดที่มีความสอดคล้องกัน

หากตัวเลขที่หายไปอาจเป็น 0 หรือ 9 ให้เอาบางสิ่งออกมาเพื่อแสดงว่าเป็นเช่นนั้น

สมมติว่าผู้ใช้นั้นฉลาดพอที่จะใส่ตัวเลขหนึ่งหลักที่ขาดหายไปและตัวเลขหนึ่งตัวเท่านั้น

กรณีทดสอบ

ในกรณีทดสอบตัวเลขที่ขาดหายไปจะถูกแสดงด้วยเครื่องหมายคำถาม

123? -> 3
?999 -> 0 or 9
?0023 -> 4
000?1 -> 8

Pythonขนาด 21 ไบต์

lambda s:-int(s,19)%9

ลองออนไลน์!

ฉันเคยIเป็นตัวแทนของตัวเลขที่ขาดหายไป

อลิซ 12 ไบต์

/o&
\i@/+R9%

ลองออนไลน์!

เอาต์พุต0ถ้าผลลัพธ์สามารถเป็น 0 หรือ 9

คำอธิบาย

/   Switch to Ordinal mode.
i   Read all input as a string.
&   Fold the next operation over the characters of this strings.
/   Switch to Cardinal mode (not an operation).
+   Add. Implicitly converts each character to the integer value it represents
    and adds it to the top of the stack. The top of the stack is initially, implicitly
    zero. When the character is "?", it is simply discarded, which adds the top of
    the stack to another implicit zero beneath, so the "?" is effectively skipped.
R   Negate. Multiplies the sum by -1.
9%  Modulo 9. This gives the result.
\   Switch to Ordinal mode.
o   Implicitly convert the result to a string and print it.
@   Terminate the program.

JavaScript (ES6), 40 ไบต์

เอาต์พุต 9 ถ้าเป็น 0 หรือ 9

f=_=>9-([..._].reduce((a,b)=>a+~~b,0)%9)

Japtap, 7 ไบต์

พยายามแก้ไขปัญหาเล็กน้อย แต่สั้นที่สุดคล้ายกับโซลูชันอื่น ๆ ส่วนใหญ่ยกเว้นเราไม่จำเป็นต้องแทนที่ ?ตอนเริ่มต้น

สามารถใช้อักขระที่ไม่ใช่ตัวเลขเป็นตัวเลขที่หายไปได้ ขาออกเมื่อการแก้ปัญหาที่สามารถนั้นหรือ09

¬x*J u9

ลองมัน

คำอธิบาย

Uการป้อนข้อมูลโดยนัยของสตริง ¬แยกเป็นอาเรย์ของอักขระแต่ละตัวxลดอาเรย์ด้วยการไม่สนใจองค์ประกอบที่ไม่ใช่ตัวเลข*Jคูณแต่ละองค์ประกอบด้วย -1 และu9รับโมดูลัสบวกของผลลัพธ์

JavaScript (ES6), 18 ไบต์

คาดว่าจะ+เป็นตัวเลขที่หายไป ผลตอบแทน9สำหรับ0 หรือ 9

s=>9-eval(9+s+9)%9

กรณีทดสอบ

let f =

s=>9-eval(9+s+9)%9

console.log(f('123+'))  // -> 3
console.log(f('+999'))  // -> 0 or 9
console.log(f('+0023')) // -> 4
console.log(f('000+1')) // -> 8

05AB1E , 7 6 ไบต์

การส่งออกของ0หมายถึงผลที่อาจเป็นได้ทั้ง0หรือ9

þSO(9%

ลองออนไลน์! หรือเป็นชุดทดสอบ

คำอธิบาย

þ        # remove non-digits from input
 S       # split to list of digits
  O      # sum list
   (     # negate
    9%   # mod by 9

Python 2 , 44 41 35 ไบต์

^{-6 ไบต์ขอบคุณ RiaD}

lambda n:-sum(ord(c)-3for c in n)%9

ลองออนไลน์!

ผู้ใช้งาน]สำหรับตัวเลขที่ขาดหายไป
เอาต์พุต0ถ้าตัวเลขที่หายไปอาจเป็น 0 หรือ 9

Pyth, 9 7 ไบต์

%_s-Qd9

ใช้ช่องว่างเป็นตัวคั่นและส่งคืนค่า 0 หากผลลัพธ์อาจเป็น 0 หรือ 9

ลองออนไลน์

คำอธิบาย

%_s-Qd9
   -Qd   Remove the space from the input.
  s      Convert it to an integer.
%_    9  Negate mod 9.

Prolog (SWI) , 59 ไบต์

0*[].
X*[H|T]:-between(0,9,H),U is mod(X+H,9),U*T.
+X:-0*X.

ลองออนไลน์!

Yay สำหรับการเขียนโปรแกรมเชิงตรรกะ!

คำอธิบาย

ครั้งแรกที่เราทำคำกริยา *ดิเคตซึ่งถือเมื่อนำไปใช้กับศูนย์และรายการที่ว่างเปล่า เพรดิเคตของเรายังคงอยู่เมื่อด้านหน้าของรายการอยู่ระหว่าง 0 ถึง 9 และเมื่อเราเพิ่มโมดิฟายด์ดิจิตหลัก 9

จากนั้นเราจะกำหนด +ให้เป็นภาคแสดงด้วย0เป็นอาร์กิวเมนต์แรก นั่นคือเราต้องการให้ผลรวมดิจิตอลเป็นผลคูณของ 9

อารัมภบททำงานหนักทุกอย่างเพื่อค้นหาวิธีแก้ปัญหาสำหรับเรา

Befunge-93 , 16 ไบต์

1+!_#@3#.--9%~:#

ลองออนไลน์!

คำตอบ BefungeของJames Holdernessรุ่นหนึ่งบรรทัดที่จัดการเพื่อกำจัดสองไบต์ สิ่งนี้จะบีบอัดโค้ดลงไปหนึ่งบรรทัดกลับทิศทางและใช้ประโยชน์จากความจริงที่ว่า Befunge ไม่ข้ามที่ปลายบรรทัด เขาแนะนำให้ฉันโพสต์คำตอบแยกต่างหากพร้อมคำอธิบาย รหัสใช้ * เป็นตัวแทนของตัวเลขที่หายไปและส่งออก 9 สำหรับ 0 หรือ 9

มันทำงานอย่างไร

1+!_  3  --9% Initialises the pointer going right and initialises the digitsum with 3

1+!_         ~: Gets input and checks whether it is end of input (-1)

      3  - Subtract three from the input. 
           This turns the ASCII values of digits into their mod 9 equivalent ("0"(48)=>45(mod 9)=>0)

          -9% Subtract the value from the digitsum and mod it with 9
              This keeps the digitsum as a negative digit greater than -9
              Repeat this until the input ends

Now this is where it gets tricky.
At the end of input, the stack looks like this:
  -(Digitsum%9), Copy of EOF input (-1)
The pointer is moving left from the _
 +!_ Invert the -1 to get 0 and add it to the digitsum (does nothing but get rid of the -1)
1           %~ Adds 1 mod -1 (no input) = 0 to the stack
         --9 Subtracts 9 from 0, yielding -9 and subtracts that from the digitsum. 
             This makes the digitsum positive and equal to 9-(digitsum%9), our desired value
     @  . Finally, print and exit

* (ค่า ASCII 42) ถูกเลือกเป็นอักขระที่ขาดหายไปเนื่องจากมันตอบโต้ค่าเริ่มต้นของตัวเลขที่ 3

LaTeX หลายไบต์ ( 1000 628 614)

\RequirePackage{expl3}
\ExplSyntaxOn
\tl_new:N \l_divnine_input_tl
\int_new:N \l_divnine_sum_int
\def \getnum {
  \typein [ \l_divnine_input_tl ] { Input\space a\space number }
  \tl_map_function:NN \l_divnine_input_tl \divnine_sum:n
  \int_set:Nn \l_tmpa_int { 9 - \int_mod:nn { \l_divnine_sum_int } { 9 } }
  \typeout
    { The\space missing\space digit\space is:\space
      \int_use:N \l_tmpa_int
      \int_compare:nNnT { \l_tmpa_int } = { 0 } { \space or\space 9 }
    }
}
\cs_new:Nn \divnine_sum:n {
  \regex_match:nnT { \d } { #1 } { \int_add:Nn \l_divnine_sum_int { #1 } }
}
\ExplSyntaxOff
\getnum
\stop

LaTeX อ่านไม่ออก ( 348 334 ไบต์)

\RequirePackage{expl3}\ExplSyntaxOn\int_new:N\1\tl_new:N\2\def\3{\typein[\2]{Input\space a\space number}\tl_map_function:NN\2\4\int_set:Nn\1{9-\int_mod:nn{\1}{9}}\typeout{The\space missing\space digit\space is:\space\int_use:N\1\int_compare:nNnT{\1}={0}{\space or\space9}}}\def\4#1{\regex_match:nnT{\d}{#1}{\int_add:Nn\1{#1}}}\3\stop

LaTeX, 132 ไบต์

\RequirePackage{expl3}\typein[\1].\newcount\2{\ExplSyntaxOn\int_gset:Nn\2{9-\int_mod:nn\19}}\typeout{\the\2 \ifnum\2=9or 0\fi}\stop

อนุญาตให้มีที่ว่างเป็นหลักที่ไม่รู้จักในรหัสนี้เท่านั้น

J , ₁₄ 12 ไบต์

-2 ไบต์ต้องขอบคุณ @BolceBussiere

9|9-[:+/"."0

ฉันไม่รู้จริงๆว่าทำไม"."0ตีความ?เป็น 0 แต่ทำเช่นนั้นกับล่ามของฉันและ TIO ดังนั้นฉันจะไม่ถามคำถาม (อัปเดต: ดูความคิดเห็นเพื่อดูคำอธิบายว่าทำไม)

วิธีการนี้ใช้เวลาเพียงผลรวมของตัวเลขลบมันด้วยการลบจาก 9 และใช้มันโมดูโล 9

ลองออนไลน์!

เจลลี่ , 11 9 6 ไบต์

|0SN%9

คำอธิบาย

|0     # Read input while removing non-digits (question marks) and removing leading zeros
  S    # Sum the digits
   N   # Negate
    %9 # Mod by 9

ผลลัพธ์ 0 หมายถึงผลลัพธ์อาจเป็น 0 หรือ 9

ลองออนไลน์!

ที่บันทึกไว้ 2 ไบต์ขอบคุณที่นาย Xcoder เมื่อใช้แต่ละด่วน ( €) ในระหว่างการประเมินผลการแบ่งตัวเลขเป็นตัวเลขซ้ำซ้อน

บันทึกแล้ว 3 ไบต์ขอบคุณ เดนนิส สามารถ bitwise หรืออินพุตด้วย 0 แทนการวิเคราะห์คำด้วยตนเองเป็นตัวเลขในขณะที่ลบเลขศูนย์หน้าและไม่ใช่ตัวเลข

รวดเร็ว , 51 ไบต์

{9-Int("0"+$0.filter{"?" != $0})!%9}as(String)->Int

ลองออนไลน์!

Befunge-93 (PyFunge) , 22 21 ไบต์

ฉันรู้ว่าฉันไม่จำเป็นต้องใช้?เพื่อเป็นตัวแทนตัวเลขที่หายไปดังนั้นฉันจึงใช้อันที่มีค่าเท่ากับ 9 หลังจากลบ 48: x
นี่ให้ฉันตีกอล์ฟ3+แต่มันช่วยฉันได้เพียง 1 ไบต์เพราะความยาวของ บรรทัดแรกก่อนเงื่อนไข :(

พอร์ตของคำตอบ Befunge-98 ของฉัน:
อีก 5 ไบต์เพื่อตรวจสอบว่าเราได้มาถึง EOF แล้ว,
อีก 1 ไบต์ที่จะกด 48 ( "0"vs '0),
อีก 1 ไบต์ที่จะพิมพ์คำตอบด้วย.@,
และอีก 1 ไบต์เพราะวินาที บรรทัดมีที่ว่าง
สำหรับรวมทั้งหมด 8 ไบต์

~:0`!#|_"0"-+
 @.%9-<

ลองออนไลน์!

เอาท์พุท 0ถ้าตัวเลขที่หายไปอาจเป็น 0 หรือ 9

สิ่งนี้ใช้ได้เฉพาะในตัวแปล PyFunge ด้วยเหตุผลอธิบายด้านล่าง

คำอธิบาย

คำอธิบายส่วนใหญ่นี้ถูกคัดลอกมาจากคำอธิบาย Befunge-98ของฉันเนื่องจากโปรแกรมนั้นคล้ายกับอันนี้มาก _{^{ปลั๊กไร้ยางอาย}}

ในบรรทัดแรกของโปรแกรมเรารวมตัวเลขรวมถึง x ซึ่งถือว่าเป็น 72 เพราะมันเป็นค่า ASCII อย่างไรก็ตามผลรวมจะเท่าเดิมเมื่อเรา modded ด้วย 9 ดังนั้นนี่จึงไม่เกี่ยวข้อง

~:0`!#|_"0"-+    THE FIRST LINE
~                Gets a character from input - If it is negative, we've reached EOF
 :0`!            Pushes 0 if the character is positive, 0 otherwise
     #|_         Goes to the next line if the value if 0
                     This also gets the negative value off the stack by using a |
        "0"-     Subtracts 48 to account for taking in ASCII values
            +    Adds this adjusted value to the sum

ถ้าเราเพียงแค่ modded 9 9 - (sum % 9)เราจะถูกทิ้งไว้กับหลักที่ไม่ถูกต้องเพราะเราต้องการ อย่างไรก็ตามเราสามารถทำได้ดีกว่า9\-ซึ่งจะลบส่วนที่เหลือจาก 9: ถ้าเราทำผลรวมเชิงลบก่อนที่จะ modding ถึง 9 เราจะได้รับผลบวกเทียบเท่ากับ9 - (sum % 9)ในล่ามบางคน นี่คือสิ่งที่เราต้องการใช้ล่าม PyFunge สำหรับ Befunge 93 และ 98 เนื่องจากเป็นเพียงหนึ่งเดียวใน TIO ที่ทำสิ่งนี้ คนอื่น ๆ ให้ค่าเราระหว่าง -8 ถึง 8 แทน 0 และ 8

 @.%9-<    THE SECOND LINE
      <    Redirects the IP onto this line
     -     Subtracts the sum from an implicit 0, making it negative
   %9      Mods the sum by 9
 @.        Prints the digit and exits

Befunge-98 (PyFunge) , 15 13 ไบต์

ฉันรู้ว่าฉันไม่จำเป็นต้องใช้?เพื่อแสดงตัวเลขที่หายไปดังนั้นฉันจึงใช้อันที่มีค่าเท่ากับ 9 หลังจากลบ 48: x
นี่ให้ฉันออก3+ไป

#v~'0-+
q>-9%

ลองออนไลน์!

ใช้ xเป็นตัวเลขที่หายไปเพราะค่า ASCII หารด้วย 9 หลังจากลบ 48 (และมันดีเพราะใช้กันทั่วไปเป็นตัวแปรในคณิตศาสตร์)

เอาต์พุตผ่านโค้ดทางออก (เนื่องจากqสั้นกว่าหนึ่งไบต์.@)
เอาต์พุต0หากหลักที่หายไปอาจเป็น 0 หรือ 9

สิ่งนี้ใช้ได้เฉพาะในตัวแปล PyFunge ด้วยเหตุผลอธิบายด้านล่าง

คำอธิบาย

ในบรรทัดแรกของโปรแกรมเรารวมตัวเลขรวมถึงxซึ่งถือว่าเป็น 72 เนื่องจากเป็นค่า ASCII อย่างไรก็ตามผลรวมจะเท่าเดิมเมื่อเรา modded ด้วย 9 ดังนั้นนี่จึงไม่เกี่ยวข้อง

#v~'0-+    THE FIRST LINE
#v~        Pushes the next character from input, and goes to the second line on EOF
   '0-     Subtracts 48 to account for taking in ASCII values
      +    Adds this adjusted value to the sum

ถ้าเราเพียงแค่ modded 9 9 - (sum % 9)เราจะถูกทิ้งไว้กับหลักที่ไม่ถูกต้องเพราะเราต้องการ อย่างไรก็ตามเราสามารถทำได้ดีกว่า9\-ซึ่งจะลบส่วนที่เหลือจาก 9: ถ้าเราทำให้ผลรวมเชิงลบก่อน modding 9 เราจะได้รับผลบวกเทียบเท่ากับในบางล่าม9 - (sum % 9) นี่คือสิ่งที่เราต้องการใช้ล่าม PyFunge สำหรับ Befunge 93 และ 98 เนื่องจากเป็นเพียงหนึ่งเดียวใน TIO ที่ทำสิ่งนี้ คนอื่น ๆ ให้ค่าเราระหว่าง -8 ถึง 8 แทน 0 และ 8

q>-9%    THE SECOND LINE
 >       Redirects the IP onto this line
  -      Subtracts the sum from an implicit 0, making it negative
   9%    Mods the sum by 9
q        Outputs via exit code, ending the program

ทับทิมขนาด 22 ไบต์

ใช้'(ตัวอักขระใด ๆ ที่มีระยะห่าง0จากตัวหารด้วย "0" จะรวมถึง0ตัวมันเอง)

การส่งออกของ0หมายอย่างใดอย่างหนึ่งหรือ09

p -(gets.sum+6*~/$/)%9

ลองออนไลน์!

คำอธิบาย

p     # print after inspecting
  -(  # unary negative, for reversing result of modulus (a-b%a)
    gets.sum # ascii value of string
    + 6*~/$/ # add six for each size (in chars) of input, so "0" translates to 0
  )%9 # mod 9
      # find remainder after dividing 9
      # except it's inverted so it's remainder to add to divide 9

Ruby , 46 , 41 ไบต์

-5 ขอบคุณ @Unihedron

->s{-s.chars.sum{|i|?<>i ? i.to_i : 0}%9}

ลองออนไลน์!

Befunge-93, 28 27 19 18 ไบต์

เครดิตต้องไปที่Mistah Figginsซึ่งคำตอบของ PyFungeแสดงให้ฉันเห็นว่าคุณไม่จำเป็นต้องมีการตรวจสอบพิเศษสำหรับตัวละครหลักที่ขาดหายไปหากคุณเพิ่งตรวจสอบให้แน่ใจว่าค่า ASCII นั้นเป็นค่าคูณเก้า

ขอขอบคุณJo King เพิ่มเติมที่แสดงให้เห็นว่าคุณไม่จำเป็นต้องแปลงอักขระเป็นตัวเลขเทียบเท่าและสามารถลบ 3 เพื่อรับค่าที่สัมพันธ์กับฐาน 9 (ASCII 0ลบ 3 คือ 45, คูณ 9) .

3_v#`0:~--
%9_@.+9

ลองออนไลน์!

เพื่อการทำงานคุณควรใช้ตัวอักษร*สำหรับตัวเลขที่หายไป (มีคนอื่นที่สามารถใช้งานได้ แต่นั่นก็เป็นวิธีที่ดีที่สุด)

เอาต์พุต9ถ้าตัวเลขที่หายไปอาจเป็น 0 หรือ 9

คำอธิบาย

3             Push 3 onto the stack.
 _            Since this is non-zero, drop the 3 and branch left.
3             Now executing right to left, push 3 again.
        --    Negate twice, leaving the value unchanged as our starting sum.

       ~      Now we start the main loop, reading a character from stdin.
    `0:       Duplicate and check if it's > 0, i.e. not end-of-stream.
 _ #          If so, continue to the left.
3        -    Subtract 3 to make the number relative to base 9.
        -     Then subtract it from the total, and repeat the loop.

  v           Once we reach the end of the input, we go down.
  _           Drop the EOF character from the stack and go left.
%9   +9       Mod the total with 9, and add 9.
   @.         Output the result and exit.

โดยพื้นฐานแล้วเรากำลังคำนวณผลรวมของตัวเลขทั้งหมดบวก 45 ต่อหลัก (ซึ่งจะถูกยกเลิกในที่สุดเมื่อเราแก้ไขด้วย 9) ผลรวมนี้หักออกจาก 3 (ผลรวมเริ่มต้นของเรา) และอีก 39 ลบด้วยหลักที่หายไป (ASCII *ลบสาม) อีกครั้งว่า 3 ลบ 39 เป็นผลคูณของ 9 ดังนั้นมันจึงถูกยกเลิกเมื่อเราดัดแปลงด้วย 9

ในที่สุดเราก็คำนวณผลบวกลบของหลักทั้งหมด, mod 9, บวก 9, เช่น

9 - (digitsum % 9)

และนั่นทำให้ตัวเลขที่หายไป

Befunge-98 (PyFunge) 8 ไบต์

#q~3--9%

ลองออนไลน์!

ส่งออกผ่านรหัสทางออก เช่นเดียวกับคำตอบของ Mistah Figginมันใช้งานได้กับ Pyfunge เท่านั้นโดยที่ mod ลบหมายเลข 9 จะกลายเป็นบวก ใช้ x เป็นตัวเลขที่หายไป

PowerShellขนาด 40 ไบต์

param($a)0..9|?{!(($a-replace'x',$_)%9)}

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

จะเข้าเหมือนเข้าไป'123x' $aโครงสร้างช่วง0การ9และการใช้งานWhere-Object(ที่นี่เรียกโดยย่อว่า|?) จะดึงออกเลขที่ตรงกับประโยค ข้อนี้จะใช้เวลา$aดำเนินการนิพจน์ทั่วไป-replaceเพื่อแทนที่xด้วยหลักในปัจจุบัน$_และได้รับพอควร %99 ดังนั้นถ้า 9 หารเท่า ๆ กันนี่จะเป็นศูนย์ เราใช้บูลีน - ไม่ใช่ของมันซึ่งเปลี่ยนความจริงเป็นศูนย์และทุกสิ่งทุกอย่างก็ล้มเหลวเพื่อให้เป็นไปตามข้อที่ ผลลัพธ์เหล่านั้นจะถูกทิ้งไว้บนไปป์ไลน์และเอาท์พุทเป็นนัย

Haskell , 35 ไบต์

f s=9-sum[read[i]|i<-s,i<':']`mod`9

ลองออนไลน์!

จอประสาทตา35 34 25 ไบต์

ถ้า?สามารถเป็นผลที่ได้จะแสดงเป็น0 or 99

.
$*
1{9}

^
9$*;
+`;1

.

ลองออนไลน์

คำอธิบาย

.       Sum of the digits in unary + 1
$*
1{9}    Modulo 9

^       Prepend 9 semicolons, for subtracting
9$*;
+`;1    Subtract from 9

.       Back to decimal

Perl 5 , 23 ไบต์

$_=- s/\D//r%9;s/0/0|9/

ลองออนไลน์!

ไม่สนใจว่าอักขระตัวใดมีความหมายว่าตัวเลขที่หายไปตราบใดที่ไม่ใช่ตัวเลข

Tcl, 53 ไบต์

puts [expr 9-([regsub -all (\\d)\\D? 0$argv +\\1])%9]

เช่นเดียวกับคำตอบอื่น ๆ สิ่งนี้สั้นลงโดยไม่พูดอย่างชัดเจนว่า“ 0 หรือ 9”
ผลลัพธ์ของ“ 9” หมายถึง 0 หรือ 9 แทน

ลองออนไลน์!

คำอธิบาย

มันใช้งานได้ง่ายมาก มันมีการแสดงออกปกติไปที่:

• แยกอาร์กิวเมนต์ออกเป็นตัวเลขแต่ละตัว
• กำจัดเครื่องหมายคำถามใด ๆไม่ใช่ตัวเลข
• แทรกตัวเลขด้วยเครื่องหมายบวก

จากนั้นประเมิน 9 - (sum_of_digits mod 9) เพื่อให้ถึงค่าสุดท้ายใน 1..9 ซึ่งมันจะ putsซึ่งมันแล้ว

0$argvจำเป็นต้องมีการนำ 0 (ใน) ในกรณีที่เครื่องหมายคำถามมาก่อนในอินพุต exprชั้นนำเครื่องหมายบวกในลำดับที่เปลี่ยนไม่ได้เป็นปัญหาสำหรับ

Pyth , 8 ไบต์

%_iz19 9

ลองออนไลน์!

ใช้แทนI?

• แปลงเป็นฐาน 19
• ลบล้าง
• Modulo 9.

APL (Dyalog), 13 bytes

{9-9|+/,↑⍎¨⍵}

Try it online!

The missing digit is ⍬.

brainfuck, 50 bytes

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

Try it online!

Prints a 9 for either 0 or 9. Missing character is represented by :

How It Works

Tape Format:
    0 Total Input 0

The total is represented as 9-digitSum%9

+>,[ Start loop with 1 as the total
    --- Subtract 3 from the inputted byte to make the value%9 equal to the digit
    [   While the input byte exists
      <-                 Decrement the total
      [<<]>[<+++++++++<] If the total is 0, reset it to 9
      >>-                Decrement the input byte
    ]
,] Continue loop until there is no input
-[<+>-----]<---. Add 48 to the total to convert the digit to the ascii value and output it

The missing character needs to be a character that has a mod 9 of 4, +3 because we subtract 3 from the normal digits and +1 for the initialisation of the total as 1.

As a side note, there is a lot of inefficiency in the code for the sake of golfing, as each digit will reset the total 5 times each, rather than just once sometimes if I subtracted 48 instead of 3.

><>, 35 33 25 21 15 bytes

An output of 0 means the result could be either 0 or 9.

0i:&0(?n&3--9%!

Try it online!

Saved 6 bytes thanks to Jo King by using ' to represent missing digits.

Java 8, 36 34 bytes

s->9-s.map(c->c>57?0:c-48).sum()%9

Returns 9 when both 0 and 9 are valid.

Explanation:

Try it online.

s->                               // Method with IntStream parameter and int return-type
   9-                             //  Return 9, minus:
     s.map(c->c>57?0:c-48).sum()  //   The sum of the digits (ignoring the question mark)
     %9                           //   modulo-9