Người dùng PPCG và mod được bầu, @Dennis vừa trở thành người dùng thứ hai kiếm được hơn 100 nghìn đại diện!

Đây là một ý tưởng hoàn toàn nguyên bản, mà tôi không nhận được từ bất kỳ ai khác , nhưng hãy thực hiện một thử thách dựa trên ID người dùng của anh ấy, 12012như một sự tôn vinh!

Nhìn vào nó, bạn sẽ nhận thấy rằng có hai "phần" riêng biệt cho ID của mình.

12

và

012

Cả hai phần này đều có tới 3. Đó là một tài sản khá thú vị.

Chúng ta hãy định nghĩa "số Dennis 2.0" là bất kỳ số nguyên dương nào trong đó mọi dãy số cực đại của các chữ số tăng nghiêm ngặt đều có cùng một số. Ví dụ,

123

là số Dennis 2.0 vì chỉ có một danh sách con tối đa gồm các chữ số tăng nghiêm ngặt và nó tổng hợp thành 6. Ngoài ra, 2.846.145 cũng là số Dennis 2.0 vì ba danh sách con tối đa của các chữ số tăng, cụ thể là

28
46
145

Tất cả tổng hợp để 10. Ngoài ra, các số chỉ lặp lại cùng một chữ số phải là số Dennis 2.0 vì, chẳng hạn, 777có thể được chia thành

7
7
7

trong đó rõ ràng tất cả tổng cộng đến bảy.

Một số ví dụ như 42là không một số Dennis 2.0, kể từ khi nó được chia thành

4
2

mà rõ ràng không tổng hợp với cùng một số.

Các thách thức

Bạn phải viết chương trình hoặc hàm để xác định xem một số đã cho có phải là số Dennis 2.0 hay không. Bạn có thể lấy đầu vào và đầu ra ở bất kỳ định dạng đầu vào hợp lý nào, ví dụ như một chuỗi, như một số, từ một tệp, đối số funtion / return, từ STDIN / STDOUT, v.v. và sau đó trả về giá trị trung thực nếu số này là Dennis 2.0 số và giá trị giả nếu không. Để tham khảo, đây là mỗi số Dennis 2.0 lên tới 1.000:

1
2
3
4
5
6
7
8
9
11
12
13
14
15
16
17
18
19
22
23
24
25
26
27
28
29
33
34
35
36
37
38
39
44
45
46
47
48
49
55
56
57
58
59
66
67
68
69
77
78
79
88
89
99
101
111
123
124
125
126
127
128
129
134
135
136
137
138
139
145
146
147
148
149
156
157
158
159
167
168
169
178
179
189
202
222
234
235
236
237
238
239
245
246
247
248
249
256
257
258
259
267
268
269
278
279
289
303
312
333
345
346
347
348
349
356
357
358
359
367
368
369
378
379
389
404
413
444
456
457
458
459
467
468
469
478
479
489
505
514
523
555
567
568
569
578
579
589
606
615
624
666
678
679
689
707
716
725
734
777
789
808
817
826
835
888
909
918
927
936
945
999

Áp dụng sơ hở tiêu chuẩn và câu trả lời ngắn nhất được đo bằng byte sẽ thắng!

Thạch, 13 12 byte

1 byte nhờ @Dennis.

DIṠ’0;œṗDS€E

Hãy thử trực tuyến!

Giải trình

DIṠ’0;œṗDS€E    Main link. Argument: N
D               Convert N to its digits.
 I              Find the differences between the elements.
  Ṡ             Find the sign of each difference. This yields 1 for locations where the
                list is strictly increasing and 0 or -1 elsewhere.
   ’            Decrement. This yields 0 for locations where the list is strictly
                increasing and -1 or -2 elsewhere.
    0;          Prepend a 0.
        D       Get another list of digits.
      œṗ        Split the list of digits at truthy positions, i.e. the -1s and -2s.
         S€     Sum each sublist.
           E    Check if all values are equal.

JavaScript (ES6), 72 70 byte

Lấy một chuỗi làm đầu vào. Trả về giá trị sai hoặc giá trị trung thực (có thể là số).

Đó là sử dụng biểu thức chính quy để chuyển đổi một chuỗi đầu vào như "2846145":

"(a=2+8)&&(a==4+6)&&(a==1+4+5)"

Sau đó gọi eval()biểu thức này.

let f =

n=>eval(n.replace(/./g,(v,i)=>(v>n[i-1]?'+':i?')&&(a==':'(a=')+v)+')')

console.log(f("101"));
console.log(f("102"));
console.log(f("777"));
console.log(f("2846145"));

Python, 50 byte

r='0'
for d in input():r=d+'=+'[r<d]*2+r
1/eval(r)

Yêu input()cầu đánh giá một chuỗi, do đó, đầu vào cần các trích dẫn xung quanh trong Python 2. Đầu ra là thông qua mã thoát , trong đó 0 biểu thị thành công (trung thực) và 1 chỉ ra thất bại (giả mạo).

Kiểm tra nó trên Ideone .

Làm thế nào nó hoạt động

Chúng tôi khởi tạo r đến chuỗi 0 và lặp lại trên tất cả các chữ số d trong đầu vào.

• Nếu d lớn hơn chữ số đầu tiên của r (ban đầu là 0 , sau đó bằng giá trị trước đó của d ), hãy r<dước lượng thành True và '=+'[r<d]*2mang lại ++.

• Nếu d nhỏ hơn chữ số đầu tiên của r , '=+'[r<d]*2sản lượng ==.

• Nếu d bằng chữ số đầu tiên của r , r sẽ dài hơn chuỗi singleton d , do đó '=+'[r<d]*2mang lại một lần nữa ==.

Trong mọi trường hợp, chữ số d và hai ký tự được tạo sẽ được thêm vào r .

Khi tất cả các chữ số đầu vào đã được xử lý, hãy eval(r)đánh giá biểu thức được tạo.

• Nếu đầu vào bao gồm một chuỗi các chữ số (dương) tăng nghiêm ngặt, biểu thức sẽ ước lượng thành tổng của chúng.

  Ví dụ, số nguyên 12345 dẫn đến biểu thức 5++4++3++2++1++0, mang lại 15 khi được ước tính. Lưu ý rằng mỗi giây + là một phép cộng đơn , vì vậy nó không ảnh hưởng đến kết quả. Chia 1 cho 15 là hợp lệ (kết quả không quan trọng); chương trình thoát bình thường.

• Nếu đầu vào bao gồm hai chuỗi chữ số tăng nghiêm ngặt, biểu thức bao gồm một so sánh đơn giản.

  Ví dụ: số nguyên 12012 dẫn đến biểu thức 2++1++0==2++1++0, mang lại True khi được đánh giá do cả hai thuật ngữ có tổng 3 . Chia 1 cho True ( 1 ) là hợp lệ (kết quả không quan trọng); chương trình thoát bình thường.

  Mặt khác, số nguyên 12366 dẫn đến biểu thức 6==6++3++2++1++0, kết quả là Sai khi được đánh giá do các số hạng có tổng 6 và 12 . Chia 1 cho Sai ( 0 ) làm tăng ZeroDivisionError ; chương trình thoát với một lỗi.

• Nếu đầu vào bao gồm ba hoặc nhiều chuỗi chữ số tăng nghiêm ngặt, biểu thức bao gồm một phép so sánh chuỗi , trả về True khi và chỉ khi tất cả các phép so sánh liên quan trả về True .

  Ví dụ: số nguyên 94536 dẫn đến biểu thức 6++3==5++4==9++0, mang lại True khi được đánh giá do tất cả các số hạng có tổng 9 . Như trước đây, chương trình thoát bình thường.

  Mặt khác, số nguyên 17263 dẫn đến biểu thức 3==6++2==7++1++0, kết quả là Sai khi được đánh giá do các số hạng có tổng 3 , 8 và 8 . Như trước đây, chương trình thoát với một lỗi.

Brachylog , 13 byte

~c@e:{<+}a!#=

Hãy thử trực tuyến!

Giải trình

~c               Find a list of integers which when concatenated result in the Input
  @e             Split the integers into lists of digits
    :{<+}a       Each list of digit is stricly increasing, and compute its sum
          !      Discard all other choice points (prevents backtracking for smaller sublists)
           #=    All sums must be equal

~c sẽ thống nhất với các danh sách con lớn nhất đầu tiên.

Pyke, 18 byte

mb$1m>0R+fMbms}lt!

Hãy thử nó ở đây!

mb                 -         map(int, input)
  $                -        delta(^)
   1m>             -       map(^, 1>i)
      0R+          -      [0]+^
         f         -     input.split_at(^) 
          Mb       -    deep_map(int, ^)
            ms     -   map(sum, ^)
              }    -  uniquify(^)
               lt! - len(^) == 1

PowerShell v2 +, 100 64 61 byte

-join([char[]]$args[0]|%{("+$_","-eq$_")[$_-le$i];$i=$_})|iex

Một lót một chữ, vì đây là tất cả một đường ống. Đưa đầu vào dưới dạng một chuỗi $args[0]. Các vòng lặp thông qua nó như là một char-ray, mỗi lần lặp đặt một phần tử hiện tại với một +hoặc -eqở phía trước của nó trên đường ống dựa trên việc giá trị hiện tại có phải là giá trị -lso với egiá trị trước đó hay không $i. Các chuỗi đó được -joined với nhau và được chuyển sang iex(viết tắt Invoke-Expressionvà tương tự eval. Ví dụ, đối với đầu vào, 2846145điều này sẽ được đánh giá là +2+8-eq4+6-eq1+4+5, đó là True.

Boolean đó được để lại trên đường ống dẫn và True/ Falseđược viết hoàn toàn khi hoàn thành chương trình.

NB - đối với đầu vào một chữ số, chữ số kết quả được để lại trên đường ống, là giá trị trung thực trong PowerShell.

Ví dụ

PS C:\Tools\Scripts\golfing> 2846145,681,777,12366,2|%{"$_ -> "+(.\dennis-number-20.ps1 "$_")}
2846145 -> True
681 -> False
777 -> True
12366 -> False
2 -> 2

GNU sed 217 hoặc 115

Cả hai đều bao gồm +1 cho -r

217:

s/./&,/g;s/^/,/g;:;s,0,,;s,2,11,;s,3,21,;s,4,31,;s,5,41,;s,6,51,
s,7,61,;s,8,71,;s,9,81,;t;s/(,1*)(1*)\1,/\1\2X\1,/;t;s/,//g
s,1X1(1*),X\1a,;t;/^1.*X/c0
/Xa*$/s,a*$,,;y,a,1,;/1X1/b;/1X|X1/c0
c1

Đưa đầu vào ở dạng thập phân bình thường

Hãy thử trực tuyến!

115:

s/^|$/,/g;:;s/(,1*)(1*)\1,/\1\2X\1,/;t;s/,//g
s,1X1(1*),X\1a,;t;/^1.*X/c0
/Xa*$/s,a*$,,;y,a,1,;/1X1/b;/1X|X1/c0
c1

Đưa đầu vào dưới dạng danh sách các chữ số được phân tách bằng dấu phẩy. ví dụ 123sẽ là1,11,111

Hãy thử trực tuyến!

Perl, 38 + 3 ( -p) = 41 byte

-9 byte nhờ @TonMedel !

s%.%2x$&.(~$&le~$')%eg;$_=/^(2+1)\1*$/

Vì có một $', mã cần phải nằm trong một tệp để chạy. Vì vậy, -ptính cho 3 byte. Xuất ra 1 nếu số đó là số Dennis 2.0 hoặc chuỗi trống khác:

$ cat dennis_numbers.pl
s%.%2x$&.(~$&le~$')%eg;$_=/^(2+1)\1*$/
$ perl -p dennis_numbers.pl <<< "1
10
12315
12314"

JavaScript (ES6), 66 65 63 byte

Đã lưu 2 byte nhờ @ edc65

x=>[...x,p=t=z=0].every(c=>p>=(t+=+p,p=c)?(z?z==t:z=t)+(t=0):1)

Đưa đầu vào dưới dạng một chuỗi. Phiên bản cũ (chỉ hoạt động trong Firefox 30+):

x=>[for(c of(p=t=0,x))if(p>=(t+=+p,p=c))t+(t=0)].every(q=>q==+p+t)

Toán học, 38 byte

Equal@@Tr/@IntegerDigits@#~Split~Less&

Chức năng ẩn danh. Lấy một số làm đầu vào, và trả về Truehoặc Falselà đầu ra.

Brachylog 2, 10 byte, thách thức ngôn ngữ

ẹ~c<₁ᵐ!+ᵐ=

Hãy thử trực tuyến!

Về cơ bản, đây là thuật toán tương tự như câu trả lời của @ Fatalize (mà tôi đã không thấy cho đến sau khi tôi viết nó), nhưng được sắp xếp lại phần nào để làm cho nó trở nên golf hơn theo cú pháp của Brachylog 2.

Đây là một chương trình đầy đủ, trả về false.nếu đó không phải là số Dennis 2.0 hoặc truenếu có.

Giải trình

ẹ~c<₁ᵐ!+ᵐ=
ẹ           Interpret the input number as a list of digits
      !     Find the first (in default order)
 ~c           partition of the digits
   <₁ᵐ        such that each is in strictly increasing order
         =  Assert that the following are all equal:
       +ᵐ     the sums of each partition

Như thường lệ đối với một chương trình đầy đủ của Brachylog, nếu tất cả các xác nhận có thể được đáp ứng đồng thời, chúng ta sẽ nhận được một sự trở lại trung thực, nếu không thì là falsey. Thứ tự mặc định cho ~clà sắp xếp các phân vùng có ít phần tử hơn, dài hơn trước và trong Prolog (do đó là Brachylog), thứ tự mặc định được xác định bởi vị từ đầu tiên trong chương trình (sử dụng phần thứ hai làm tiebreak, v.v., ở đây, ~cchiếm ưu thế, bởi vì ẹlà xác định và do đó không có gì để đặt hàng).

MATL, 24 23 20 18 16 byte

Tjdl<vYsG!UlXQ&=

Trả về một sự thật của ma trận falsey

Hãy thử trực tuyến!

Ngoài ra, xin chúc mừng @Dennis!

Giải trình

T       % Push a literal TRUE to the stack
        %   STACK: {1}
j       % Explicitly grab the input as a string
        %   STACK: {1, '2846145'}
d       % Compute the difference between successive ASCII codes
        %   STACK: {1, [6 -4 2 -5 3 1]}
l<      % Find where that difference is less than 1
        %   STACK: {1, [0 1 0 1 0 0]}
v       % Prepend the TRUE value we pushed previously
        %   STACK: {[1 0 1 0 1 0 0]}
Ys      % Compute the cumulative sum. This assigns a unique integer label to
        % each set of increasing numbers
        %   STACK: {[1 1 2 2 3 3 3]}
G!U     % Grab the input as numeric digits
        %   STACK: {[1 1 2 2 3 3 3], [2 8 4 6 1 4 5]}
lXQ     % Compute the sum of each group of increasing digits
        %   STACK: {[10 10 10]}
&=      % Computes element-wise equality (automatically broadcasts). A
        % truthy value in MATL is a matrix of all ones which is only the case
        % when all elements are equal:
        %   STACK: {[1 1 1
        %            1 1 1
        %            1 1 1]}
        % Implicitly display the result

PHP, 108 105 92 byte

$p=-1;foreach(str_split("$argv[1].")as$d)$p>=$d?$r&&$s-$r?die(1):($r=$s)&$s=$p=$d:$s+=$p=$d;

lấy đầu vào từ đối số, thoát với số 0Dennis-2.0, với số 1khác.

phá vỡ

$p=-1;                              // init $p(revious digit) to -1
foreach(str_split("$argv[1].")as$d) // loop $d(igit) through input characters
                                    // (plus a dot, to catch the final sum)
    $p>=$d                              // if not ascending:
        ?$r                             // do we have a sum remembered 
        &&$s-$r                         // and does it differ from the current sum?
                ?die(1)                     // then exit with failure
                :($r=$s)&$s=$p=$d           // remember sum, set sum to digit, remember digit
        :$s+=$p=$d                      // ascending: increase sum, remember digit
    ;
// 

05AB1E , 18 byte

SD¥X‹X¸«DgL*ꥣOÙg

Giải trình

N = 12012 dùng làm ví dụ.

                    # implicit input N = 12012
S                   # split input number to list of digits  
                    # STACK: [1,2,0,1,2]
 D                  # duplicate
                    # STACK: [1,2,0,1,2], [1,2,0,1,2]
  ¥                 # reduce by subtraction
                    # STACK: [1,2,0,1,2], [1,-2,1,1]
   X‹               # is less than 1
                    # STACK: [1,2,0,1,2], [0,1,0,0]
     X¸«            # append 1
                    # STACK: [1,2,0,1,2], [0,1,0,0,1]
        DgL*        # multiply by index (1-indexed)
                    # STACK: [1,2,0,1,2], [0,2,0,0,5]
            ê       # sorted unique
                    # STACK: [1,2,0,1,2], [0,2,5]
             ¥      # reduce by subtraction
                    # STACK: [1,2,0,1,2], [2,3]
              £     # split into chunks
                    # STACK: [[1,2],[0,1,2]]
               O    # sum each
                    # STACK: [3,3]
                Ù   # unique
                    # STACK: [3]
                 g  # length, 1 is true in 05AB1E
                    # STACK: 1

Hãy thử trực tuyến!

Ruby 2.3, 56 byte

p !gets.chars.chunk_while(&:<).map{|a|eval a*?+}.uniq[1]

Hầu như chắc chắn không phải là cách tốt nhất để làm điều này, nhưng nó cho thấy một số tính năng ngôn ngữ tốt đẹp.

(Không dung nạp dòng mới, vì vậy hãy chạy như thế nào ruby dennis2.rb <<< '12012')

PHP, 144 byte

<?php preg_match_all("/0?1?2?3?4?5?6?7?8?9?/",$argv[1],$n);foreach($n[0]as$i)if(strlen($i)&&($a=array_sum(str_split($i)))!=$s=$s??$a)die;echo 1;

Tôi chắc chắn có một cách thông minh hơn (và ngắn hơn) để làm điều này nhưng nó sẽ làm ngay bây giờ.

Python 2, 69 byte

Đưa đầu vào dưới dạng một chuỗi.

lambda I:len(set(eval(reduce(lambda x,y:x+',+'[y>x[-1]]+y,I+' '))))<2

Giải trình:

Ví dụ 1201212012

Chuyển đổi sang danh sách các khoản tiền:

1+2,0+1+2,1+2,0+1+2,

Evals và chuyển đổi để thiết lập.

set([3])

Nếu độ dài của tập hợp là 1, tất cả các khoản tiền đều giống nhau.

JavaScript (ES6), 58

s=>![...s,z=x=p=0].some(c=>[c>p?0:z-=(x=x||z),z-=p=c][0])

Áp dụng mẹo hiếm khi hữu ích của tôi https://codegolf.stackexchange.com/a/49967/21348

Nó quét chuỗi char bằng cách xác định char chạy ký tự tăng dần, ở cuối mỗi rum nó kiểm tra xem tổng có luôn giống nhau không

• c: char hiện tại
• p: char trước
• z: tổng chạy, khi kết thúc một lần chạy sẽ được so sánh với ...
• x: tổng để so sánh với, lần đầu tiên được thực hiện đơn giản bằng z

Kiểm tra

f=
s=>![...s,z=x=p=0].some(c=>[c>p?0:z-=(x=x||z),z-=p=c][0])

function run()
{
  var i=I.value
  O.textContent = i + ' -> ' + f(i)
}

run()

test=`1 2 3 4 5 6 7 8 9 11 12 13 14 15 16 17 18 19 22 23 24 25 26 27 28 29 33 34 35 36 37 38 39 44 45 46 47 48 49 55 56 57 58 59 66 67 68 69 77 78 79 88 89 99 101 111 123 124 125 126 127 128 129 134 135 136 137 138 139 145 146 147 148 149 156 157 158 159 167 168 169 178 179 189 202 222 234 235 236 237 238 239 245 246 247 248 249 256 257 258 259 267 268 269 278 279 289 303 312 333 345 346 347 348 349 356 357 358 359 367 368 369 378 379 389 404 413 444 456 457 458 459 467 468 469 478 479 489 505 514 523 555 567 568 569 578 579 589 606 615 624 666 678 679 689 707 716 725 734 777 789 808 817 826 835 888 909 918 927 936 945 999`.split` `

numerr=0
for(i=1; i<1000; i++)
{
  v = i + '';
  r = f(v);
  ok = r == (test.indexOf(v) >= 0)
  if (!ok) console.log('Error',++numerr, v)
}  
if(!numerr) console.log('All test 1..999 ok')

<input id=I value=612324 type=number oninput='run()'>
<pre id=O>

Bình thường , 20 byte

Hai phiên bản

!t{sMcJjQThMx1<R0.+J
LS{b!t{sMhyI#I#./jQT

Hãy thử cái đầu tiên trực tuyến!

Hãy thử cái thứ hai trực tuyến!

Hồng ngọc 117 105 85 byte

# original (117):
j,k=0,?0;"#{i}".chars.group_by{|n|n>k||j=j+1;k=n;j}.values.map{|a|a.map(&:to_i).reduce(&:+)}.reduce{|m,n|n==m ?m:nil}

# inspired by PHP regexp approach (105):
"#{i}".scan(/0?1?2?3?4?5?6?7?8?9?/).map{|a|a.chars.map(&:to_i).reduce(&:+)}.reduce{|m,n|!n||n==m ?m:nil}

# some number comparison simplification (85):
!"#{i}".scan(/0?1?2?3?4?5?6?7?8?9?/).map{|a|a.chars.map(&:to_i).reduce(&:+)}.uniq[1]

Điều này sẽ trả về số nguyên của số dennis này hoặc nilnếu không phải là số dennis. Tất cả các số nguyên sẽ được coi là đúng trong ruby ​​cũng nilđược coi là sai. ilà số nguyên đang được kiểm tra.

Phiên bản thứ ba thực sự trở lại truevà false.

PS đã thử nghiệm để trả về 172 số nguyên từ 1 đến 1000 như trong câu trả lời.

APL, 23 byte

{1=≢∪+/↑N⊂⍨1,2>/N←⍎¨⍕⍵}

Giải trình:

• N←⍎¨⍕⍵: lấy các chữ số riêng lẻ trong đầu vào, lưu trữ trong N
• N⊂⍨1,2>/N: tìm danh sách con của các số tăng nghiêm ngặt trong N
• +/↑: tổng hợp từng danh sách con
• 1=≢∪: xem danh sách kết quả chỉ có một yếu tố duy nhất

Thêm ++ , 109 byte

D,g,@@#,BF1_B
D,k,@@#,bR$d@$!Q@BFB
D,f,@,BDdVÑ_€?1€_0b]$+€?dbLRBcB*BZB]GbL1+b]+qG€gd€bLÑ_0b]$+BcB]£k€¦+Ñ=1$ª=

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

$f$$g$$k$$f$

$f(x)$

$x$$1$$[4, 4, 4]$$0$$-1$$1$$0$$A$$0$$1$$0$

$[1, 2, ... length(A)]$$0$$A$$A'$$A'$$A'$$A''$

$g$$g$€$A''$

$g(x, y)$

$g(x, y)$$x := [1, 2, 0, 1, 2]$$y = 3$$3$$A''$$A$$1$$0$$x = 12012$$A'' = [3, 6]$$3$$A$$6$$x$

$g([1, 2, 0, 1, 2], 3)$[1 2 0 1 2 2]$[1, 2]$$g$

$g(x, y)$$y \in A''$$x := 12012$$g$

[[[1 2] [1 2 0 1 2]]]

$[2, 5]$$A'' - 1$$-$$0$$[0, 3]$$g$$B$

$k(x, n)$

$k$$[[1, 2], [3, 4], [5, 6]]$

$[[[1, 2], 0], [[1, 2, 0, 1, 2], 3]]$$k$$k([1, 2, 0, 1, 2], 3)$

$k(x, n)$$g$$n = 0$$[n, x, n]$$n = 0$$[[2, 1, 0, 1, 2], 3]$$n$$x$$x$$B$

$[0, 1, 2]$$[2, 1, 0]$

$k(x, n)$$(x, n) \in B$$1$