Herausforderung

Bestimmen Sie anhand einer gegebenen Liste, ob das Gruppieren der Liste in Reihen von auf- und absteigenden Elementen zu einer Liste von Listen gleicher Größe führt.

Mit anderen Worten, "Wendepunkte" der Liste sind gleichmäßig verteilt.

Beispiel

Hier ist ein Beispiel: 0, 3, 7, 5, 2, 3, 6

0, 3, 7erhöht, 7, 5, 2verringert und 2, 3, 6erhöht. Deshalb ist das wahr.

Ein anderes Beispiel: 1, 4, 6, 8, 5, 3, 5, 7, 9

1, 4, 6, 8erhöht, 8, 5, 3verringert und 3, 5, 7, 9erhöht. Deshalb ist das falsch.

Regeln und Spezifikationen

• Keine benachbarten Elemente werden gleich sein
• Es kann davon ausgegangen werden, dass alle Nummern innerhalb des angemessenen Nummernbereichs Ihrer Sprache liegen
• Sie können davon ausgehen, dass alle Zahlen Ganzzahlen sind, wenn dies Ihnen beim Golfspielen hilft
• Das ist Code-Golf , also gewinnt die kürzeste Antwort
• Eingabe als Liste in einer angemessenen Darstellung und Ausgabe als wahrer / falscher Wert. Die beiden Werte müssen konsistent sein.

Testfälle

Input -> Output
1, 3, 5, 8, 6, 4, 2, 3, 5, 7, 6, 4, 2, 5, 7, 9, 6, 4, 2 -> True
1, 3, 5, 7, 6, 4, 5, 7, 9, 8, 6, 4, 2, 3, 5 -> False
2, 3, 6, 4, 2, 3, 7, 5, 3, 4, 6 -> True
3, 6, 4, 8, 5, 7, 3, 5, 2 -> True
8 -> True
1, 3, 5, 7 -> True
4, 5, 7, 6, 8, 9 -> False
6, 4, 2, 3, 5, 4, 2 -> True
8, 5, 3, 2, 4, 6, 5, 3, 2, 5, 7 -> False

Hinweis : Es kann sein, dass Sie nicht davon ausgehen, dass alle Zahlen einstellig sind (es sei denn, Ihre gesamte Sprache kann damit umgehen). Die Testfälle spiegeln dies wider, nur weil es für mich einfacher ist, die Fälle auf diese Weise einzugeben: P Hier sind einige Testfälle mit Zahlen außerhalb dieses Bereichs:

1, 5, 10, 19, 15, 13, 8, 13, 18, 23, 19, 18, 14 -> True
15, 14, 17, 16, 19, 18 -> True
12, 16, 19, 15, 18, 19 -> False

MATL , 10 9 Bytes

dZS&Y'da~

Probieren Sie es online!

Dank Luis Mendo ein Byte gespart!

Erläuterung:

Angenommen, die Eingabe lautet [0, 3, 7, 5, 2, 3, 6]:

            % Implicit input:                                [0, 3, 7, 5, 2, 3, 6]
d           % Difference between adjacent elements:          [3, 4, -2, -3,  1,  3]
 ZS         % Sign of the differences:                       [1, 1, -1, -1, 1, 1]
   &Y'      % Length of runs of consecutive elements:        [2, 2, 2]
     d      % Difference between the lengths:                [0, 0]
      a     % Any non-zero elements:                         False
       ~    % Negate, to get a truthy value if all are zero: True

Gelee , 6 Bytes

IṠŒgAE

Probieren Sie es online!

Dank Adnan 1 Byte gespart !

Wie es funktioniert

IṠŒgAE - Volles Programm.

I - Inkremente (Deltas).
 Ṡ - Zeichen von jedem. -1 wenn negativ, 0 wenn null, 1 wenn positiv.
  Œg - Gruppenläufe benachbarter Elemente.
    A - Absoluter Wert. Vektorisiert. Dies ordnet -1 und 1 demselben Wert zu.
     E - Sind alle gleich?

Während Golf spielen, entdeckte ich ein paar coole, mehr Alternativen: IṠŒgL€E, IṠŒrṪ€E(Anwendungen lauflängen kodieren statt).

Oktave , 54 50 Bytes

@(x)nnz(unique(diff(find([diff(diff(x)>0) 1]))))<2

Probieren Sie es online!

Erläuterung

@(x)nnz(unique(diff(find([diff(diff(x)>0) 1]))))<2

@(x)                                                % Define anonymous function    
                               diff(x)              % Deltas (consecutive differences)
                                      >0            % Positive? Gives signs
                          diff(         )           % Deltas between signs
                         [                1]        % Append 1 to "close" last group
                    find(                   )       % Indices of nonzeros
               diff(                         )      % Deltas. Gives group lengths
        unique(                               )     % Remove duplicates
    nnz(                                       )    % Number of nonzeros. Gives length
                                                <2  % If 1 or 0: input is periodic

Wolfram Language (Mathematica) , 38 Byte

Equal@@(1^Differences@#~SplitBy~Sign)&

Probieren Sie es online!

Erläuterung

Equal@@(1^Differences@#~SplitBy~Sign)&  (* Input:                {3, 6, 4, 8, 5, 7, 3, 5, 2} *)

          Differences@#                 (* Take differences:     {3, -2, 4, -3, 2, -4, 2, -3} *)
                       ~SplitBy~Sign    (* Split by sign:        {{3}, {-2}, {4}, {-3}, {2}, {-4}, {2}, {-3}} *)
        1^                              (* Raise to power of 1:  {{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}} *)
Equal@@                                 (* Check equal:          True *)

05AB1E , 8 7 Bytes

¥0.SγaË

Probieren Sie es online!

-1 danke an Adnan.

C (GCC) , 143 140 138 136 135 132 Bytes

• Drei Bytes gespeichert; Verwenden einer Variablen rzum Speichern des Rückgabewerts der Funktion, anstatt mit zu beenden return.
• Zwei Bytes gespeichert; Golfen int A[]auf int*A(mit einem Zeiger anstelle eines Arrays).
• Zwei Bytes dank Steadybox gespart ; Golfen f(int*A,int a)zu f(A,a)int*A;.
• Ein Byte gespeichert; Golfen if(d!=...zu if(d-....
• Drei Bytes gespeichert; Golfen ;j++...j+1zu ;...++j.

j,d,e,l,m,r;f(A,a)int*A;{for(d=A[0]>A[1],r=1,j=m=l=0;j-~-a;){l++;if(d-(e=A[j]>A[++j]))d=e,j--,r*=l>=(m=!m?l:m),l=0;}r*=-~l==m||m<1;}

Probieren Sie es online!

Definiert eine Funktion, fdie jedes Element in der Liste außer dem letzten betrachtet und die Beziehung dieses Elements zum nächsten Element in der Liste bestimmt. Die Anzahl aufeinanderfolgender gleicher Vergleiche wird gespeichert, wenn die Beziehung zum ersten Mal umgedreht wird. Alle Läufe nach dem ersten Lauf, deren Länge von der gespeicherten Länge abweicht, führen zu einer falschen Ausgabe. Am Ende wird die Beziehung des vorletzten Elements zum letzten Element so betrachtet, dass sie mit dem Rest der Liste übereinstimmt.

Pyth , 11 Bytes

qFlM.g._k.+

Probieren Sie es hier aus.

Python 2 , 107 105 103 97 96 94 91 Bytes

lambda l:len({sum(g)**2for k,g in groupby(map(cmp,l[:-1],l[1:]))})<2
from itertools import*

Probieren Sie es online!

Python 3 , 102 100 97 Bytes

lambda l:len({len([*g])for k,g in groupby(x>y for x,y in zip(l,l[1:]))})<2
from itertools import*

Probieren Sie es online!

Schale , 7 Bytes

EmLġ±Ẋ-

Probieren Sie es online!

Wie das geht

EmLġ ± Ẋ- ~ Volles Programm.

     Ẋ ~ Über Paare benachbarter Elemente abbilden.
      - ~ Mit Subtraktion (dies berechnet die Deltas)
   ġ ~ Gruppiere unter Verwendung des Gleichheitsprädikats.
    ± ~ Vorzeichen.
 ml ~ Holen Sie sich die Längen.
E ~ Sind alle gleich?

Einige süße Alternativen:

εġLġ±Ẋ-
εüLġ±Ẋ-

JavaScript (ES6), 81 Byte

Das scheint zu lang. Vermutlich fehlt mir hier etwas ... Rückgabe entweder trueoder undefined.

f=(a,p=1)=>a.every((n,i)=>!i|!(1/(y=a[i+1]))|!(i%p)^y>n^a[i-1]>n)||a[p]&&f(a,p+1)

Sucht nach einer Periode 0 <p <a.Länge, so dass alle Richtungsänderungen bei jedem p- Element auftreten.

Testfälle

f=(a,p=1)=>a.every((n,i)=>!i|!(1/(y=a[i+1]))|!(i%p)^y>n^a[i-1]>n)||a[p]&&f(a,p+1)

console.log(f([1, 3, 5, 8, 6, 4, 2, 3, 5, 7, 6, 4, 2, 5, 7, 9, 6, 4, 2])) // -> True
console.log(f([1, 3, 5, 7, 6, 4, 5, 7, 9, 8, 6, 4, 2, 3, 5])) // -> False
console.log(f([2, 3, 6, 4, 2, 3, 7, 5, 3, 4, 6])) // -> True
console.log(f([3, 6, 4, 8, 5, 7, 3, 5, 2])) // -> True
console.log(f([8])) // -> True
console.log(f([1, 3, 5, 7])) // -> True
console.log(f([4, 5, 7, 6, 8, 9])) // -> False
console.log(f([15, 14, 17, 16, 19, 18])) // -> True
console.log(f([19, 15, 14, 17, 18, 17, 16, 19, 20])) // -> True

Python 2 , 96 Bytes

import re
def f(x):exec"x=map(cmp,x[1:],x[:-1]);"*2;re.match('.([^1]*)(-?1, \\1)*9',`x+[9]`)<0<_

Probieren Sie es online! Ausgabe über Exit-Code: crash (1) ist falsch, clean exit (0) ist wahr.

Python 2 , 106 Bytes

def f(x):d=map(cmp,x[1:],x[:-1]);l=len(d);s=(d+[0])[0];k=(d+[-s]).index(-s);print((k*[s]+k*[-s])*l)[:l]==d

Probieren Sie es online!

Haskell , 79 78 77 Bytes

import Data.List
g s|h:t<-(1<$)<$>group(zipWith(<)s$tail s)=all(==h)t
g _=1<3

Probieren Sie es online!

Eine Liste gegeben s , zipWith(<)s$tail sTests für jedes Element , ob er kleiner ist als sein Nachfolger, zB s=[2,3,6,4,2,3,7,5,3]Ausbeuten [True,True,False,False,True,True,False,False]. Danngroup läuft die gleichen Elemente zusammen: [[True,True],[False,False],[True,True],[False,False]]. Um zu überprüfen , ob alle diese Listen die gleiche Länge haben, ersetzen ihre Elemente mit 1( siehe diesen Tipp ) nachgebend [[1,1],[1,1],[1,1],[1,1]]und prüfen , ob alle Elemente in den Schwanz tdieser Liste den Kopf gleich h: all(==h)t.

Dieser Ansatz funktioniert nicht für Singleton - Listen, sondern weil die immer wahr sind, können wir sie in ihrem eigenen Fall behandeln: g[_]=1<3.

R , 57 Bytes

function(x){d=diff
sum(rle(d(which(!!d(d(x)>0))))$v^0)<2}

Probieren Sie es online!

Japt , 15 Bytes

ä- mg ò¦ mÊä¥ e

Probieren Sie es online!

Erläuterung

ä- mg ò¦ mÊä¥ e                                                  [0,3,7,5,2,3,6]
ä-                // Difference between neighboring elements     [-3,-4,2,3,-1,-3]
   mg             // Get the sign of each element                [-1,-1,1,1,-1,-1]
      ò¦          // Partition between different elements        [[-1,-1],[1,1],[-1,-1]]
         mÊ       // Get the length of each element              [2,2,2]
           ä¥     // Check for uniqueness                        [true,true]
              e   // Return true if all elements are truthy      true

R, 36 Bytes

function(n)!sd(rle(sign(diff(n)))$l)

diffberechnet die aufeinanderfolgenden Differenzen und signzerquetscht diese dann auf ± 1. rleDann codiert sie die Lauflänge. Alle Elemente davon rlesollten gleich sein, dh der Vektor hat die Standardabweichung Null. !erzeugt dann die richtige logische Ausgabe.

Haskell (Lambdabot), 59 Bytes

g(map(1<$).group.ap(zipWith(<))tail->h:t)=all(==h)t;g _=1<3

Basierend auf der Antwort von @ Laikoni

Java (OpenJDK 8) , 437 302 256 188 Bytes

a->{int i=0,g=0,x=0,l=0;String d="";for(;i<~-a.length;d+=a[0].compare(a[i+1],a[i++])+1);for(String s:d.split("(?<=(.))(?!\\1)"))if(g++<1)x=s.length();else if(s.length()!=x)l++;return l<1;}

Probieren Sie es online!

Clojure, 70 Bytes

#({0 1 1 1}(count(set(map count(partition-by pos?(map -(rest %)%))))))

Gibt 1als wahr und nil(AKA null) als falsch zurück.

Java (OpenJDK 8) , 135 Byte

a->{Integer i=0,c,d=0,p=0,r=0;for(;++i<a.length;)d+=(i<2|(c=i.signum(a[i-1]-a[i]))<0?d<0:d>0)?c:p==0|p==-d?c-(p=d):1-(r=1);return r<1;}

Probieren Sie es online!

Erklärungen

a->{                    // int array
 Integer i=0,c,d=0,p=0,r=0;
                        // variable definitions, use Integer to abuse static calls
 for(;++i<a.length;)    // Loop from 1 till length - 1
  d+=                   // Change d
   (i<2                 // First iteration?
     |(c=i.signum(a[i-1]-a[i]))<0?d<0:d>0
   )                    // Or do c and d have the same sign?
    ?c                  // then increase the magnitude of d.
    :p==0|p==-d         // else we're in a u-turn. Is it the first? Or is the magnitude the same as previously?
     ?c-(p=d)           // assign the new magnitude with sign to p and reset d to -1 (if was positive) or 1 (if was negative)
     :1-(r=1);          // else just do r=1 (technically: "add 1-1=0 to d" as well)
 return r<1;            // return whether there were wrong amplitudes.
}

Python 2 , 110 99 Bytes

-11 Bytes dank @Lynn

d=input()
exec"d=map(cmp,d[:-1],d[1:]);"*2
x=[i+1for i,e in enumerate(d)if e]
for i in x:i%x[0]>0<q

Probieren Sie es online!

Ruby , 57 Bytes

->a{!a.each_cons(2).chunk{|x,y|x>y}.uniq{|*,x|x.size}[1]}

Probieren Sie es online!