Użytkownik PPCG i wybrany mod, @Dennis właśnie został drugim użytkownikiem, który zarobił ponad 100 000 powtórzeń!

Jest to całkowicie oryginalny pomysł, którego nie dostałem od nikogo innego , ale zróbmy wyzwanie na podstawie jego identyfikatora użytkownika, 12012jako hołd!

Patrząc na to, zauważysz, że jego identyfikator ma dwie odrębne „sekcje”.

12

i

012

Obie te sekcje sumują się do 3. To całkiem interesująca właściwość.

Zdefiniujmy „liczbę Dennisa 2.0” jako dowolną liczbę całkowitą dodatnią, w której każda maksymalna podsekwencja ściśle rosnących cyfr sumuje się do tej samej liczby. Na przykład,

123

jest liczbą Dennisa 2.0, ponieważ istnieje tylko jedna maksymalna podlista ściśle rosnących cyfr i sumuje się do 6. Dodatkowo 2.846,145 to także liczba Dennisa 2.0, ponieważ trzy maksymalne podlisty rosnących cyfr, a mianowicie

28
46
145

Suma do 10. Ponadto liczby, które powtarzają tę samą cyfrę, muszą być liczbami Dennisa 2.0, ponieważ na przykład 777można je podzielić

7
7
7

które oczywiście wszystkie sumują się do siedmiu.

Liczba taka jak nie42 jest liczbą Dennis 2.0, ponieważ jest podzielona na

4
2

które oczywiście nie sumują się do tej samej liczby.

Wyzwanie

Musisz napisać program lub funkcję, aby ustalić, czy podana liczba jest liczbą Dennisa 2.0, czy nie. Możesz pobierać dane wejściowe i wyjściowe w dowolnym rozsądnym formacie wejściowym, np. Jako ciąg, jako liczba, z pliku, argumentów / return funkcji, z STDIN / STDOUT itp., A następnie zwrócić prawdziwą wartość, jeśli liczba ta to Dennis 2.0 liczba i wartość fałsz, jeśli nie jest. Dla porównania, oto każda liczba Dennis 2.0 do 1000:

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

Obowiązują standardowe luki, a najkrótsza odpowiedź mierzona w bajtach wygrywa!

Galaretka, 13 12 bajtów

1 bajt dzięki @Dennis.

DIṠ’0;œṗDS€E

Wypróbuj online!

Wyjaśnienie

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 bajtów

Pobiera ciąg jako dane wejściowe. Zwraca wartość false lub true (która może być liczbą).

Używa wyrażenia regularnego, aby przekształcić ciąg wejściowy, taki jak "2846145":

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

Następnie wywołuje eval()to wyrażenie.

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 bajtów

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

Oczekuje input()oceny na ciąg, więc dane wejściowe wymagają otaczania cudzysłowami w Pythonie 2. Dane wyjściowe są przesyłane za pomocą kodu wyjścia , gdzie 0 oznacza sukces (prawda), a 1 oznacza niepowodzenie (fałsz).

Przetestuj na Ideone .

Jak to działa

Inicjalizujemy r do ciągu 0 i iterujemy wszystkie cyfry d na wejściu.

• Jeśli d jest większe niż pierwsza cyfra r (początkowo 0 , a następnie równa poprzedniej wartości d ), r<docenia się na True i '=+'[r<d]*2daje ++.

• Jeśli d jest mniejsze niż pierwsza cyfra r , '=+'[r<d]*2daje ==.

• Jeśli d jest równe pierwszej cyfrze r , r będzie dłuższy niż ciąg singletonu d , więc '=+'[r<d]*2daje to ponownie ==.

We wszystkich przypadkach cyfra d i dwa wygenerowane znaki są dodawane do r .

Po przetworzeniu wszystkich cyfr wejściowych eval(r)ocenia wygenerowane wyrażenie.

• Jeśli dane wejściowe składają się z jednej ściśle rosnącej sekwencji (dodatnich) cyfr, wyrażenie wyraża się jako ich suma.

  Na przykład liczba całkowita 12345 powoduje wyrażenie 5++4++3++2++1++0, które daje 15 po ocenie. Pamiętaj, że każda sekunda + jest jednoznacznym plusem, więc nie wpływa na wynik. Dzielenie 1 przez 15 jest poprawne (wynik nie jest ważny); program kończy się normalnie.

• Jeśli dane wejściowe składają się z dwóch ściśle rosnących sekwencji cyfr, wyrażenie składa się z prostego porównania.

  Na przykład liczba całkowita 12012 powoduje wyrażenie 2++1++0==2++1++0, które daje wartość True po ocenie, ponieważ oba terminy mają sumę 3 . Dzielenie 1 przez True ( 1 ) jest poprawne (wynik nie jest ważny); program kończy się normalnie.

  Z drugiej strony liczba całkowita 12366 powoduje wyrażenie 6==6++3++2++1++0, które daje wartość Fałsz, gdy jest oceniana, ponieważ terminy mają sumy 6 i 12 . Dzielenie 1 przez False ( 0 ) podnosi ZeroDivisionError ; program kończy pracę z błędem.

• Jeśli dane wejściowe składają się z trzech lub więcej ściśle rosnących sekwencji cyfr, wyrażenie składa się z łańcuchowego porównania , które zwraca wartość True wtedy i tylko wtedy, gdy wszystkie zaangażowane porównania zwracają wartość True .

  Na przykład liczba całkowita 94536 powoduje wyrażenie 6++3==5++4==9++0, które daje wartość True po ocenie, ponieważ wszystkie terminy mają sumę 9 . Tak jak poprzednio program kończy się normalnie.

  Z drugiej strony liczba całkowita 17263 powoduje wyrażenie 3==6++2==7++1++0, które daje Fałsz, gdy jest oceniane, ponieważ terminy mają sumy 3 , 8 i 8 . Tak jak poprzednio, program kończy działanie z błędem.

Brachylog , 13 bajtów

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

Wypróbuj online!

Wyjaśnienie

~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 najpierw zjednoczy się z największymi podlistami.

Pyke, 18 bajtów

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

Wypróbuj tutaj!

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 bajtów

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

Dosłownie jednowarstwowy, ponieważ jest to jeden potok. Pobiera dane wejściowe jako ciąg $args[0]. Pętle przechodzą przez nią jako chartablicę, każda iteracja umieszcza bieżący element za pomocą a +lub -eqprzed nim na rurociągu w oparciu o to, czy bieżąca wartość jest -lmniejsza niż lub wyższa eod poprzedniej wartości $i. Te ciągi są -joinedytowane razem i przesyłane potokowo do iex(skrót od Invoke-Expressioni podobne do eval. Na przykład dla danych wejściowych 2846145zostanie to ocenione jako +2+8-eq4+6-eq1+4+5, co oznacza True.

To, że wartość logiczna jest pozostawiana w potoku i True/ Falsejest domyślnie zapisywana po zakończeniu programu.

NB - w przypadku wprowadzania jednocyfrowego cyfra wynikowa pozostaje w potoku, co jest prawdziwą wartością w programie PowerShell.

Przykłady

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 lub 115

Oba zawierają +1 dla -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

Pobiera dane w normalnym systemie dziesiętnym

Wypróbuj online!

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

Pobiera dane wejściowe jako rozdzieloną przecinkami listę cyfr w unarnych. np. 123byłoby1,11,111

Wypróbuj online!

Perl, 38 + 3 ( -p) = 41 bajtów

-9 bajtów dzięki @Ton Hospel !

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

Ponieważ istnieje $', kod musi znajdować się w pliku, aby go uruchomić. -pLiczy się więc 3 bajty. Zwraca 1, jeśli liczba jest liczbą Dennisa 2.0 lub pusty ciąg znaków w przeciwnym razie:

$ 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 bajtów

Zaoszczędzono 2 bajty dzięki @ edc65

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

Pobiera dane wejściowe jako ciąg. Stara wersja (działa tylko w przeglądarce Firefox 30+):

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

Mathematica, 38 bajtów

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

Funkcja anonimowa. Pobiera liczbę jako dane wejściowe i zwraca Truelub Falsedane wyjściowe.

Brachylog 2, 10 bajtów, wyzwanie dotyczące postdatacji języka

ẹ~c<₁ᵐ!+ᵐ=

Wypróbuj online!

Jest to w zasadzie ten sam algorytm, co odpowiedź @ Fatalize (której nie widziałem, dopóki nie napisałem tego), ale zmienił się nieco, aby uczynić go bardziej golfowym zgodnie ze składnią Brachylog 2.

Jest to pełny program, zwracany, false.jeśli nie jest to numer Dennis 2.0 lub truejeśli jest.

Wyjaśnienie

ẹ~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

Jak zwykle w przypadku pełnego programu Brachylog, jeśli wszystkie twierdzenia można spełnić jednocześnie, otrzymamy prawdziwy zwrot, w przeciwnym razie falsey. Domyślna kolejność ~cto sortowanie partycji z mniejszą liczbą dłuższych elementów w pierwszej kolejności, aw Prologu (a więc Brachylog), domyślna kolejność jest zdefiniowana przez pierwszy predykat w programie (użycie drugiego jako rozstrzygnięcia itd.; Tutaj ~cdominuje, ponieważ ẹjest deterministyczny i dlatego nie ma nic do zamówienia).

MATL, 24 23 20 18 16 bajtów

Tjdl<vYsG!UlXQ&=

Zwraca prawdę o matrycy falsey

Wypróbuj online!

Gratulacje @Dennis!

Wyjaśnienie

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 bajtów

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

pobiera dane wejściowe z argumentu, kończy na z 0liczbą Dennis-2.0, z 1innym.

awaria

$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 bajtów

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

Wyjaśnienie

N = 12012 użyty jako przykład.

                    # 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

Wypróbuj online!

Ruby 2.3, 56 bajtów

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

Niemal na pewno nie jest to najbardziej golfowy sposób na zrobienie tego, ale pokazuje kilka fajnych funkcji językowych.

(Nie toleruje nowej linii, więc uruchom jak ruby dennis2.rb <<< '12012')

PHP, 144 bajty

<?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;

Jestem pewien, że jest o wiele mądrzejszy (i krótszy) sposób, aby to zrobić, ale na razie się sprawdzi.

Python 2, 69 bajtów

Pobiera dane wejściowe jako ciąg.

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

Wyjaśnienie:

dawny 1201212012

Konwertuje na listę sum:

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

Ewaluuje i konwertuje na set.

set([3])

Jeśli długość zestawu wynosi 1, wszystkie kwoty są takie same.

JavaScript (ES6), 58

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

Stosując moją rzadko przydatną wskazówkę https://codegolf.stackexchange.com/a/49967/21348

Skanuje ciąg znaków char, identyfikując ciąg rosnących znaków, na końcu każdego rumu sprawdza, czy suma jest zawsze taka sama

• c: obecny char
• p: poprzedni znak
• z: suma bieżąca, pod koniec przebiegu zostanie porównana do ...
• x: suma do porównania, przy pierwszym uruchomieniu jest po prostu równa z

Test

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>

Pyth , 20 bajtów

Dwie wersje

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

Wypróbuj pierwszy online!

Wypróbuj drugą online!

Rubin, 117 105 85 bajtów

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

Zwróciłoby to liczbę całkowitą tego numeru dennis lub, niljeśli nie, liczbę dennis. Wszystkie liczby całkowite będą uważane za rubinowe również nilza fałszywe. ijest liczbą całkowitą, która jest sprawdzana.

Trzecia wersja faktycznie powraca truei false.

PS przetestowano, aby zwrócić 172 liczby całkowite od 1 do 1000, jak w odpowiedzi.

APL, 23 bajty

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

Wyjaśnienie:

• N←⍎¨⍕⍵: pobierz poszczególne cyfry z wejścia, zapisz N
• N⊂⍨1,2>/N: znajdź podlisty ściśle rosnącej liczby w N
• +/↑: zsumuj każdą podlistę
• 1=≢∪: sprawdź, czy wynikowa lista zawiera tylko jeden unikalny element

Dodaj ++ , 109 bajtów

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$ª=

Wypróbuj online!

Jak to działa

$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$