Schreiben Sie ein Programm, um zu bestimmen, ob eine periodische Folge von positiven ganzen Zahlen die Eigenschaft hat, dass für jede nin der Folge vorkommende ganze Zahl nzwischen zwei aufeinanderfolgenden Vorkommen von nie mehr als andere ganze Zahlen liegen n.

Hat beispielsweise 2, 3, 5, 2, 3, 6, 2, 3, 5, 2, 3, 6, ...diese Eigenschaft: Jedes Paar aufeinanderfolgender Vorkommen von 2darf höchstens zwei Ganzzahlen zwischen sich haben (z. B. 2, 3, 5, 2und2, 3, 6, 2 ; jedes Paar aufeinanderfolgender Vorkommen von 3hat höchstens drei Ganzzahlen dazwischen; und dasselbe für 5und 6.

Jedoch, 2, 3, 5, 2, 3, 4, 2, 3, 5, 2, 3, 4, ... Eigenschaft besitzt jedoch nicht: Zwei aufeinanderfolgende Vorkommen von 4haben nämlich 4, 2, 3, 5, 2, 3, 4mehr als vier Ganzzahlen zwischen sich.

Eingang : Eine sinnvolle Darstellung einer periodischen Folge von positiven ganzen Zahlen. Zum Beispiel kann eine endliche Liste, wie oben {2, 3, 5, 2, 3, 6}die erste unendliche Folge darstellen 2, 3, 5, 2, 3, 6, 2, 3, 5, 2, 3, 6, .... (Diesbezüglich könnte das Problem für endliche Listen angegeben werden, die sich umlaufen, anstatt für unendliche periodische Listen.)

Ausgabe : ein wahrer / falscher Wert.

Wahrheitsbeispiele:

{1}
{8, 9}
{2, 3, 4}
{5, 5, 3, 3, 6}
{2, 3, 5, 2, 3, 6}
{6, 7, 3, 5, 3, 7}
{9, 4, 6, 7, 4, 5}
{1, 1, 1, 1, 1, 100, 1}
{1, 9, 1, 8, 1, 7, 1, 11}

Falsche Beispiele:

{1, 2, 3}
{2, 3, 9, 5}
{3, 5, 4, 4, 6}
{2, 3, 5, 2, 3, 4}
{3, 5, 7, 5, 9, 3, 7}
{5, 6, 7, 8, 9, 10, 11}
{1, 9, 1, 8, 1, 6, 1, 11}

Das ist Codegolf , also gewinnt der kürzeste Code. Antworten in allen Sprachen sind erwünscht.

Haskell, 60 57 56 55 Bytes

f(a:b)=b==[]||length(fst$span(/=a)b)<=a&&f b
g x=f$x++x

Angenommen, die Eingabeliste enthält mindestens ein Element.

Anwendungsbeispiel: g [1]-> True. Probieren Sie es online!

Sei ader Kopf der Liste und bder Schwanz. Das Ergebnis ist, Truewenn bleer ist oder die Anzahl der Elemente am Anfang b, die nicht gleich aist, nicht größer ist als aund der rekursive Aufruf von f bist auch Truesonst False. Beginnen Sie mit der doppelten Eingabeliste.

Edit: @Leo hat 3 Bytes gespeichert. Vielen Dank!

Edit 2: @Laikoni hat 1 Byte gespeichert. Vielen Dank!

Python , 57 56 Bytes

-1 Byte dank Dennis (Ersetzen i+1:i+v+2durch i:i-~vmit einem iVersatz von 1 von enumerate)

lambda a:all(v in(a+a)[i:i-~v]for i,v in enumerate(a,1))

Probieren Sie es online!

Unnamed Funktion nimmt eine Liste, aund die Bedingung , dass die Prüfung jeder Wert, verscheint indie entsprechende Scheibe zu ihrem Recht in einer Verkettung amit mir selbst (a+a)[i:i-~v], wobei der 1-basierten Index vin a, i, vorgesehen ist , durch enumerate(a,1).

JavaScript (ES6), 67 65 55 54 51 49 Byte

3B dank @ETHproductions und 2B dank @Arnauld gespeichert

a=>!a.some((b,c)=>a.concat(a).indexOf(b,++c)>b+c)

Erläuterung

Dies definiert eine Funktion, die ein Array aals Eingabe verwendet. Anschließend .somedurchläuft die Methode dieses Array und führt für jedes Element eine andere Funktion aus.

Diese innere Funktion akzeptiert zwei Argumente, bund zwar cden aktuellen Wert und seinen Index. Die Funktion findet den Index des aktuellen Wertes, beginnend mit dem Indexc + 1 . Anschließend wird geprüft, ob dieser Index größer als der aktuelle Wert plus der aktuelle Index ist (die Differenz zwischen zwei Vorkommen desselben Werts ist größer als b). Beachten Sie, dass dies genau das Gegenteil von dem ergibt, was wir wollen.

Wenn einer dieser Rückgabewerte ist true, .somekehrt die Funktion ebenfalls zurück true. Wenn keiner der Schecks zurückkehrt true, wird der.some kehrt Funktion zurückfalse . Wieder das Gegenteil des Werts, den wir zurückgeben möchten, sodass dieses Ergebnis negiert und dann zurückgegeben wird.

Probier es aus

Probieren Sie alle Testfälle hier aus:

let f=
a=>!a.some((b,c)=>a.concat(a).indexOf(b,++c)>b+c)

let truthy = [[1], [8, 9], [2, 3, 4], [5, 5, 3, 3, 6], [2, 3, 5, 2, 3, 6], [6, 7, 3, 5, 3, 7], [9, 4, 6, 7, 4, 5], [1, 1, 1, 1, 1, 100, 1], [1, 9, 1, 8, 1, 7, 1, 11]];
let falsy  = [[1, 2, 3], [2, 3, 9, 5], [3, 5, 4, 4, 6], [2, 3, 5, 2, 3, 4], [3, 5, 7, 5, 9, 3, 7], [5, 6, 7, 8, 9, 10, 11], [1, 9, 1, 8, 1, 6, 1, 11]];

console.log("Truthy test cases:");
for (let test of truthy) {
    console.log(`${test}: ${f(test)}`);
}

console.log("Falsy test cases:");
for (let test of falsy) {
    console.log(`${test}: ${f(test)}`);
}

Jelly , 11 Bytes

ṣZL
;çЀ<‘P

Probieren Sie es online!

Wie es funktioniert

;çЀ<‘P  Main link. Argument: A (array)

;        Concatenate A with itself.
 çD€     For each n in A, call the helper with left arg. A + A and right arg. n.
     ‘   Increment all integers in A.
    <    Perform element-wise comparison of the results to both sides.
      P  Take the product of the resulting Booleans.


ṣZL      Helper link. Left argument: A. Right argument: n

ṣ        Split A at all occurrences of n.
 Z       Zip to transpose rows and columns.
  L      Length; yield the number of rows, which is equal to the number of columns
         of the input to Z.

Gelee , 8 Bytes

ṙJḣ"‘Œpċ

Beeindruckt von @ JonathanAllans Python-Antwort .

Probieren Sie es online!

Wie es funktioniert

ṙJḣ"‘Œpċ  Main link. Argument: A (array)

 J        Yield the indicies of A, i.e., [1, ..., len(A)].
ṙ         Rotate; yield A, rotated 1, ..., and len(A) units rotated to the left.
    ‘     Increment; add 1 to all elements of A.
  ḣ"      Head zipwith; truncate the n-th rotation to length A[n]+1.
     Œp   Take the Cartesian product of all resulting truncated rotations.
       ċ  Count the number of times A appears in the result.

SWI-Prolog, 83 Bytes

a(L,[H|R]):-nth0(X,R,H),H>=X,a(L,R);length(R,N),nth0(X,L,H),H>=N+X,a(L,R).
a(_,[]).

Die Liste sollte zweimal eingegeben werden:

a([1,2,3],[1,2,3]).

Wenn dies nicht als akzeptabel angesehen wird, können Sie das Prädikat hinzufügen

a(L):-a(L,L).

Das fügt zusätzliche 14 Bytes hinzu.

Probieren Sie es online aus

nb: Sie können auf verschiedene falsche Fälle gleichzeitig testen, indem Sie Ihre Anfragen mit ';' trennen. (oder) und auf verschiedene wahre Fälle prüfen, indem mit ',' (und) getrennt wird

dh unter Verwendung der OP-Beispiele:

a([1],[1]),
a([8, 9],[8, 9]),
a([2, 3, 4],[2, 3, 4]),
a([5, 5, 3, 3, 6],[5, 5, 3, 3, 6]),
a([2, 3, 5, 2, 3, 6],[2, 3, 5, 2, 3, 6]),
a([6, 7, 3, 5, 3, 7],[6, 7, 3, 5, 3, 7]),
a([9, 4, 6, 7, 4, 5],[9, 4, 6, 7, 4, 5]),
a([1, 1, 1, 1, 1, 100, 1],[1, 1, 1, 1, 1, 100, 1]),
a([1, 9, 1, 8, 1, 7, 1, 11],[1, 9, 1, 8, 1, 7, 1, 11]).

und

a([1, 2, 3],[1, 2, 3]);
a([2, 3, 9, 5],[2, 3, 9, 5]);
a([3, 5, 4, 4, 6],[3, 5, 4, 4, 6]);
a([2, 3, 5, 2, 3, 4],[2, 3, 5, 2, 3, 4]);
a([3, 5, 7, 5, 9, 3, 7],[3, 5, 7, 5, 9, 3, 7]);
a([5, 6, 7, 8, 9, 10, 11],[5, 6, 7, 8, 9, 10, 11]);
a([1, 9, 1, 8, 1, 6, 1, 11],[1, 9, 1, 8, 1, 6, 1, 11]).

PHP, 52 Bytes

for(;$n=$argv[++$i];$$n=$i)!$$n|$i-$$n<$n+2?:die(1);

Nimmt die Reihenfolge der Befehlszeilenargumente an. Ausgänge mit Code 1für falsch, 0für wahr.
Laufen Sie mit -nr.

• Schleife $ndurch Argumente:
  • Wenn es kein vorheriges Vorkommen gab oder es aktuell genug
    war, nichts tun, andernfalls mit Code beenden1
  • Erinnere dich an das vorherige Vorkommen in $$n( variable Variablen )
• Exit mit Code 0(implizit)

Netzhaut , 50 Bytes

$
,$`
M!&`\b(1+),.*?\b\1\b
+%`(^1*)1,1+
$1
M`1,
^0

Eingabe als Liste von durch Kommas getrennten unären Zahlen.

Probieren Sie es online!

Erläuterung

$
,$`

Duplizieren Sie die Eingabe, um die am Ende umlaufenden Schritte zu überprüfen.

M!&`\b(1+),.*?\b\1\b

Ordnen Sie jedem (kürzesten) Abschnitt zwei identische Werte zu und geben Sie sie zurück, z 11,111,1,11.

+%`(^1*)1,1+
$1

Entfernen Sie wiederholt eine Ziffer von der ersten Ziffer zusammen mit einer ganzen Zahl danach. Wenn die Lücke klein genug ist, wird die erste Zahl vollständig entfernt. Andernfalls bleibt mindestens eine Ziffer übrig.

M`1,

Zählen Sie, wie oft 1,in allen Zeilen angezeigt wird. Wenn es irgendwo auftaucht, war eine der Stufen zu breit.

^0

Versuchen Sie, eine Zahl zu finden, die mit 0(dh nur sich 0selbst) beginnt . Dies ist praktisch eine logische Negation der Ausgabe.

JavaScript (ES6), 47 Byte

a=>![...a,...a].some((n,i)=>a[-n]-(a[-n]=i)<~n)

Wie es funktioniert

Wir verwenden das Eingabearray erneut a, um die Position des letzten Vorkommens jeder Ganzzahl in zu speichern a. Wir verwenden den Schlüssel -n, um diese Position zu speichern, damit sie nicht mit den ursprünglichen Indizes von interferiert a.

Wenn a[-n]vorhanden, wird der eigentliche Test durchgeführt. Wenn a[-n]nicht vorhanden, ist der Ausdruck a[-n] - (a[-n] = i)gleich undefined - i == NaNund der Vergleich mit~n ist immer falsch, was das erwartete Ergebnis ist.

Testfälle

f=
a=>![...a,...a].some((n,i)=>a[-n]-(a[-n]=i)<~n)

console.log('Truthy cases:');
console.log(f([1]));
console.log(f([8, 9]));
console.log(f([2, 3, 4]));
console.log(f([5, 5, 3, 3, 6]));
console.log(f([2, 3, 5, 2, 3, 6]));
console.log(f([6, 7, 3, 5, 3, 7]));
console.log(f([9, 4, 6, 7, 4, 5]));
console.log(f([1, 1, 1, 1, 1, 100, 1]));
console.log(f([1, 9, 1, 8, 1, 7, 1, 11]));

console.log('Falsy cases:');
console.log(f([1, 2, 3]));
console.log(f([2, 3, 9, 5]));
console.log(f([3, 5, 4, 4, 6]));
console.log(f([2, 3, 5, 2, 3, 4]));
console.log(f([3, 5, 7, 5, 9, 3, 7]));
console.log(f([5, 6, 7, 8, 9, 10, 11]));
console.log(f([1, 9, 1, 8, 1, 6, 1, 11]));

Retina ,  41 bis 39 Bytes

2 Bytes Golf dank Martin Ender, der mich übrigens mit seinem fantastischen Guide über SO in die Bilanzgruppe einführte

$
,$`,
((1)+,)(?=(?<-2>1+,)*(\1|$))

^$

Die Eingabe ist eine durch Kommas getrennte Liste von unären Zahlen. Die Ausgabe erfolgt 0für falsch und 1für wahr.

Probieren Sie es online! (Testsuite, die automatisch von dezimal konvertiert)

Ich habe kürzlich etwas über Bilanzkreise gelernt und wollte sie ausprobieren. Sie gehören nicht zu den am einfachsten zu verwendenden Werkzeugen, sind aber sicher leistungsstark.

Erläuterung

$
,$`,

Wie bei vielen anderen Einsendungen duplizieren wir die Liste, um den Zeilenumbruch zu behandeln. Wir fügen am Ende auch ein Komma hinzu, sodass auf jede Zahl ein Komma folgt (dies erleichtert die Sache später ein bisschen).

((1)+,)(?=(?<-2>1+,)*(\1|$))

Hier wird es interessant. Dies ist eine Ersetzungsphase. Wir ersetzen alles, was mit der ersten Zeile übereinstimmt, durch die zweite Zeile. In diesem Fall möchten wir alle Zahlen entfernen, denen nkeine n+1anderen Zahlen folgen .

Dazu stimmen wir zuerst mit der Nummer überein und erfassen jede 1in einer Gruppe (in diesem Fall mit der Gruppennummer 2). Bei einem positiven Ausblick versuchen wir dann wiederholt, eine Übereinstimmung in einer Bilanzgruppe zu erzielen -2, die nicht mehr als die Anzahl der von der Gruppe durchgeführten Erfassungen erreicht2 , gefolgt von einem Komma, erreicht. Nach dieser Zahlenfolge sind wir zufrieden, wenn wir wieder die erste Zahl oder das Zeilenende erreichen.

Hinweis: Dieser Ausdruck kann nur mit dem letzten Teil einer Zahl übereinstimmen, wenn es nicht gelingt, eine Übereinstimmung mit der vollständigen Zahl zu finden. Dies ist kein Problem, da dann der erste Teil der Zahl in der Zeichenfolge verbleibt und wir wissen, dass die Ersetzung nicht vollständig erfolgreich war.

^$

Schließlich sollte das Ergebnis wahr sein, wenn wir alle Zahlen vollständig aus der Liste entfernt haben. Wir versuchen, die leere Zeichenfolge abzugleichen und die Anzahl der gefundenen Übereinstimmungen zurückzugeben.

Jelly , 11 Bytes

ẋ2ĠṢI_2<"QȦ

Probieren Sie es online!

ẋ2ĠṢI_2<"QȦ  Main link. Argument: A (array)

ẋ2           Repeat A twice to account for wrap-around.
  Ġ          Group all indices of A + A by their respective values, sorting the
             index groups by the associated values.
   Ṣ         Sort the groups lexicographically, i.e., by first appearance in A.
    I        Increments; compute the forward differences of adjacent indices in
             each of the groups.
     _2      Subtract 2 from the differences.
         Q   Unique; yield A, deduplicated.
       <"    Compare all differences in the index group corresponding to the n-th
             unique value in A with the n-th unqiue value in A.
          Ȧ  All; yield 1 if and only if none of the comparisons returned 0.

Python 3 , 101 Bytes

lambda l:all(v>=(l[i+1:].index(v)if v in l[i+1:]else len(l[i+1:])+l.index(v))for i,v in enumerate(l))

Probieren Sie es online!

Röda , 50 Bytes

f a{seq 0,#a-1|[indexOf(a[_],a[_1+1:]..a)<=a[_1]]}

Probieren Sie es online!

Endlich! Ich habe gewartet für diese Herausforderung ...

Es ist eine Funktion, die einen wahren oder falschen Wert zurückgibt. Es braucht ein Argument, das Array.

Es durchläuft einen Strom von Indizes und prüft für jeden Index, _1ob der Abstand zwischen dem aktuellen Index und dem nächsten Index a[_1]nicht größer als ist a[_1].

05AB1E , 13 Bytes

Dì©v®¦©yky›_P

Probieren Sie es online! oder als Testsuite

Erläuterung

Dì             # duplicate input and prepend the copy to the original
  ©            # store a copy in the register
   v           # for each element in the list
    ®          # push the list from register
     ¦©        # remove the first element and store a copy in the register
       yk      # get the index of the current element in the list
         y›_   # check if it's less than or equal to the current element
            P  # product of stack