PPCG kullanıcısı ve seçilen mod, @Dennis , 100k rep üzerinde kazanan ilk kullanıcı oldu!

Bu tamamen orijinal bir fikir, kimseden alamadım , hadi kullanıcı kimliğine dayanarak, 12012haraç olarak bir meydan okuma yapalım !

Ona bakarak kimliğinin iki ayrı "bölümü" olduğunu göreceksin.

12

ve

012

Bu iki bölüm de 3'e kadar ekler. Bu oldukça ilginç bir özellik.

Bir "Dennis 2.0 numarası" nı kesin olarak artan rakamların her bir sonraki sırasının aynı sayıya ulaştığı herhangi bir pozitif tamsayı olarak tanımlayalım. Örneğin,

123

Dennis 2.0 bir sayıdır, çünkü kesinlikle artan basamaklardan yalnızca bir maksimum alt listesi vardır ve 6'ya ulaşır. Ek olarak, 2.846,145 aynı zamanda bir Dennis 2.0 sayıdır, çünkü artan sayıdaki üç maksimum alt liste, yani

28
46
145

Tüm toplamı 10. Ek olarak, aynı haneyi tekrar eden sayılar Dennis 2.0 sayıları olmalıdır , çünkü örneğin 777parçalara ayrılabilir.

7
7
7

hangi açıkça yedi toplamı.

Gibi bir dizi gibi 42olduğu değil de ayrılmıştır yana Dennis 2.0 numarası

4
2

açıkça aynı sayıya sahip değildir.

Meydan okuma

Belirli bir sayının Dennis 2.0 numarası olup olmadığını belirlemek için bir program veya işlev yazmalısınız. Sen vb STDIN / STDOUT, bir dosyaya, işlev argümanları / getiri, gelen bir sayı olarak, bir dize olarak örneğin herhangi bir makul girdi biçiminde giriş ve çıkışını almak ve daha sonra bir dönebilirsiniz truthy değerini bu sayı Dennis 2.0 ise sayı ve değilse sahte bir değer. Başvuru için, işte her Dennis 2.0 sayısı 1.000'e kadar:

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

Standart boşluklar uygulanır ve bayt cinsinden ölçülen en kısa cevap kazanır!

Jöle, 13 12 bayt

@Dennis sayesinde 1 bayt.

DIṠ’0;œṗDS€E

Çevrimiçi deneyin!

açıklama

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 bayt

Giriş olarak bir dize alır. False veya bir rutubet değerini döndürür (sayı olabilir).

Aşağıdaki gibi bir giriş dizesini dönüştürmek için normal bir ifade kullanıyor "2846145":

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

Sonra eval()bu ifadeyi çağırır .

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 bayt

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

input()Bir dizgenin değerlendirilmesini bekler , bu nedenle girişin Python 2'deki tırnaklara ihtiyacı vardır. Çıktı çıkış kodudur , burada 0 başarı (truthy) ve 1 başarısızlık (falsy) gösterir.

İdeone üzerinde test et .

Nasıl çalışır

Biz başlatmak r dizeye 0 ve tüm basamak üzerinde yineleme d girişte.

• Eğer d birinci basamak daha büyük olan r (ilk olarak 0 , önceki değerine eşittir, d ), r<ddeğerlendirir doğru ve '=+'[r<d]*2verimleri ++.

• Eğer d birinci basamak daha küçük olan R , '=+'[r<d]*2verim ==.

• Eğer d birinci basamak eşittir r , r, tekil dizi daha uzun olacak d , böylece '=+'[r<d]*2verim yine ==.

Her durumda, d rakamı ve oluşturulan iki karakter r'ye hazırlanır .

Tüm giriş basamakları işlendikten sonra eval(r), üretilen ifadeyi değerlendirir.

• Girdi, katı bir şekilde artan (pozitif) basamaklardan oluşuyorsa, ifade toplamlarına göre değerlendirilir.

  Örneğin, 12345 tamsayısı , ifade 5++4++3++2++1++0edildiğinde 15'i veren ifadeyle sonuçlanır . Her saniye unutmayın + bir olan tek terimli artı, bu nedenle sonuç etkilemez. Bölme 1 ile 15 (sonuç önemli değildir) geçerlidir; program normal şekilde çıkar.

• Girdi, kesinlikle artan iki basamak dizisinden oluşuyorsa, ifade basit bir karşılaştırmadan oluşur.

  Örnek olarak, tamsayı 12012 ekspresyonunda sonuçlar 2++1++0==2++1++0verir, doğru her iki terim de bir miktar beri değerlendirildiğinde 3 . Bölme 1 tarafından true ( 1 ) (sonuç önemli değildir) geçerlidir; program normal şekilde çıkar.

  Öte yandan, tam sayı 12366 ekspresyonunda sonuçlar 6==6++3++2++1++0verir, yanlış terimler Sumi beri değerlendirildiğinde 6 ve 12 . Bölme 1 ile yanlış ( 0 ), bir yükseltir ZeroDivisionError ; program bir hata ile çıkar.

• Sayıları üç veya daha fazla kesin artan dizilerin oluşuyorsa, ekspresyonu oluşur zincirli karşılaştırma döndürür doğru ilgili tüm karşılaştırmalar geri ancak ve ancak doğru .

  Örnek olarak, tamsayı 94536 ekspresyonunda sonuçlar 6++3==5++4==9++0verir, doğru tüm terimler toplamı beri değerlendirildiğinde 9 . Daha önce olduğu gibi, program normal şekilde çıkar.

  Öte yandan, tam sayı 17.263 tanımlanmasına neden 3==6++2==7++1++0verir, yanlış terimler miktarda beri değerlendirildiğinde 3 , 8 ve 8 . Daha önce olduğu gibi, program bir hata ile çıkar.

Brachylog , 13 bayt

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

Çevrimiçi deneyin!

açıklama

~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 ilk önce en büyük alt listelerle birleşecek.

Pyke, 18 bayt

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

Burada dene!

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 bayt

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

Bir edebi bir liner, çünkü hepsi bir boru hattı. Bir dize olarak girdi alır $args[0]. Bir şekilde içinden Loops char-array, bir mevcut elemanı ya yerleştirilmesi, her yineleme +veya -eqolmadığına göre, boru hattı üzerine önünde mevcut değer -less-daha-veya- eönceki değerine Qual $i. Bu şeritler vardır -joinbirlikte ed ve borulu iexkısa ( Invoke-Expressionve benzer eval. Örneğin, giriş için 2846145bu değerlendirilecektir +2+8-eq4+6-eq1+4+5olan True.

Bu Boolean boru hattında bırakılır ve True/ Falseprogramın sonunda örtük olarak yazılır.

Not - tek basamaklı giriş için, elde edilen basamak, PowerShell'de bir truthy değeri olan boru hattında bırakılır.

Örnekler

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

Her ikisi de -r için +1 içerir

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

Normal ondalık sayıda girdi alır

Çevrimiçi deneyin!

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

Girdiyi, unary'deki sayı hanelerinin virgülle ayrılmış listesi olarak alır. örneğin 123olurdu1,11,111

Çevrimiçi deneyin!

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

-Ton Hospel sayesinde -9 bayt !

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

Bir $'olduğundan kod çalıştırmak için bir dosyada olmalıdır. Bu yüzden -p3 bayt için sayar. Sayı bir Dennis 2.0 numarası veya boş bir dize ise 1 değerini verir:

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

@ Edc65 sayesinde 2 bayt kaydedildi

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

Bir dize olarak girdi alır. Eski versiyon (sadece Firefox 30+ ile çalışır):

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

Mathematica, 38 bayt

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

Anonim işlev Giriş ve döner gibi bir dizi alır Trueya da Falseçıkış olarak.

Brachylog 2, 10 bayt, dil son kullanma tarihi zorluğu

ẹ~c<₁ᵐ!+ᵐ=

Çevrimiçi deneyin!

Bu temelde @ Fatalize'in cevabıyla aynı algoritmadır (ki bunu yazana kadar görmedim), fakat Brachylog 2'nin sözdizimi altında daha golfçü yapmak için bir şekilde yeniden düzenlendi.

false.Dennis 2.0 numarası truedeğilse ya da öyleyse dönen, tam bir programdır .

açıklama

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

Bir Brachylog tam programında her zamanki gibi, tüm iddialar aynı anda yerine getirilebiliyorsa, gerçek bir geri dönüş elde ederiz, aksi takdirde falsey. İçin varsayılan sırası ~cilk az olan bölümleri, uzun unsurları sıralamak ve Prolog (böylece Brachylog) 'de, yani bir tiebreak olarak ikinci ve kullanma programda ilk dayanak tarafından tanımlanan varsayılan siparişin (; burada, ~chakim, çünkü ẹdeterministiktir ve bu nedenle sipariş edecek bir şeyi yoktur).

MATL, 24 23 20 18 16 bayt

Tjdl<vYsG!UlXQ&=

Bir falsey matrisi gerçeği döndürür

Çevrimiçi Deneyin!

Ayrıca, @Dennis tebrikler!

açıklama

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 bayt

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

argümandan girdi alır, 0Dennis-2.0 numarasıyla çıkar , 1başkasıyla.

Yıkmak

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

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

açıklama

N = 12012 örnek olarak kullanılır.

                    # 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

Çevrimiçi deneyin!

Ruby 2.3, 56 bayt

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

Neredeyse kesinlikle bunu yapmanın en golf yolu değil, ancak bazı güzel dil özelliklerini gösterir.

(Newline toleranslı değil, öyleyse koş ruby dennis2.rb <<< '12012')

PHP, 144 bayt

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

Bunu yapmanın çok daha akıllıca (ve daha kısa) bir yolu olduğuna eminim ama şimdilik yapacak.

Python 2,69 bayt

Bir dize olarak girdi alır.

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

Açıklama:

eski 1201212012

Toplamların listesine dönüştürür:

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

Değerlendirir ve sete dönüştürür.

set([3])

Setin uzunluğu 1 ise, tüm toplamlar aynıdır.

JavaScript (ES6), 58

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

Nadiren yararlı olan ipucumu uygulama https://codegolf.stackexchange.com/a/49967/21348

Karakterin char karakterini, artan karakterlerin çalışmasını tanımlayan karakter ile tarar, her rom sonunda, toplamın daima aynı olup olmadığını kontrol eder

• c: mevcut karakter
• p: önceki karakter
• z: koşuların toplamı, koşuların sonunda yapılanlarla karşılaştırılacak ...
• x: karşılaştırmak için toplam, ilk çalıştırmada sadece z'ye eşit yapılır

Ölçek

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 bayt

İki versiyonu

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

İlki çevrimiçi deneyin!

İkincisi çevrimiçi deneyin!

Yakut, 117 105 85 bayt

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

Bu, bu dennis sayısının tamsayısını veya nilbir dennis sayısının olmaması durumunda döndürür . Tüm tamsayılar yakutta doğru olarak nilkabul edilir ve yanlış olarak kabul edilir. ikontrol edilen tamsayıdır.

Üçüncü sürüm aslında döndürür trueve false.

PS cevapta olduğu gibi 1'den 1000'e kadar 172 tam sayı döndürmek için test edildi.

APL, 23 bayt

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

Açıklama:

• N←⍎¨⍕⍵: girilen bireysel rakamları almak için kayıt N
• N⊂⍨1,2>/N: kesinlikle artan sayıların alt listelerini bulmak N
• +/↑: her alt listeyi topla
• 1=≢∪: sonuçta ortaya çıkan listenin yalnızca bir benzersiz öğesi olup olmadığını görün

++ , 109 bayt ekle

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

Çevrimiçi deneyin!

Nasıl çalışır

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