Utilisateur de PPCG et élu mod, @Dennis vient de devenir le deuxième utilisateur à gagner plus de 100 000 reps!

C'est une idée totalement originale, que je n'ai reçue de personne d'autre , mais faisons un défi à partir de son identifiant, 12012en hommage!

En le regardant, vous remarquerez qu'il y a deux "sections" distinctes à son identifiant.

12

et

012

Ces deux sections totalisent un 3. C'est une propriété assez intéressante.

Définissons un "nombre de Dennis 2.0" comme tout entier positif où chaque sous-séquence maximale de chiffres strictement croissants est la somme du même nombre. Par exemple,

123

est un numéro Dennis 2.0 car il n’existe qu’une sous-liste maximale de chiffres strictement croissants et s’élève à 6. En outre, 2 846 145 est également un numéro Dennis 2.0, car les trois sous-listes maximales de chiffres croissants, à savoir

28
46
145

Tout somme à 10. De plus, les nombres qui ne font que répéter le même chiffre doivent être des chiffres de Dennis 2.0, car ils 777peuvent , par exemple, être divisés en deux.

7
7
7

qui clairement tout somme à sept.

Un nombre tel que 42n'est pas un nombre de Dennis 2.0, car il est divisé en

4
2

qui ne correspondent clairement pas au même nombre.

Le défi

Vous devez écrire un programme ou une fonction pour déterminer si un nombre donné est un nombre de Dennis 2.0 ou non. Vous pouvez utiliser les entrées et les sorties dans tous les formats possibles, par exemple sous forme de chaîne, sous forme de nombre, à partir d'un fichier, d'arguments / de fonctions, depuis STDIN / STDOUT, etc., puis de renvoyer une valeur de vérité si ce nombre est un Dennis 2.0. nombre, et une valeur de fausseté si ce n'est pas. Pour référence, voici chaque numéro de Dennis 2.0 jusqu'à 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

Les failles standard s'appliquent et la réponse la plus courte mesurée en octets est gagnante!

Gelée, 13 à 12 octets

1 octet grâce à @Dennis.

DIṠ’0;œṗDS€E

Essayez-le en ligne!

Explication

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 octets

Prend une chaîne en entrée. Retourne false ou une valeur de vérité (qui peut être un nombre).

Il utilise une expression régulière pour transformer une chaîne d'entrée telle que "2846145":

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

Puis appelle eval()cette expression.

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 octets

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

S'attend input()à être évalué à une chaîne. L'entrée doit donc contenir des guillemets en Python 2. La sortie s'effectue via le code de sortie , où 0 indique le succès (vérité) et 1, un échec (falsy).

Testez-le sur Ideone .

Comment ça fonctionne

Nous initialisons r avec la chaîne 0 et parcourons tous les chiffres d de l’entrée.

• Si d est plus grand que le premier chiffre de r (initialement 0 , alors égal à la valeur précédente de d ), est r<dévalué à True et '=+'[r<d]*2donne ++.

• Si d est inférieur au premier chiffre de r , '=+'[r<d]*2donne ==.

• Si d est égal au premier chiffre de r , r sera plus long que la chaîne singleton d , donc '=+'[r<d]*2cède encore une fois ==.

Dans tous les cas, le chiffre d et les deux caractères générés sont préfixés à r .

Une fois que tous les chiffres saisis ont été traités, eval(r)évalue l'expression générée.

• Si l'entrée consiste en une seule séquence strictement croissante de chiffres (positifs), l'expression est évaluée à leur somme.

  Par exemple, le nombre entier 12345 donne l'expression 5++4++3++2++1++0, ce qui donne 15 lorsqu'elle est évaluée. Notez que chaque seconde + est un plus unaire , elle n’affecte donc pas le résultat. La division de 1 sur 15 est valide (le résultat n'est pas important); le programme se termine normalement.

• Si l'entrée consiste en deux séquences de chiffres strictement croissantes, l'expression consiste en une simple comparaison.

  Par exemple, l'entier 12012 donne l'expression 2++1++0==2++1++0, ce qui donne True lorsqu'il est évalué, car les deux termes ont la somme 3 . La division de 1 par True ( 1 ) est valide (le résultat n'est pas important); le programme se termine normalement.

  D'autre part, le nombre entier 12366 donne l'expression 6==6++3++2++1++0, ce qui donne Faux lors de l'évaluation car les termes ont les sommes 6 et 12 . La division de 1 par False ( 0 ) génère une erreur ZeroDivisionError ; le programme se termine avec une erreur.

• Si l'entrée consiste en trois séquences de chiffres strictement croissantes ou plus, l'expression consiste en une comparaison chaînée , qui renvoie True si et seulement si toutes les comparaisons impliquées renvoient True .

  Par exemple, le nombre entier 94536 donne l'expression 6++3==5++4==9++0, ce qui donne True lorsqu'il est évalué car tous les termes ont la somme 9 . Comme auparavant, le programme se termine normalement.

  D'autre part, le nombre entier 17263 donne l'expression 3==6++2==7++1++0, ce qui donne Faux lors de l'évaluation car les termes ont les sommes 3 , 8 et 8 . Comme auparavant, le programme se termine avec une erreur.

Brachylog , 13 octets

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

Essayez-le en ligne!

Explication

~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 sera unifié avec les plus grandes sous-listes en premier.

Pyke, 18 octets

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

Essayez-le ici!

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 octets

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

Une ligne littérale, car il s’agit d’un seul pipeline. Prend l'entrée sous forme de chaîne $args[0]. Boucle à travers elle sous forme de chartableau, chaque itération plaçant l'élément actuel avec un devant +ou -eqdevant lui sur le pipeline en fonction du fait que la valeur actuelle est -lessentielle ou non par rapport eà la valeur précédente $i. Ces chaînes sont -joinéditées ensemble et dirigées vers iex(raccourci pour Invoke-Expressionet similaire à eval. Par exemple, pour l’entrée, 2846145cela sera évalué comme +2+8-eq4+6-eq1+4+5, ce qui est True.

Ce booléen est laissé sur le pipeline et True/ Falseest écrit implicitement à l'achèvement du programme.

NB: pour une entrée à un chiffre, le chiffre obtenu est laissé sur le pipeline, ce qui correspond à la valeur de vérité de PowerShell.

Exemples

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

Les deux incluent +1 pour -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

Prend les entrées en décimal normal

Essayez-le en ligne!

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

Prend la saisie sous forme de liste de chiffres numérotés séparés par des virgules. par exemple 123serait1,11,111

Essayez-le en ligne!

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

-9 octets grâce à @Ton Hospel !

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

Comme il existe un $', le code doit être dans un fichier à exécuter. Donc, -pcompte pour 3 octets. Les sorties 1 si le nombre est un nombre de Dennis 2.0 ou une chaîne vide sinon:

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

2 octets sauvés grâce à @ edc65

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

Prend l'entrée sous forme de chaîne. Ancienne version (ne fonctionne que dans 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 octets

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

Fonction anonyme. Prend un nombre en entrée et renvoie Trueou Falseen sortie.

Brachylog 2, 10 octets, langue postdates challenge

ẹ~c<₁ᵐ!+ᵐ=

Essayez-le en ligne!

C’est fondamentalement le même algorithme que la réponse de @ Fatalize (que je n’ai pas vue avant d’avoir écrit cela), mais qui a été quelque peu réorganisé pour le rendre plus golfeur sous la syntaxe de Brachylog 2.

C'est un programme complet, renvoyant false.s'il ne s'agit pas d'un numéro Dennis 2.0 ou trues'il l'est.

Explication

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

Comme d'habitude pour un programme complet de Brachylog, si toutes les affirmations peuvent être satisfaites simultanément, nous aurons un retour de vérité, sinon Falsey. L'ordre par défaut ~cconsiste à trier les partitions avec des éléments moins nombreux et les plus longs en premier. Dans Prolog (donc Brachylog), l'ordre par défaut est défini par le premier prédicat du programme (en utilisant le second comme condition de départage, etc.; ici, ~cdomine, car ẹest déterministe et n’a donc rien à commander).

MATL, 24 23 20 18 16 octets

Tjdl<vYsG!UlXQ&=

Retourne une truthy de Falsey matrice

Essayez-le en ligne!

Aussi, félicitations @Dennis!

Explication

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 octets

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

prend en charge l'argument, sort avec 0pour numéro Dennis-2.0, avec 1else.

panne

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

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

Explication

N = 12012 utilisé comme exemple.

                    # 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

Essayez-le en ligne!

Ruby 2.3, 56 octets

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

Ce n’est certainement pas la façon la plus risquée de faire cela, mais cela présente quelques fonctionnalités intéressantes.

(Pas de tolérance à la nouvelle ligne, alors lancez comme ruby dennis2.rb <<< '12012')

PHP, 144 octets

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

Je suis sûr qu'il existe un moyen beaucoup plus intelligent (et plus court) de le faire, mais cela ira pour le moment.

Python 2, 69 octets

Prend l'entrée sous forme de chaîne.

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

Explication:

ex 1201212012

Conversion en liste de sommes:

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

Evals et convertit à définir.

set([3])

Si la longueur de l'ensemble est 1, toutes les sommes sont identiques.

JavaScript (ES6), 58

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

Appliquer mon conseil rarement utile https://codegolf.stackexchange.com/a/49967/21348

Il analyse le caractère de chaîne par caractère en identifiant une série de caractères ascendants. À la fin de chaque rhum, il vérifie si la somme est toujours la même.

• c: caractère actuel
• p: caractère précédent
• z: somme courante, à la fin d'une course sera comparée à ...
• x: somme à comparer, au premier passage est simplement égal à z

Tester

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 octets

Deux versions

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

Essayez le premier en ligne!

Essayez le second en ligne!

Rubis, 117 105 85 octets

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

Cela renverrait l'entier de ce numéro dennis ou nils'il n'était pas un numéro dennis. Tous les entiers seront considérés comme vrais dans Ruby et nilsont également considérés comme faux. iest le nombre entier en cours de vérification.

La troisième version revient réellement trueet false.

PS a testé pour renvoyer 172 nombres entiers compris entre 1 et 1 000, comme indiqué dans la réponse.

APL, 23 octets

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

Explication:

• N←⍎¨⍕⍵: obtenir les chiffres individuels dans l'entrée, enregistrer dans N
• N⊂⍨1,2>/N: trouver les sous-listes de nombres strictement croissants dans N
• +/↑: somme chaque sous-liste
• 1=≢∪: voir si la liste résultante n'a qu'un seul élément unique

Ajouter ++ , 109 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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