Tôi có phải là số tự không?

31

Một số tự (còn gọi là số Colombia hoặc Devlali) là một số tự nhiên, xnơi phương trình n + <digit sum of n> = xkhông có giải pháp cho bất kỳ số tự nhiên n. Ví dụ, 21 không phải là một số tự, như n = 15kết quả trong 15 + 1 + 5 = 21. Mặt khác, 20 là một số tự, vì không nthể tìm thấy nó thỏa mãn một đẳng thức như vậy.

Vì định nghĩa này tham chiếu tổng số, nó phụ thuộc vào cơ sở. Đối với mục đích của thử thách này, chúng tôi sẽ chỉ xem xét các số tự cơ bản 10, là chuỗi A003052 trong OEIS. Số tự nhị phân ( A010061 ) và cơ sở 100 ( A283002 ) cũng đã được ghi lại.

Các thách thức

Cho một số nguyên dương xlàm đầu vào, xuất giá trị trung thực nếu xlà số tự trong cơ sở 10 và giá trị falsey khác. Để làm rõ các giá trị trung thực và falsey, hãy tham khảo bài đăng meta này về chủ đề này .

Bạn có thể viết một chương trình hoặc chức năng đầy đủ, đầu vào và đầu ra có thể được cung cấp trên bất kỳ kênh thông thường nào. Tất nhiên, sơ hở là bị cấm.

Đây là môn đánh gôn , vì vậy câu trả lời của bạn (tính bằng byte) càng ngắn càng tốt!

Các trường hợp thử nghiệm

Sự thật:

1
3
5
7
9
20
31
86
154
525

Falsey:

2
4
6
8
10
15
21
50
100
500

Liên kết hộp cát

Bảng xếp hạng

Dưới đây là Stack Snippet để tạo cả bảng xếp hạng thông thường và tổng quan về người chiến thắng theo ngôn ngữ.

Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu câu trả lời của bạn bằng một tiêu đề, sử dụng mẫu Markdown sau:

# Language Name, N bytes

nơi Nlà kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Nếu ở đó bạn muốn bao gồm nhiều số trong tiêu đề của mình (ví dụ: vì điểm của bạn là tổng của hai tệp hoặc bạn muốn liệt kê riêng các hình phạt cờ phiên dịch), hãy đảm bảo rằng điểm thực tế là số cuối cùng trong tiêu đề:

# Perl, 43 + 2 (-p flag) = 45 bytes

Bạn cũng có thể đặt tên ngôn ngữ thành liên kết sau đó sẽ hiển thị trong đoạn trích bảng xếp hạng:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Hiển thị đoạn mã

code-golf  math  decision-problem 
— Sok
nguồn
Dường như có một số cuộc thảo luận / bất đồng về kết quả đầu ra hợp lệ, vì vậy tôi nghĩ rằng tôi đã không rõ ràng về những gì tôi dự định. Tôi đã thêm một câu mà hy vọng sẽ làm sáng tỏ mọi thứ, đề cập đến bài đăng meta này . Xin lỗi nếu tôi đã gây ra bất kỳ nhầm lẫn về điều này!
— Sok
Không gây ra nhiều nhầm lẫn, nhưng tôi nghĩ rằng cuộc thảo luận này có liên quan đến lý do tại sao có một số nhầm lẫn. Vui lòng xem xét điều này khi thực hiện các thách thức trong tương lai, vì có thể khó đăng bài bằng các ngôn ngữ không có cấu trúc if / other nếu bạn sử dụng sự đồng thuận cũ.
— FryAmTheEggman
@FryAmTheEggman I hadn't realised the consensus had shifted, I feel like a numpty now :/ Still, I've already added one clarification now, it seems wrong to change it again. I'll just bear it in mind for the next challenge I post. Thanks
— Sok
2
I am not any kind of number! I am a free man!
— David Richerby
1
@DavidRicherby *sends white ball after you*
— Sok

Câu trả lời:

7

Java (JDK 10), 84 bytes

i->{for(int n=i;i-->1;)i|=((""+i).chars().map(x->x-48).sum()+i^n)-1>>-1;return~i<0;}

Try it online!

Explanation

i->{                                    // IntPredicate
  for(int n=i;i-->1;)                   //  for each number below n
    i|=(                                //   keep the sign of
      (""+i).chars().map(x->x-48).sum() //    sum of digits
      +i                                //    plus the number
      ^n                                //    xor n (hoping for a zero)
     )-1>>-1;                           //    changing that into a negative number if equals to zero
  return~i<0;                           //  return i>=0
}

Credits

— Olivier Grégoire
nguồn
1
-1 byte: n->{int i=n,r=0;for(;i-->0;)r=(""+i).chars().map(x->x-48).sum()+i==n?1:r;return r<1;}
— Kevin Cruijssen
2
84 bytes: i->{for(int n=i;i-->1;)i|=((""+i).chars().map(x->x-48).sum()+i^n)-1>>-1;return~i<0;}
— Nevay
5

05AB1E, 8 bytes

LD€SO+ÊW

Try it online! or as a Test suite

Explanation

L          # push range [1 ... input]
 D         # duplicate
  €S       # split each number into a list of digits
    O      # sum digit lists
     +     # add (n + digitSum(n))
      Ê    # check for inequality with input
       W   # min
— Emigna
nguồn
5

Brachylog, 12 bytes

¬{⟦∋Iẹ+;I+?}

Try it online!

Explanation

¬{         }    Fails if succeeds, suceeds if fails:
  ⟦∋I             I ∈ [0, ..., Input]
    Iẹ+           The sum of the elements (i.e. digits) of I...
       ;I+?       ... with I itself results in the Input
— Fatalize
nguồn
1
Is false. a truthy value by any objective method in a way that true. is not? I for one don't think so, and it looks like that would be supported by the meta consensus
— Sok
1
@Sok I added 3 uninteresting bytes to adress your concerns.
— Fatalize
5

C (gcc), 70 67 65 bytes

i,r,d,j;f(n){for(r=i=n;d=j=--i;r*=d!=n)for(;j;j/=10)d+=j%10;i=r;}

Try it online!

To shave off another 2 bytes, the truthy value returned is no longer 1, but the number itself.

— gastropner
nguồn
4

Octave, 49 47 44 bytes

@(x)arrayfun(@(k)k+sum(num2str(k)-48)-x,1:x)

Try it online!

Explanation:

Trying to do the operation on a range is cumbersome and long, since num2str returns a string with spaces as separators if there are more than input number. Subtracting 48 would therefore give something like: 1 -16 -16 2 -16 -16 3 -16 -16 4 for an input range 1 ... 4. Getting rid of all the -16 takes a lot of bytes.

Therefore, we'll do this with a loop using arrayfun. For each of the numbers k = 1 .. x, where x is the input, we add k and its digit sum, and subtract x. This will return an array of with the result of that operation for each of the numbers in k. If any of the numbers in the array is a zero, the number is not a self number.

For inputs 20 and 21, the outputs are:

20:  -18, -16, -14, -12, -10, -8, -6, -4, -2, -9, -7, -5, -3, -1, 1, 3, 5, 7, 9, 2
21:  -19, -17, -15, -13, -11, -9, -7, -5, -3, -10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 1, 3

There are only non-zero elements for input 20, and at least one non-zero element for input 21. That means that 20 is a self number, and 21 is not.

Octave treats an array with at least one zero as false, as can be seen in the TIO-link.

— Stewie Griffin
nguồn
4

MATL, 11 bytes

t:tFYA!Xs+-

The output is a non-empty array, which is truthy if all its entries are non-zero, and falsy if it contains one or more zeros.

Try it online! Or verify all test cases, including truthiness/falsihood test.

Explanation

Consider input n = 10 as an example.

t       % Implicit input, n. Duplicate
        % STACK: 10, 10
:       % Range
        % STACK: 10, [1 2 3 4 5 6 7 8 9 10]
t       % Duplicate
        % STACK: 10, [1 2 3 4 5 6 7 8 9 10], [1 2 3 4 5 6 7 8 9 10]
FYA!    % Convert to base 10 digits and transpose
        % STACK: 10, [1 2 3 4 5 6 7 8 9 10], [0 0 0 0 0 0 0 0 0 1
                                              1 2 3 4 5 6 7 8 9 0]
Xs      % Sum of each column
        % STACK: 10, [1 2 3 4 5 6 7 8 9 10], [1 2 3 4 5 6 7 8 9 1]
+       % Add, element-wise
        % STACK: 10, [2 4 6 8 10 12 14 16 18 11]
-       % Subtract, element-wise
        % STACK: [8 6 4 2 0 -2 -4 -6 -8 -1]
        % Implicit display
— Luis Mendo
nguồn
3

APL (Dyalog), 14 bytes

~⊢∊⍳+(+/⍎¨∘⍕)¨∘⍳

Try it online!

How?

               ⍳   range
     (  ⍎¨∘⍕)      digits
     (+/    )      digit sums
   ⍳+              vectorized addition with the range
 ⊢∊                is the input included?
~                  negate
— Uriel
nguồn
that's 16 bytes. to make them 15: +/⍎¨∘⍕ -> #+.⍎⍕
— ngn
3

Jelly, 6 bytes

ḟDS+Ɗ€

For input n, this returns [n] if n is a self number, [] if not.

Try it online!

How it works

ḟDS+Ɗ€  Main link. Argument: n

     €  Call the link to the left for each k in [1, ..., n].
    Ɗ     Drei; combine the three links to the left into a monadic chain.
 D          Decimal; map k to the array of its digits in base 10.
  S         Take the sum.
   +        Add k to the sum of the k's digits.
ḟ       Filterfalse; promote n to [n], then remove all elements that appear in the
        array to the right.
        This returns [n] if the array doesn't contain n, [] if it does.
— Dennis
nguồn
What encoding packs these six characters into only six bytes?
— WGroleau
1
Jelly uses a custom code page.
— Dennis
3

J, 28, 24, 22 21 bytes

-1 byte thanks to Conor O'Brien

-2 byts thanks to ngn

$@-.(+1#.,.&.":)"+@i.

Try it online!

Explanation:

i. a list 0 .. n-1

( )"+ for each item in the list

.,.&.": convert it to a list of digits,

1# find their sum

+ and add it to the item

$@-. exclude the list from the argument and find the shape

— Galen Ivanov
nguồn
1
I realize this is an old post, but "0 i. can be "+i. (-1 byte).
— Conor O'Brien
1
@ConorO'Brien Thank you! I think I didn't know this kind of golfs back then; now I use it (when I remember :) )
— Galen Ivanov
1
-.@e. -> $@-.
— ngn
@ngn Thank you, really nice!
— Galen Ivanov
1
@GalenIvanov also [:( )"+i. -> ( )"+@i.
— ngn
2

Python 2, 70 66 Bytes

lambda x:[i for i in range(x)if i+sum([int(j)for j in`i`])==x]==[]

EDIT: -4 thanks to @user56656

— sonrad10
nguồn
1
in python2 you can use `i` instead of str(i) to save 4 bytes.
— Wheat Wizard
@user56656 thanks, I didn't know about that
— sonrad10
1
You can drop the [ and ] inside the sum
— Mr. Xcoder
lambda x:[i for i in range(x)if i+sum(map(int,`i`))==x]==[]
— B. Eckles
lambda x:all(i+sum(map(int,`i`))-x for i in range(x))
— B. Eckles
2

Pyth, 8 bytes

!/m+sjdT

Test suite.

If swapping truthy / falsy values is allowed, then we can drop the ! and get 7 bytes instead. One of Sok's suggestions helped me golf 2 bytes.

Explanation

!/m+sjdT – Full program. Takes an input Q from STDIN, outputs either True or False.
  m      – Map over the range [0 ... Q) with a variable d.
     jdT – Convert d to base 10.
    s    – Sum.
   +     – And add the sum to d itself.
 /       – Count the occurrences of Q in the result.
!        – Negate. Implicitly output the result.
— Mr. Xcoder
nguồn
I had .AmnQ+dsjdT, I had no idea about /. I've not used Pyth properly in a long time it seems! +1
— Sok
@Sok / basically counts the occurrences of an element in a list. I can also use }, which tests whether an object appears in a list, but I think that's the same byte count.
— Mr. Xcoder
I think the S isn't required - input will be a positive integer, so having 0 in the mapping list won't be a problem? At least, it seems to work for the given test cases.
— Sok
@Sok Great, you're right! I shaved off one more byte thanks to this.
— Mr. Xcoder
How does +sjdT add sjdT to d? I've never seen anything like that
— RK.
2

Perl 6, 39 33 bytes

{!grep $_,map {$_+[+] .comb},^$_}

Try it out!

A bare block with implicit single parameter, called thus:

say {!grep $_,map {$_+[+] .comb},^$_}(500);
> False
say {!grep $_,map {$_+[+] .comb},^$_}(525);
> True

Since n + digits(n) >= n, we can just calculate the Colombian number for all the numbers up to our query value and see if any of them match. So this calculates the Colombian number for a given input:

{$_ + [+] .comb}

Which we apply to all the values up to our target:

(^$_).map({$_+[+] .comb})

But we only care whether any of them match, not what those values are, so as pointed out by @nwellenhof, we can grep:

grep $_, map {$_+[+] .comb}, ^$_

The rest is just coercion to bool and wrapping in a block.

39 bytes

{!((^$_).map({$_+[+] .comb}).any==$_)}

TIO test link provided by @Emigna

@nwellenhof pointed out that using grep would save 6 bytes!

— Phil H
nguồn
1
Cool solution! You could add a TIO link for testing purposes.
— Emigna
1
— nwellnhof
— Jo King
2

Python 3, 60, 56, 55, 54 bytes

lambda x:{x}-{n+sum(map(int,str(n)))for n in range(x)}

Try it online!

-4 using all inverse instead of any
-1 by changing != to ^ by @jonathan-allan
-1 by using sets by @ovs

— Rick Rongen
nguồn
2

Japt -d!, 6 bytes

N¥U+ìx

Try it

Original, 8 bytes

Returns the input number for truthy or 0 for falsey. If only the empty array were falsey in JavaScript, this could be 7 bytes.

ÂNkUÇ+ìx

Try it

Explanation

             :Implicit input of integer U
   UÇ        :Generate the range [0,U) and pass each Z through a function
      ì      :  Digits of Z
       x     :  Reduce by addition
     +       :  Add to Z
  k          :Remove the elements in that array
 N           :From the array of inputs
            :Bitwise NOT NOT (~~), casts an empty array to 0 or a single element array to an integer

Alternative

Ç+ìxÃe¦U

Try it

             :Implicit input of integer U
Ç            :Generate the range [0,U) and pass each Z through a function
  ì          :  Digits of Z
   x         :  Reduce by addition
 +           :  Add to Z
    Ã        :End function
     e       :Every
      ¦U     :  Does not equal U
— Shaggy
nguồn
1

Retina, 55 bytes

.+
*
Lv`_+
_+
$&$.&
^_+
$&¶$&
\d
*
Cms`^(_+)\b.*¶\1\b
0

Try it online! Link includes test cases. Explanation:

.+
*

Convert input x to unary.

Lv`_+

Create a range from x down to 1.

_+
$&$.&

Suffix the decimal value of each n to its unary value.

^_+
$&¶$&

Make a copy of x.

\d
*

Convert each decimal digit of n to unary, thus adding the digits to the existing copy of n.

Cms`^(_+)\b.*¶\1\b

Check whether x appears in any of the results.

0

Invert the result.

— Neil
nguồn
1

JavaScript (ES6), 52 51 bytes

Saved 1 byte thanks to @l4m2

Returns 0 or 1.

n=>(g=k=>k?eval([...k+'k'].join`+`)-n&&g(k-1):1)(n)

Try it online!

— Arnauld
nguồn
n=>(g=k=>k?n-eval([...k+'k'].join`+`)&&g(k-1):1)(n)
— l4m2
1

Retina, 24 bytes

.+
*

$.`¶$`
\d
*
D`
.\z

Try it online!

Could be 18 bytes with input given in unary, but the other Retina answer uses decimal as well, so I figured using decimal would make for a fairer comparison.

Explanation

.+
*

Convert input to unary, using _ as the unary digit.


$.`¶$`

At each position in the string (i.e. beginning, end, and between every pair of characters), insert: $.`, the length of the prefix (or the zero-indexed position of the match), , a linefeed, $`, the prefix itself (i.e. a unary representation of the zero-indexed position). E.g. if the input was 3 and we'd have the unary representation ___, then this would result in:

0
_1
__2
___3
___

In other words, we get one line for each number from 0 to the input (inclusive), which holds both a unary and a decimal representation of that number.

\d
*

We convert each digit to unary, which effectively computes the digit sum on each line and adds it to the number itself (all in unary).

D`

Deduplicate lines. This doesn't actually delete duplicate lines but just clears them to empty lines. So if any number from 0 to the input plus its digit sum is equal to the input, the last line will get cleared. Otherwise, the last line remains in place.

.\z

Check whether there's still a character on the last line. We can't use $, because that also matches in front of a trailing linefeed (which is exactly where we don't want to look).

— Martin Ender
nguồn
1

Bash + GNU Coreutils, 91 Bytes

Returns truthy or falsy.

e=1;for((i=1;i<=$1;i++));{ [ $(bc<<<`grep -o . <<<$i|tr '\n' +`$i) -eq $1 ]&&e=0; };exit $e
— rexkogitans
nguồn
1

Kotlin, 48 bytes

x->(1..x).all{v->"$v".sumBy{it.toInt()-48}+v!=x}

Try it online!

Explanation:

(1..x)      // Range of numbers from 1 to x
.all{v->    // Function expression that checks if ALL values evaluate to tru
"$v"        // Convert the value into a string
.sumBy{it.toInt()-48} // For each character, get the ASCII char value, subtract 48 in order to get it back to the numerical value, and then sum it up
+v          // Add the original number
!=x}        // Ensure that it does not equal the input
— Makotosan
nguồn
1

Add++, 27 bytes

D,g,@,BDB+A+BK=
L,RbUABkºg!

Try it online!

How it works

D,g,@,		; Create a monadic function 'g'
		; Example argument:		[15]
	BD	; Digits;		STACK = [[1 5]]
	B+	; Sum;			STACK = [6]
	A+	; Add argument;		STACK = [21]
	BK=	; Equals input;		STACK = [1]

L,		; Create a lambda function
		; Example argument:		[21]
	RbUABk	; Push range;		STACK = [1 2 3 ... 19 20 21]
	ºg	; Any true from 'g';	STACK = [1]
	!	; Logical NOT;		STACK = [0]
— caird coinheringaahing
nguồn
1

Stax, 8 bytes

Å8avj╒Éπ

Run and debug it

Explanation

ASCII equivalent:

{cE+|+x=f!
{       f     Filter [1..input] with block
 cE           Decimal digits of current value
   +|+        Sum of digits and the current value
      x=      Equals input
         !    Logical not, maps empty array to 1 and non-empty array to 0

fcE+|+x= is a Stax program that outputs all numbers whose sum of digits added to itself equals the input. For example for 101 the output would be 91 and 100, each on a separate line.

Run and debug it

— Weijun Zhou
nguồn
1

Pyt, 7 bytes

ĐřĐŚ+∈¬

Try it online!

If swapping truthy/falsy values is allowed, then the ¬ at the end can be dropped for 6 bytes.

Explanation:

        Implicit input
Đ       Duplicate input
ř       Get [1,2,...,input]
Đ       Duplicate the top of the stack
Ś       Get the sum of the digits of each element in the array
+       Add the top two items on the stack element-wise
∈       Is the input in the list?
¬       Negate the top of the stack
        Implicit print
— mudkip201
nguồn
1

J, 20 bytes

#@-.i.+1#.10#.inv i.

Try it online!

                  i.     Range [0,n-1]
          10#.inv        To base 10
       1#.               Sum the digits
    i.+                  Plus the corresponding number
  -.                     Remove from the input, leaves an empty list if it was a self number.
#@                       An empty list is truthy, so return the length instead.
— FrownyFrog
nguồn
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.