Vor kurzem hatte ich einen Mathetest und bemerkte, dass eine bestimmte Zahl auf dem Test einem interessanten Muster entsprach. Die Zahl ( 28384) stimmte mit einer generischen Ziffernfolge überein, die so aussieht

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

wo nund xsind einstellige ganze Zahlen. Die Sequenz kann mit entweder beginnen xoder nmit und Ende entweder xodern+y .

Ihre Aufgabe ist es, bei einer mehrstelligen positiven Ganzzahl einen Wahrheits- oder Falschwert auszugeben, je nachdem, ob die Eingabe mit dem Muster übereinstimmt. Die Eingabe ist zwischen 4 und 18 Ziffern lang. Sie können die Eingabe als Zeichenfolgendarstellung der Ganzzahl annehmen. Die Eingabe beginnt nicht mit einer 0, sondern kann 0en enthalten oder damit enden.

n+y wird immer eine einstellige Zahl sein (daher ist die Länge auf 18 begrenzt).

Testfälle

Diese sollten einen Wahrheitswert ausgeben

182838485868788898
4344
85868
12223242526

Und diese sollten falsch sein

12345
6724013635
36842478324836
1222232425
5859510511

Wie bei allen Code-Golfspielen gewinnt der kürzeste Code! Viel Glück und möge die Wahrscheinlichkeit immer zu Ihren Gunsten sein!

Python 2 , 84 81 80 79 Bytes

-1 Byte dank ovs

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

Probieren Sie es online!

Python 3 , 82 79 78 77 Bytes

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

Probieren Sie es online!

In Python 3 etwas kürzer, aber ich dachte nicht, dass es eine eigene Antwort verdient.

Erläuterung

Wir haben eine Funktion eingerichtet, die einen gString und einen Index (entweder 1 oder 0) akzeptiert. gdann wird zurückgegeben, ob oder ob nicht len(set(x[a::2])), das ist die Anzahl der eindeutigen Stellen an jeder anderen Position, gleich ist (x[a==0::2]in"123456789"), ob die anderen Stellen in aufsteigender Reihenfolge sind oder nicht. Wenn die Ziffern in aufsteigender Reihenfolge sind, wird zurückgegeben, ob sie alle gleich sind oder nicht. Wenn nicht, wird gefragt, ob die Menge leer ist, was nicht möglich ist. Daher wird immer false zurückgegeben.

Jelly , 13 11 Bytes

Ds2ZI’M¦Ẏ¬Ạ

Probieren Sie es online!

Erläuterung:

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 Bytes

TG9LNýN.øŒ})˜Iå

Probieren Sie es online!

Erläuterung

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

Es sollte funktionieren (Testfälle haben funktioniert), aber wenn Sie Fehler finden, lassen Sie es mich bitte wissen.

14 Bytes, wenn keine Ausgabe als falsch gilt:

TG9LNýN.øŒIåi1

D, 117 Bytes

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

Auf jeden Fall suboptimal, aber es funktioniert gut

Probieren Sie es online!

Haskell, 108 113 97 95 Bytes

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)

Beispielanruf: f "182838485868788898"ErträgeTrue

Ungolfed-Version mit Erläuterungen:

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

Übernimmt die Eingabe als Zeichenfolge.

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

Testfälle

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 Bytes

#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;}

Probieren Sie es online!

Python 3 , 99 96 89 Bytes

• Gespeicherte 3 Bytes: Verwendung der all()Funktion
• @ WheatWizard sparte 7 Bytes: Shorthanding & |und ersetze zusätzliche Variable durchk<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)

Probieren Sie es online!

Erläuterung:

Teilen Sie die Zeichenfolge zunächst in zwei Listen auf: eine mit ungeraden und eine mit geraden Elementen. Die zwei Listen A und B sollen so sein, dass entweder:

1. A enthält die gleiche Nummer und B enthält fortlaufende Nummern in aufsteigender Reihenfolge.

ODER genau das Gegenteil

2. B enthält die gleiche Nummer und A enthält fortlaufende Nummern in aufsteigender Reihenfolge.

Die Folgebedingung wird überprüft durch: a in '123456789'

Die Bedingung mit der gleichen Nummer wird überprüft durch: all(i=a[x] for i in a)

PHP , 68 Bytes

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

Probieren Sie es online!

Geben Sie einen Teil des Suchstrings ab dem ersten Auftreten der Eingabe bis zum Ende des Suchstrings als Wahrheitswert und nichts für falsch aus

für 2 Bytes mehr können Sie ersetzen echo$s; mit !!echo$s;bekommen1 als truthy Wert

Suchen Sie das Vorkommen der Eingabe in einer der folgenden Zeichenfolgen im Array

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

JavaScript (ES6), 54 Byte

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>

Übernimmt die Eingabe als Zeichenfolge.

MATL , 15 Bytes

2L&),duw]hSFTX=

Probieren Sie es online!

Mit Hilfe von @LuisMendo im Chat. Beachten Sie, dass, wenn leere Ausgabe + Fehler ebenfalls als "falsch" eingestuft werden, das weggelassen werden Xkann, was die Punktzahl auf 14 Byte erhöht .

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 Bytes

(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 Bytes

ASm.+sMd.Tcz2&-GZ-H1

Ausgabe [] wenn die Zahl mit dem Ziffernmuster übereinstimmt, ansonsten nichts.

Probieren Sie es online!

Erläuterungen (Beispiel mit Eingabe 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 Bytes

qU2Ssm{.+d.TcjQT2

Probieren Sie es hier aus

Gleicher Algorithmus wie meine Jelly-Antwort.

Erläuterung:

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 131 106 Bytes

-55 Bytes dank @ WheatWizard's Vorschlägen

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)

Probieren Sie es online!

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

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

Probieren Sie es online!

Erläuterung:

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
}

Retina , 47 Bytes

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

^1+;1+

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

Probieren Sie es online!

Gibt 1 aus, wenn es mit dem Muster übereinstimmt, und 0, wenn es nicht übereinstimmt

Erläuterung

.
$*11;

Konvertieren Sie jede Ziffer n in n + 1 in unary, getrennt durch Semikolon

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

(Hinterste Zeile) wandelt jede Ziffer in die Differenz zwischen sich selbst und der einen Stelle davor um

^1+;1+

(Hinterer Zeilenumbruch) entfernt die ersten 2 Ziffern

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

Zählt die Anzahl der Übereinstimmungen dieses Musters, wobei nach abwechselnden Nullen und Einsen gesucht wird