Meydan okuma

Bir liste verildiğinde, listenin artan ve azalan öğelerin çalışmalarında gruplanmasının eşit boyutlu listelerin bir listesiyle sonuçlanıp sonuçlanmayacağını belirleyin.

Başka bir deyişle, listenin "dönüm noktaları" eşit aralıklarla yerleştirilir.

Misal

İşte bir örnek: 0, 3, 7, 5, 2, 3, 6

0, 3, 7artar, 7, 5, 2azalır ve 2, 3, 6artar. Dolayısıyla bu doğrudur.

Başka bir örnek: 1, 4, 6, 8, 5, 3, 5, 7, 9

1, 4, 6, 8artar, 8, 5, 3azalır ve 3, 5, 7, 9artar. Bu yüzden bu sahtelik.

Kurallar ve Spesifikasyonlar

• Hiçbir bitişik öğe eşit olmayacak
• Tüm sayıların dilinizin makul sayı aralığında olduğu varsayılabilir
• Gönderinizi golf oynamanıza yardımcı olursa, tüm sayıların tamsayı olduğunu varsayabilirsiniz.
• Bu kod golf , bu yüzden en kısa cevap kazanır
• Herhangi bir makul gösterimde bir liste olarak girin ve herhangi bir doğruluk / falsy değeri olarak çıktı alın. İki değer tutarlı olmalıdır.

Test Durumları

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

Not : Tüm sayıların tek haneli olduğunu varsayamazsınız (dilinizin tamamı işleyemezse); test senaryoları, vakaları bu şekilde yazmamın daha kolay olması nedeniyle bunu yansıtır: P İşte bu aralığın dışında sayıları olan birkaç test vakası:

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 bayt

dZS&Y'da~

Çevrimiçi deneyin!

Luis Mendo sayesinde bir bayt kurtardı!

Açıklama:

Girdinin [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

Jöle , 6 bayt

IṠŒgAE

Çevrimiçi deneyin!

Adnan sayesinde 1 bayt kurtardı !

Nasıl çalışır

IṠŒgAE - Tam program.

I - Artışlar (Deltalar).
 Ṡ - Her birinin işareti. Negatifse -1, boşsa 0, pozitifse 1.
  Œg - Bitişik elemanların grup çalışması.
    A - Mutlak değer. Vektörleştirir. Bu -1 ve 1'i aynı değere eşler.
     E - Hepsi eşit mi?

Golf ederken, bazı serin, daha uzun alternatifler keşfetti: IṠŒgL€E, IṠŒrṪ€E(kullanım çalıştırmak uzunlukta kodlamak yerine).

Oktav , 54 50 bayt

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

Çevrimiçi deneyin!

açıklama

@(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 Dili (Mathematica) , 38 bayt

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

Çevrimiçi deneyin!

açıklama

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 bayt

¥0.SγaË

Çevrimiçi deneyin!

-1 Adnan sayesinde.

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

• Üç bayt kurtardı; rişlevini kullanarak sonlandırmak yerine dönüşün boole değerini depolamak için bir değişken kullanma return.
• İki bayt kaydedildi; golf int A[]için int*A(bir işaretçi kullanılarak yerine bir dizi).
• Steadybox sayesinde iki bayt tasarruf edildi ; golf f(int*A,int a)için f(A,a)int*A;.
• Bir bayt kaydedildi; golf if(d!=...için if(d-....
• Üç bayt kurtardı; golf ;j++...j+1için ;...++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;}

Çevrimiçi deneyin!

fListedeki her öğeye ancak sonuncuya bakan ve bu öğenin listedeki bir sonraki öğeyle ilişkisini belirleyen bir işlevi tanımlar . Ardışık eşit karşılaştırmaların sayısı, ilişki ilk kez çevrildiğinde kaydedilir, ilk çalıştırmadan sonra uzunluğu depolanan uzunluktan farklı olan herhangi bir çalışma, hatalı bir çıktı ile sonuçlanır. Sonunda, ikinci öğeden son öğeye son öğenin ilişkisine bakılır, böylece listenin geri kalanıyla eşleşir.

Pyth , 11 bayt

qFlM.g._k.+

Burada deneyin.

Piton 2 , 107 105 103 97 96 94 91 bayt

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

Çevrimiçi deneyin!

Piton 3 , 102 , 100 97 bayt

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

Çevrimiçi deneyin!

Kabuk , 7 bayt

EmLġ±Ẋ-

Çevrimiçi deneyin!

Bu nasıl çalışır?

EmLġ ± Ẋ- ~ Tam program.

     Bitişik elemanların çiftleri üzerinde eşleyin.
      - ~ Çıkarma ile (bu deltaları hesaplar)
   Eşitlik yüklemini kullanan grup.
    ± İşaret.
 mL ~ Uzunlukları alın.
E ~ Hepsi eşit mi?

Bazı sevimli alternatifler:

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

JavaScript (ES6), 81 bayt

Bu çok uzun görünüyor. Muhtemelen burada bir şey eksik ... Ya trueda geri döner 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)

Tüm yön değişikliklerinin her p öğesinde meydana geleceği şekilde 0 <p <a. Uzunluğunda bir süre arar .

Test senaryoları

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 bayt

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

Çevrimiçi deneyin! Çıkış kodu ile çıktı: çökme (1) falsey, temiz çıkış (0) doğrudur.

Python 2 , 106 bayt

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

Çevrimiçi deneyin!

Haskell , 79 78 77 bayt

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

Çevrimiçi deneyin!

Bir liste verildiğinde s, zipWith(<)s$tail sher eleman için halefinden daha küçük olup olmadığını test eder, örneğin s=[2,3,6,4,2,3,7,5,3]verim [True,True,False,False,True,True,False,False]. Sonra groupbirlikte aynı elemanların çalıştırır: [[True,True],[False,False],[True,True],[False,False]]. , Tüm bu listeler aynı uzunluğa sahip olup olmadığını kontrol ile elemanlarını değiştirmek için 1( bu uç bakınız ) elde [[1,1],[1,1],[1,1],[1,1]]ve kuyruk tüm elemanları kontrol tBu listenin baş eşit h: all(==h)t.

Bu yaklaşım tekil listeler için çalışmaz, ancak bu her zaman doğru olduğu için, biz kendi halinde bunları işleyebilir: g[_]=1<3.

R , 57 bayt

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

Çevrimiçi deneyin!

Japt , 15 bayt

ä- mg ò¦ mÊä¥ e

Çevrimiçi deneyin!

açıklama

ä- 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 bayt

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

diffbirbirini izleyen farkları hesaplar, sonra sign± 1'e düşürür. rlesonra çalışma uzunluğu bunları kodlar. Bunun tüm elemanları rleaynı olmalıdır, yani vektörün standart sapması sıfırdır. !sonra doğru mantıksal çıktıyı üretir.

Haskell (Lambdabot), 59 bayt

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

@ Laikoni'nin cevabına dayanarak

Java (OpenJDK 8) , 437 302 , 256 188 bayt

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

Çevrimiçi deneyin!

Clojure, 70 bayt

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

İade 1truthy gibi nilfalsy olarak (AKA null).

Java (OpenJDK 8) , 135 bayt

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

Çevrimiçi deneyin!

açıklamalar

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 bayt

@Lynn sayesinde -11 bayt

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

Çevrimiçi deneyin!

Yakut , 57 bayt

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

Çevrimiçi deneyin!