Récemment, j'ai passé un test de mathématiques et j'ai remarqué qu'un certain nombre du test correspondait à un modèle intéressant. Le nombre ( 28384) correspond à une séquence de chiffres générique qui ressemble à ceci

(n)(x)(n+1)(x)(n+2)(x)(n+3) etc...

où net xsont des entiers à un chiffre. La séquence peut commencer par ou xou net se terminer par xou n+y.

Votre tâche consiste, étant donné un entier positif à plusieurs chiffres, à sortir une valeur true ou falsey, selon que l'entrée correspond au modèle. L'entrée comprendra entre 4 et 18 chiffres. Vous pouvez prendre l'entrée comme une représentation sous forme de chaîne de l'entier. L'entrée ne commencera pas par un 0 mais pourra contenir ou se terminer par des 0.

n+y sera toujours un nombre à un seul chiffre (d'où la limite de longueur est de 18).

Cas de test

Ceux-ci devraient produire une valeur véridique

182838485868788898
4344
85868
12223242526

Et cela devrait être falsey

12345
6724013635
36842478324836
1222232425
5859510511

Comme avec tous les golfs de code, le code le plus court gagne! Bonne chance et que les chances soient toujours en votre faveur!

Python 2 , 84 81 80 79 octets

-1 octet grâce aux ovs

lambda x:g(x,1)|g(x,0)
g=lambda x,a:len(set(x[a::2]))==(x[a<1::2]in"123456789")

Essayez-le en ligne!

Python 3 , 82 79 78 77 octets

lambda x:g(x,1)|g(x,0)
g=lambda x,a:len({*x[a::2]})==(x[a<1::2]in"123456789")

Essayez-le en ligne!

Un peu plus court en Python 3, mais je ne pensais pas qu'il méritait sa propre réponse.

Explication

Nous mettons en place une fonction gqui prend une chaîne et un index (1 ou 0). grenvoie ensuite si oui ou non len(set(x[a::2])), c'est-à-dire le nombre de chiffres uniques dans toutes les autres positions, est égal à (x[a==0::2]in"123456789"), que les autres chiffres soient ou non dans l'ordre croissant. Si les chiffres sont dans l'ordre croissant, cela renvoie s'ils sont tous identiques ou non, sinon il demandera si l'ensemble est vide, ce qu'il ne peut pas être, retournant ainsi toujours faux.

Gelée , 13 11 octets

Ds2ZI’M¦Ẏ¬Ạ

Essayez-le en ligne!

Explication:

Ds2ZI’M¦Ẏ¬Ạ Accepts an integer
D           Get individual digits
  2         2
 s          Split into chunks of specific length
   Z        Zip
    I       Take deltas
     ’      Decrement
      M     Take maximal indices
       ¦    Apply at specific indices
        Ẏ   Reduce dimensionality
         ¬  Vectorized NOT
          Ạ Check if all are truthy

05AB1E , 15 octets

TG9LNýN.øŒ})˜Iå

Essayez-le en ligne!

Explication

TG9LNýN.øŒ})˜Iå
TG        }     # For 1 to 9...
  9L             # Push [1 .. 9]
    Ný           # Join with current value 
      N.ø        # surround with current value
         Π      # Push substrings
           )    # Wrap stack to array
            ˜   # Deep flatten the array
             I  # Push input
              å # Is the input in the array?
                # Implicit print

Cela devrait fonctionner (les cas de test l'ont fait) mais si vous trouvez des défauts, faites-le moi savoir.

14 octets si aucune sortie n'est considérée comme fausse:

TG9LNýN.øŒIåi1

D, 117 octets

int f(string n){int o=n[0]!=n[2],x=n[o];foreach(i,c;n){if(i%2!=o&&i>1&&c!=n[i-2]+1||i%2==o&&c!=x)return 0;}return 1;}

Certainement sous-optimal, mais cela fonctionne bien

Essayez-le en ligne!

Haskell, 108 113 97 95 octets

d(x:_:r)=x:d r
d r=r
c(x:n:r)=and$all(==x)(d r):zipWith(==)(d$n:r)[n..]
f s@(_:n:_)=c s||c(n:s)

Exemple d'appel: f "182838485868788898"rendementsTrue

Version non golfée avec explications:

-- Take every other element from the string, starting with the first
d (x:_:r) = x : d r
d r       = r
c (x:n:r) = and $ all (== x) (d r)              -- Every other char is equal to the first
                : zipWith (==) (d $ n:r) [n..]  -- The remaining chars are a prefix of n(n+1)(n+2)...
f s@(_:n:_) = c s      -- The case where s already starts with x
           || c (n:s)  -- If not, prepend a dummy x and try again

JavaScript (ES6), 66 63 60 octets

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

s=>[...s].every((d,i)=>d-s[j^(k=i+j&1)]==k*i>>1,j=s[2]-s[0])

Cas de test

let f =

s=>[...s].every((d,i)=>d-s[j^(k=i+j&1)]==k*i>>1,j=s[2]-s[0])

console.log('[Truthy]');
console.log(f("182838485868788898"))
console.log(f("4344"))
console.log(f("85868"))
console.log(f("12223242526"))

console.log('[Falsy]');
console.log(f("12345"))
console.log(f("6724013635"))
console.log(f("36842478324836"))
console.log(f("1222232425"))

C (gcc), 123 octets

#define X*s&&*s++-++n&&(r=0)
t,n,x,r;f(char*s){t=*s==s[2];for(r=1,n=s[t],x=s[!t],s+=2;*s;)t||X,*s&&*s++-x&&(r=0),t&&X;n=r;}

Essayez-le en ligne!

Python 3 , 99 96 89 octets

• 3 octets enregistrés: utilisation de la all()fonction
• @WheatWizard a économisé 7 octets: raccourcir & |et remplacer la variable supplémentaire park<1

lambda x,g=lambda x,k:(x[k<1::2]in'123456789')&all(j==x[k]for j in x[k::2]):g(x,0)|g(x,1)

Essayez-le en ligne!

Explication:

Divisez d'abord la chaîne en deux listes: une avec des éléments indexés impairs et l'autre avec des éléments indexés pairs. Les deux listes A et B sont supposées être telles que:

1. A contient le même numéro et B contient des numéros consécutifs dans l'ordre croissant.

OU juste le contraire

2. B contient le même numéro et A contient des numéros consécutifs dans l'ordre croissant.

La condition consécutive est vérifiée par: a in '123456789'

La condition du même numéro est vérifiée par: all(i=a[x] for i in a)

PHP , 68 octets

for(;$v<10;)$s.=strstr(+$v.join(+$v,range(1,9)).+$v++,$argn);echo$s;

Essayez-le en ligne!

Sortie d'une partie de la chaîne de recherche à partir de la première occurrence de l'entrée à la fin de la chaîne de recherche en tant que valeur véridique et rien pour fausse

pour 2 octets de plus, vous pouvez remplacer echo$s;par !!echo$s;pour obtenir 1une valeur fidèle

Rechercher l'occurrence de l'entrée dans l'une des chaînes suivantes du tableau

Array
(
    [0] => 0102030405060708090
    [1] => 1112131415161718191
    [2] => 2122232425262728292
    [3] => 3132333435363738393
    [4] => 4142434445464748494
    [5] => 5152535455565758595
    [6] => 6162636465666768696
    [7] => 7172737475767778797
    [8] => 8182838485868788898
    [9] => 9192939495969798999
)

JavaScript (ES6), 54 octets

f=
s=>[...s].every((e,i)=>i<2|e-s[i-2]==(s[2]!=s[0])^i%2)

<input oninput=o.textContent=this.value[3]?f(this.value):``><pre id=o>

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

MATL , 15 octets

2L&),duw]hSFTX=

Essayez-le en ligne!

Avec l'aide de @LuisMendo dans le chat. Notez que si une sortie vide + erreur est également considérée comme «fausse», elle Xpeut être laissée de côté, ce qui porte le score à 14 octets .

2L&)     % Split the input into odd and even-indexed elements
    ,   ] % Do twice (new feature since MATL v20.0), i.e., on both halves of the input
     d     % Pairwise differences of the array. Results in [0,0,...] for the 'constant' part,
            %  and [1,1,...] for the 'increasing' part.
      u      % Get unique elements. Results in [0] for the constant part, [1] for the increasing part.
       w      % Swap the stack to do the same for the other half of the input.
         hS    % Horizontal concatenation followed by sort. Results in [0,1] for the desired string.
           FTX= % Check if the result is indeed [0,1]. Implicit display.

Mathematica, 121 octets

(m[x_]:=Take[s=IntegerDigits@#,{x,Length@s,2}];w[b_,n_]:=Union@Differences@m@b=={1}&&Length@Union@m@n==1;w[1,2]||w[2,1])&

Pyth , 20 octets

ASm.+sMd.Tcz2&-GZ-H1

Sortie []lorsque le nombre correspond au modèle de chiffres, sinon toute autre chose.

Essayez-le en ligne!

Explications (exemple avec entrée 85868)

ASm.+sMd.Tcz2&-GZ-H1

          cz2           # Chop the input in pairs: ['85', '86', '8']
        .T              # Transpose, ignore absences: ['888', '56']
     sM                 # Convert to integers: [[8, 8, 8], [5, 6]]
  m.+  d                # Compute deltas: [[0, 0], [1]]
 S                      # Sort: [[0, 0], [1]]
A                       # Assign first list to G and second list to H
              -GZ       # Filter 0 on G (on absence): [0, 0] -> []
                 -H1    # Filter 1 on H (on absence): [1] -> []
             &          # Check both lists are empty (logical and): [] & [] -> []

Pyth, 17 octets

qU2Ssm{.+d.TcjQT2

Essayez-le ici

Même algorithme que ma réponse Jelly.

Explication:

qU2Ssm{.+d.TcjQT2 Accepts an integer
             jQT  Take digits of input
            c   2 Split in pairs
          .T      Transpose
     m            Map the following on each of the two resulting lists:
       .+d          Take deltas
      {             Deduplicate
    s             The list is now in [[a, b, ...], [A, B, ...]] format, convert it to [a, b, ..., A, B, ...]
   S              Sort
qU2               Check if equal to [0, 1]

Python 3 , 167 161 157 157 131 106 octets

-55 octets grâce aux suggestions de @ WheatWizard

def g(t):k,c,f,j=t[::2],t[1::2],'123456789',''.join;return(len({*k})and j(c)in f)or(len({*c})and j(k)in f)

Essayez-le en ligne!

Java (OpenJDK 8) , 128 119 118 108 107 104 octets

s->{int i=3,a=s[2]-s[0],b=s[3]-s[1];for(;++i<s.length;)a+=b-(b=s[i]-s[i-2]==a?a:2);return(a|b)==1&a!=b;}

Essayez-le en ligne!

Explication:

s->{                             // lambda
  int i=3,                       //  iterating index
      a=s[2]-s[0],               //  diff of even-indexed characters
      b=s[3]-s[1];               //  diff of odd-indexed characters
  for(;++i<s.length;)            //  iterate
    a+=b-(b=                     //   swap a and b
        s[i]-s[i-2]==a?a:2       //    or set b to 2 if the diffs don't match
      ));                        //
  return (a|b)==1                //  return true if both a and b are in (0,1)
        &a!=b;                   //         but different
}

Rétine , 47 octets

.
$*11;
(1+)(?<=\1;1+;\1)

^1+;1+

^;?(;1;)+;?$

Essayez-le en ligne!

Affiche 1 s'il correspond au modèle, 0 s'il ne correspond pas

Explication

.
$*11;

Convertir chaque chiffre n en n + 1 en unaire, séparés par des points-virgules

(1+)(?<=\1;1+;\1)

(Trailing newline) convertit chaque chiffre à la différence entre lui-même et celui qui le précède

^1+;1+

(Trait de fin de ligne) supprime les 2 premiers chiffres

^;?(;1;)+;?$

Compte le nombre de correspondances de ce modèle, qui vérifie l'alternance des 0 et des 1