도전

정수를 9로 나눌 수 있고 하나의 누락 된 숫자가 있으면 누락 된 숫자를 찾으십시오.

누락 된 숫자는 일관된 한 숫자 0-9 이외의 다른 문자로 표시 될 수 있습니다.

누락 된 숫자가 0 또는 9 일 수 있으면 의미있는 것을 출력하십시오.

사용자가 누락 된 숫자 하나와 숫자 하나만 넣을 정도로 지능적이라고 가정하십시오.

테스트 사례

테스트 사례에서 누락 된 숫자는 물음표로 표시됩니다.

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

파이썬 , 21 바이트

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

온라인으로 사용해보십시오!

나는 I누락 된 숫자를 나타내 곤했습니다.

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

자바 스크립트 (ES6), 40 바이트

0 또는 9 일 수 있으면 9를 출력합니다.

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

apt, 7 바이트

몇 가지 솔루션을 시도했지만 ?시작시 교체 할 필요가 없다는 점을 제외하면 가장 짧은 솔루션은 대부분의 다른 솔루션과 비슷했습니다 .

숫자가 아닌 문자를 누락 된 숫자로 사용할 수 있습니다. 0솔루션이 또는 일 수있는 경우 출력 합니다 9.

¬x*J u9

시도 해봐

설명

문자열의 암시 적 입력 U. ¬개별 문자의 배열로 분할 x하고 숫자가 아닌 요소를 무시하고 배열을 줄이고 *J각 요소에 -1을 곱하고 u9결과의 양의 계수를 얻습니다.

자바 스크립트 (ES6), 18 바이트

+누락 된 숫자로 예상 됩니다. 0 또는 9를 반환 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

파이썬 2 , 44 41 35 바이트

^{RiaD 덕분에 -6 바이트}

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

온라인으로 사용해보십시오!

]숫자가 누락 된 사용자 누락 된 숫자가 0 또는 9 일 수있는 경우
출력 0합니다.

Pyth, 9 7 바이트

%_s-Qd9

공백을 구분 기호로 사용하고 결과가 0 또는 9 일 수 있으면 0을 반환합니다.

온라인으로 사용해보십시오

설명

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

프롤로그 (SWI) , 59 바이트

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

온라인으로 사용해보십시오!

논리 프로그래밍을위한 예!

설명

먼저 우리는 술어를 만듭니다. *이것은 0과 빈 목록에 적용될 때 유지됩니다. 우리의 술어는리스트의 앞이 0과 9 사이 일 때와 선행 숫자 mod 9를 추가 할 때 술어가 보유합니다.

그런 다음 +이 술어로 정의 합니다.0 첫 번째 인수 . 즉 우리는 디지털 합이 9의 배수가되기를 원합니다.

프롤로그는 실제로 우리를위한 솔루션을 찾는 모든 힘든 일을합니다.

Befunge-93 , 16 바이트

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

온라인으로 사용해보십시오!

James Holderness의 Befunge 답변 한 줄 버전으로 2 바이트를 줄일 수 있습니다. 이것은 본질적으로 코드를 한 줄로 압축하고 방향을 바꾸며 Befunge가 줄 끝에서 건너 뛰지 않는다는 사실을 활용합니다. 그는 설명과 함께 별도의 답변을 게시 할 것을 제안했습니다. 이 코드는 누락 된 숫자를 나타내는 *를 사용하고 0 또는 9에 대해 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의 초기 값에 대항하기 때문에 누락 문자로 선택되었습니다.

유액, 바이트 ( 1,000 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 바이트

@BolceBussiere 덕분에 -2 바이트

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 바이트 절약 Mr. Xcoder 절약했습니다 . €평가하는 동안 각 빠른 ( )을 사용하는 경우 숫자를 숫자로 나누는 것이 중복되었습니다.

Dennis 덕분에 3 바이트를 절약했습니다 . 선행 0과 숫자가 아닌 숫자를 제거하면서 입력을 수동으로 숫자로 구문 분석하는 대신 0으로 비트 OR 입력을 수행 할 수 있습니다.

스위프트 , 51 바이트

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

온라인으로 사용해보십시오!

Befunge-93 (PyFunge) , 22 21 바이트

나는 ?결석 숫자를 나타내는 데 사용할 필요가 없다는 것을 깨달았 으므로 48을 뺀 후 9의 배수 인 것을 사용했습니다. x
이것은 골프를 껐습니다 3+. 그러나 길이 때문에 1 바이트 만 절약했습니다. 조건부 앞의 첫 번째 줄 :(

내 비 펀지-98 답의 포트 :
우리가 EOF에 도달 한 경우보다 5 확인하기 위해 바이트
1 바이트 이상 48 (밀어 "0"대 '0)
와 답을 인쇄하는 1 바이트 이상 .@,
1 바이트 이상을, 두 번째 때문에 line에는
총 8 바이트가 더있을 수 있는 공간 이 있습니다.

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

온라인으로 사용해보십시오!

출력 0누락 된 숫자가 0 또는 9 일 수있는 경우 합니다.

아래 설명 된 이유로 PyFunge 인터프리터에서만 작동합니다.

설명

이 설명의 대부분은 Befunge-98 description 에서 복사하여 붙여 넣습니다. 해당 프로그램은이 프로그램과 매우 유사합니다. _{^{뻔뻔한 플러그}}

프로그램의 첫 번째 줄에서 x를 포함하여 ASCII 값 때문에 72처럼 취급되는 숫자를 합산합니다. 그러나 우리가 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

우리가 방금 9로 수정했다면, 우리는 원하기 때문에 잘못된 숫자로 남겨질 것 9 - (sum % 9)입니다. 그러나 우리는 9\-9 보다 나머지를 빼는 것 보다 더 잘 할 수 있습니다 . 모딩하기 전에 합계를 음수로 9로 만들면 9 - (sum % 9)일부 통역사 와 동등한 긍정적 인 결과를 얻습니다 . 이를 위해서는 TIO에서 유일하게 Befunge 93 및 98에 PyFunge 인터프리터를 사용해야합니다. 나머지는 0과 8 대신 -8과 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 바이트

나는 ?결석 숫자를 나타내는 데 사용할 필요가 없다는 것을 깨달았 으므로 48을 빼고 9의 배수를 사용 x
했습니다 3+.

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

온라인으로 사용해보십시오!

사용 x 그것의 ASCII 값이 48을 뺀 9의 배수이기 때문에, 누락 된 자리에 (그리고 그것의 좋은 일반적 수학 변수로 사용하기 때문에).

종료 코드를 통한 출력 ( q보다 1 바이트 짧기 때문에 .@)
출력0 누락 된 숫자가 0 또는 9 일 수있는 경우 합니다.

아래 설명 된 이유로 PyFunge 인터프리터에서만 작동합니다.

설명

프로그램의 첫 번째 줄 x에서 ASCII 값으로 인해 72로 취급되는을 포함하여 숫자를 합산합니다 . 그러나 우리가 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

우리가 방금 9로 수정했다면, 우리는 원하기 때문에 잘못된 숫자로 남겨질 것 9 - (sum % 9)입니다. 그러나, 우리는보다 더 잘 할 수 9\-9에서 나머지를 뺄 것이다, 우리가 9 모딩 전에 합계 부정을 할 경우, 우리는 동등 긍정적 인 결과를 얻을 것이다 9 - (sum % 9) 약간의 통역 인을 . 이를 위해서는 TIO에서 유일하게 Befunge 93 및 98에 PyFunge 인터프리터를 사용해야합니다. 나머지는 0과 8 대신 -8과 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을 의미하거나 0또는 9.

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

루비 , 46 , 41 바이트

@Unihedron 덕분에 -5

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

온라인으로 사용해보십시오!

Befunge-93, 28 27 19 18 바이트

신용 가야한다 Mistah 피긴스 누구의 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 (시작 총계)에서 빼고, 누락 된 숫자 (ASCII *-3) 에서 추가 39를 뺍니다 . 다시 3 빼기 39는 9의 배수이므로 9로 수정하면 취소됩니다.

결국 우리는 모든 숫자의 음수 합계, mod 9와 plus 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하여를 현재 숫자 로 바꾸고 $_mod 9를 얻습니다 %9. 따라서 9가 균등하게 나누면 0이됩니다. 우리는 Boolean-not을 취합니다. 이것은 0을 진실로 바꾸고 그 밖의 모든 것을 거짓으로 바꾸어 Where-Object 절을 충족시킵니다. 이러한 결과는 파이프 라인에 남아 있으며 출력은 암시 적입니다.

하스켈 , 35 바이트

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

온라인으로 사용해보십시오!

망막 , 35 34 25 바이트

(가) 경우 ?가 될 수있다 0 or 9, 그 결과로서 도시된다 9.

.
$*
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 bytes

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

Try it online!

Doesn't care what character signifies the missing digit as long as it isn't a digit.

Tcl, 53 bytes

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

As with other answers, this is made shorter by not explicitly saying “0 or 9”.
Instead, a result of “9” means either 0 or 9.

Try it online!

Explanation

It works pretty simply. It employs a regular expression to:

• split the argument into individual digits
• eliminate any question mark(s) non-digit(s)
• interleave the digits with plus signs

It then evaluates 9 - (sum_of_digits mod 9) to arrive at a final value in 1..9, which it then puts.

The leading 0 (in 0$argv) is required just in case the question mark comes first in the input; a leading plus sign in the transformed sequence is not a problem for expr.

Pyth, 8 bytes

%_iz19 9

Try it online!

Uses I instead of ?.

• Convert to base 19.
• Negate.
• 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