Bir düzensiz sayı, rakamlarının arasında değiştiği bir sayıdır aşağıdaki sayı gibi yukarı ve aşağı değiştiği bir sayıdır: 461902 veya 708143, hatta 1010101, ancak 123 değil, çünkü 2 <3.

Bir program ya da fonksiyonu bir sayı ise bir truthy değerini verir Yazın dalgalı , ve aksi takdirde falsy değer. En kısa kod kazanır.

Not : Tek haneli sayılar geçerli bir girdidir, ancak udulant olarak kabul edilmez , bu nedenle isUndulantn <10 için false değerini döndürür.

J, 45

*./(n>9),(}:(=-)}.)(}:*@-}.)n#:~10$~>.10^.n=.

Örnek kullanım:

   *./(n>9),(}:(=-)}.)(}:*@-}.)n#:~10$~>.10^.n=. 461902
1
   *./(n>9),(}:(=-)}.)(}:*@-}.)n#:~10$~>.10^.n=. 708143
1
   *./(n>9),(}:(=-)}.)(}:*@-}.)n#:~10$~>.10^.n=. 1010101
1
   *./(n>9),(}:(=-)}.)(}:*@-}.)n#:~10$~>.10^.n=. 123
0
   *./(n>9),(}:(=-)}.)(}:*@-}.)n#:~10$~>.10^.n=. 5
0

Eminim /, bir seferde daha fazla iş yapmak için Insert'u çevirmenin daha iyi bir yolu var , ama aylardır J-less oldum, geri dönmem gerekiyor.

Ruby, 72 70 karakter

Q=10;k=->n,v{(n%Q-n/Q%Q)*v<0?k[n/Q,-v]:n<Q};u=->n{n>9&&k[n,-1]|k[n,1]}

Kullanım ve testcases:

p u[10101]   # <= true
p u[708143]  # <= true
p u[2421]    # <= false
p u[1231]    # <= false
p u[873]     # <= false

Tek hane yanlış verir :

p u[5]       # <= false

Ardışık özdeş rakamlar da yanlış döndürür :

p u[66]      # <= false
p u[1221]    # <= false

J, 30 bayt

*/0<(#,]*{.*1 _1$~#)2-/\a.i.":

Diğer J cevaplarından farklı bir yaklaşım.

   * / 0 <(#,] * {. * 1 _1 $ ~ #) 2 - / \ ai ": 461902
1
   * / 0 <(#,] * {. * 1 _1 $ ~ #) 2 - / \ ai ": 708143
1
   * / 0 <(#,] * {. * 1 _1 $ ~ #) 2 - / \ ai ": 1010101
1
   * / 0 <(#,] * {. * 1 _1 $ ~ #) 2 - / \ ai ": 123
0
   * / 0 <(#,] * {. * 1 _1 $ ~ #) (} .-} :) ai ": 5
0

5 inatçı kabul edilirse 3 karakter daha kısa olurdu.

(pdf) eTeX, 129 karakter

\def\a#1#2{\if#2?\ifx\r\s\def\s{1}\else
True\end\fi\fi\edef\t{\pdfstrcmp{#2}{#1}}\ifx\s\t
False\end\fi\let\s\t\a#2}\expandafter\a

İle derleme pdfetex filename.tex 1324?bir pdf çıktı verir. TeX öncelikle dizgi yapan bir dildir ve stdout yerine çıktı almak yaklaşık 20 karakter daha sürecektir. Ayrıca tek basamaklı sayılar için garip gereksinim (doğru yerine yanlış) bana 26 karakter getiriyor.

Haskell, 88 77 73 65 karakterler

z=tail>>=zipWith compare
q[]=0>1
q s=all(/=EQ)$s++z s
u=q.z.show

Bu yaygın olarak kullanılan dil pragma (ya gerektirir -Xbayrağı): NoMonomorphismRestriction. Bunu kabul etmiyorsanız, 4 karakter eklememiz ve bunu tanımlamamız gerekir z:

z s=zipWith compare s$tail s

Adaçayı, 83 76 bayt

f=lambda x:uniq(cmp(*`x`[i-2:i][::(-1)^i])for i in[2..len(`x`)])in[[1],[-1]]

JBernardo'dan cmp (* [..]) kullanma fikrim var. Sage, uniq(...)için bir takma addır list(set(...)).

Düzenleme: sadece uniq(cmp(...)) == []açık olmayan x <10 için fark ettim [[1],[-1]]. Eğer x tamsayı yerine dize olarak girilseydi, 4 karakter daha alabilirim!

Python: 101100 karakter

Küçültmeden önce:

undulate = (lambda n: n > 9
            and all(cmp(*digits) == (i % 2) * 2 - 1
                    for i, digits
                    in enumerate(zip(min(`n`,`n`[1:]), 
                                     max(`n`,`n`[1:])))))

Küçültmeden sonra:

a=lambda b:b>9and all(cmp(*c)==d%2*2-1 for d,c in enumerate(zip(min(`b`,`b`[1:]),max(`b`,`b`[1:]))))

Python, 134 129 karakter

def f(x):d=[cmp(*i)for i in zip(`x`,`x`[1:])]if x>9 else[0];n=d[0]>0;return all(i<0 for i in d[n::2])&all(i>0 for i in d[n<1::2])

Ungolfed:

def f(x):
    if x>9:
        d = [cmp(*i)for i in zip(`x`,`x`[1:])] #difference of x[i] and x[i+1]
    else:
        d = [0]       #trick to return False if x<10 using less chars
    n = d[0]>0        #First digit is -1 or 1?
    neg = d[n::2]     #negative numbers if x is Undulant
    pos = d[not n::2] #positive numbers if x is Undulant

    #check if all negs are -1 and all pos are 1 and return value
    return all(i<0 for i in neg) and all(i>0 for i in pos)

JavaScript, 88 karakter

function _(i){i+='';c=i[0];f=i[a=x=1];for(g=f<c;d=i[x++];c=d)g^=a&=g?d<c:d>c;return!f^a}

Özünde, sayıyı bir dizeye dönüştürün ve bitişik karakterleri karşılaştırın, her biri için beklentiyi ters çevirin.

K, 41 bayt

{(x>9)&~max(=). 1_'-':'1_'(<':;>':)@\:$x}

Örneğin

{(x>9)&~max(=). 1_'-':'1_'(<':;>':)@\:$x}1212130659
1b

CoffeeScript, 98 67 53 bayt

(n)->0!in((n[i]>=c^(n[0]<n[1])+i)%2for c,i in n[1..])

Testler:

[
    '01010101' # true
    '12345'    # false
    '1010101'  # true
    '887685'   # false
    '9120734'  # true
    '090909'   # true
]

sıkıştırılmamış:

undulant = (n) ->
    direction = n[0] < n[1]
    return n.split('').every (cur, i) ->
        prev = arr[i-1] or 10 * direction
        +(prev >= cur) is (direction+i)%2

J, 44 39 36 31 bayt

*/2(0<#@],0>*/\)*2-/\".;' ',.":

Daha önce olduğu gibi kullanın.

Son düzenlememin 0 çek ile eşitsizliği tamamen gereksiz hale getirdiğini fark etmemiştim. :-)

Önceki cevap (+ açıklama):

(0=+/2=/\u)*(1<#u)**/2~:/\2<:/\u=.".;' ',.":

Kullanımı:

    (0=+/2=/\u)*(1<#u)**/2~:/\2<:/\u=.".;' ',.":461902
1

Cevap dört bölümden oluşmaktadır:

1. u=.".;' ',.": Bu sayıyı bir dize olarak okur, ":boşluklardan önce gelen karakterler listesine böler ' ',., tekrar birleştirir ;, tekrar sayılara dönüştürür ".ve sonra sonucu saklar. u=.Bu temelde 461902'yi daha kolay bulduğum 4 6 1 9 0 2'ye dönüştürür J.'de işlemek

2. */2~:/\2<:/\ Bu, u içinde saklanan değer üzerinde çalışır. Her karakter çiftini alır ve sol karakterin sağdan küçük veya eşit olup olmadığını kontrol eder, 2<:/\böylece 4 6 1 9 0 2 1 0 1 0 1 olur ve ardından her bir sayı çiftini eşitsizlik açısından kontrol eder. 2~:/\böylece 1 0 1 0 1 1 1 1 1 olur. Son olarak, 0 veya 1 elde etmek için hepsini çoğaltır */. Bu noktada, 2 şey olmasaydı cevabı döndürebiliriz: soru 0 gerektirir; ve eşit sayılar 'küçükten küçük' ile aynı şekilde ele alınır, böylece 461900 0 yerine 1 döndürür. Bummer. Başlıyoruz ...

3. (1<#u) Bu, u'da saklanan öğe sayısının #u1'den büyük olup olmadığını kontrol eder ve yalnızca tek haneli bir sayı ise false değerini döndürür.

4. (0=+/2=/\u) Bu, u içinde saklanan her sayı çiftini alır ve eşitliği kontrol eder 2=/\u. Daha sonra cevapları toplar ve 0 olup olmadığını kontrol eder.

Daha sonra bölüm 2, 3 ve 4'ün sonuçları, sayı soruda belirtilen gereksinimleri karşıladığında (umarım) 1 üretmek için birlikte çoğaltılır.

Haskell, 82 bayt

c=cycle[(<),(>)]
l!n=n>9&&and(zipWith3($)l(show n)$tail$show n)
u n=c!n||((>):c)!n

Çevrimiçi deneyin!

Python, 119108 bayt

def u(x):l=[cmp(i,j)for i,j in zip(`x`,`x`[1:])];print x>9and all([i*j<0 for i,j in zip(l,l[1:])])and l!=[0]

Python, 155 karakter

g=lambda a,b:all(x>y for x,y in zip(a,b))
u=lambda D:g(D[::2],D[1::2])&g(D[2::2],D[1::2])
def U(n):D=map(int,str(n));return(n>9)&(u(D)|u([-d for d in D]))

C ++, 94 karakter

bool u(int N){int K,P,Q,U=1,D=1;while(N>9)P=N%10,Q=(N/=10)%10,K=D,D=U&Q<P,U=K&Q>P;return U^D;}

benim Erlang wnser ile aynı yöntem özyineleme yerine bir for döngüsü.

Python 105 101 100 karakter

c=lambda r,t:len(r)<2 or(cmp(*r[:2])==t and c(r[1:],-t))
u=lambda x:x>9and c(`x`,cmp(*`x`[:2])or 1)

Özyinelemeli çözüm. c(r,t)ilk karakterin ikinci karakterden daha raz (t==-1)veya daha büyük (t==1)olup olmadığını kontrol eder ve kısaltılmış dize üzerinde ters kontrol çağırır.

Perl / re, 139 bayt

Normalde her şeyi yapmak kötü bir fikirdir.

/^(?:(.)(?{local$a=$1}))?(?:(?>((.)(?(?{$a lt$3})(?{local$a=$3})|(?!)))((.)(?(?{$a gt$5})(?{local$a=$5})|(?!))))*(?2)?)(?(?{pos>1})|(?!))$/

Perl 5.12 kullanıyorum ama bunun Perl 5.10 üzerinde çalışacağını düşünüyorum. Oldukça emin 5.8 olsa dışarı.

için (qw (461902 708143 1010101 123 5)) {
    "$ _ is" yazdırın. (/ çılgın regex buraya gidiyor /? '': 'not'). "inip \ n";
}

461902 zayıflatıcıdır
708143 zayıflatıcıdır
1010101 sönük
123 insansız değil
5 insansız değil

GolfScript, 48 bayt

[`..,(<\1>]zip{..$=\-1%.$=-}%(\{.@*0<*}/abs

GolfScript kullanarak ilk kez J'yi yenmeyi umuyorum. Başarılı olamadı.

JavaScript, 66 65 62 60 bayt

Girdi bir dize olarak alır, truedüzensiz sayılar için döner , tek haneli sayılar için boş bir dize (falsey) ve falseaksi halde.

([s,...a])=>a+a&&a.every(x=>eval(s+"<>"[++y%2]+x,s=x),y=s<a)

Dene

Test etmek için 0-925 Snippet'i ve 25 rasgele sayıyı çalıştırın <10,000,000.

f=
([s,...a])=>a+a&&a.every(x=>eval(s+"<>"[++y%2]+x,s=x),y=s<a)
tests=new Set([...Array(10).keys()])
while(tests.add(Math.random()*1e7|0).size<35);
o.innerText=[...tests].map(x=>(x=x+``).padStart(7)+` = `+JSON.stringify(f(x))).join`\n`

<pre id=o></pre>

açıklama

Birkaç eğlenceli küçük hileler bu yüzden benden bir JS çözümü için nadir bir açıklama garanti düşünüyorum.

()=>

Basitçe, tamsayı dizesini çağrıldığında argüman olarak alan anonim bir işlevle başlarız.

[s,...a]

Bu argüman hemen 2 parametrelere Bozunmamış edilir: sdizesindeki ilk karakter olmak ve akalan karakterler içeren bir dizidir olma (örneğin "461902"olur s="4"ve a=["6","1","9","0","2"]).

a+a&&

İlk olarak, aher iki olayı da dizgilere çeviren kendisiyle birleştiririz . Giriş tek basamaklı bir sayı aise boş olur ve bu nedenle dize olur ve boş olur; boş bir dize ve boş bir dize hala boş bir dizedir ve bu JS'de falsey olduğundan, mantıksal AND'de işlemeyi durdurur ve boş dizemizi çıkarırız. Diğer tüm durumlarda a+adoğruluk olacaktır ve bu nedenle işlevin bir sonraki bölümüne devam ediyoruz.

a.every(x=>)

Her eleman olmadığı kontrol olacağım xiçinde adönüşleri truebir fonksiyonu geçerken.

y=s<a

Bu, ilk karşılaştırmamızın ( <veya >) ne olacağını belirler ve sonra oradan değişeceğiz . Dize edip etmediğini kontrol saz dizinin daha aeğer, bu nedenle sürecinde bir dizeye döküm alır, sdaha az ilk karakterin daha a, yolacak trueya falseda değilse.

s+"<>"[++y%2]+x

sBaşlangıçta ve xsonunda geçerli değeri olan bir dize oluştururuz . Arasında, dizeye dizine "<>"artırarak ybize veren 2 oranında bir tamsayı ve modulo için başlangıç boolean değerini döküm, 0ya 1.

eval()

Bu dizeyi değerlendirin.

s=x

Son olarak, evalgörmezden geldiği ikinci bir argüman iletiriz ve bunu bir sonraki yinelemenin sgeçerli değerine ayarlamak için kullanırız x.

PowerShell, 88

Saf ve önemsiz. Daha sonra golf oynayacağım.

filter u{-join([char[]]"$_"|%{if($n){[Math]::Sign($n-$_)+1}$n=$_})-notmatch'1|22|00|^$'}

Test senaryolarım .

JavaScript, 112

function(n,d,l,c,f){while(l=n%10,n=n/10|0)d=n%10,c?c>0?d>=l?(f=0):(c=-c):d<=l?(f=0):(c=-c):(c=d-l,f=1);return f}

Sadece bir argüman iletmeniz gerekiyor. Muhtemelen bu bir for döngüsü ile daha da golf olabilir.

Erlang, 137 123 118 karakter

u(N)->Q=N div 10,u(Q,N rem 10,Q>0,Q>0). u(0,_,D,U)->D or U;u(N,P,D,U)->Q=N rem 10,u(N div 10,Q,U and(Q<P),D and(Q>P)).

CJam, 30 bayt

CJam bu meydan okuma daha yeni, bu yüzden bu yeşil onay işareti için rekabet değil, ama yine de bir kazanan değil (her ne kadar bu aslında biraz golf olabilir eminim).

l"_1=\+{_@-\}*;]"_8'*t+~{W>},!

Burada test edin.

Nasıl çalışır

İlk olarak, yinelenen kod 5 bayt kaydetmek için bazı dize manipülasyon (eval sonra takip) yapıyorum:

"..."_8'*t+~
"..."        "Push this string.":
     _       "Duplicate.";
      8'*t   "Replace the 8th character (the -) with *.";
          +~ "Concatenate the strings and evaluate.";

Yani aslında kodum

l_1=\+{_@-\}*;]_1=\+{_@*\}*;]{W>},!

İlk olarak, tek bir rakamın tuhaf özel durumu ile nasıl başa çıkacağım. 1Basamağı dizine kopyalayıp numaraya ekliyorum. 3 vakayı ayırt etmeliyiz:

• İlk iki rakam gibi farklı 12..., o zaman olsun212... , böylece başlangıç ​​zayıftır ve tüm sayının zayıf olup olmadığını etkilemez.
• İlk iki basamak aynıdır, sanki 11...alırız 111.... Şimdi başlangıç ​​düzensiz değil, ama sayı yine de düzensiz değildi, bu da sonucu etkilemeyecek.
• Sayının yalnızca bir rakamı varsa, dizindeki 1basamak ilk basamak olacaktır (CJam'ın dizi indeksleme bitiş etrafında döngülediğinden), bu iki özdeş basamağa neden olur ve sayı belirsiz değildir .

Şimdi koda ayrıntılı olarak bakıyoruz:

l_1=\+{_@-\}*;]_1=\+{_@*\}*;]{W>},!
l                                   "Read input.";
 _1=\+                              "Prepend second digit.";
      {_@-\}*                       "This fold gets the differences of consecutive elments.";
             ;]                     "Drop the final element and collect in an aray.";
               _1=\+                "Prepend second element.";
                    {_@*\}*         "This fold gets the products of consecutive elments.";
                           ;]       "Drop the final element and collect in an aray.";
                             {W>},  "Filter out non-negative numbers.";
                                  ! "Logical not.";

Eminim onlar (eğer iki kat kullanmadan) inatçı olup olmadıklarını (özellikle 1 kat daha büyük) rakamları kontrol etmek için daha kısa bir yol var, ama henüz bulamadım.

Prolog 87 bayt

u(X) :- number_codes(X,C),f(C).
f([_,_]).
f([A,B,C|L]) :- (A<B,B>C;A>B,B<C),f([B,C|L]).

Çalıştırmak için golf.pl olarak kaydedin, aynı dizinde bir prolog yorumlayıcısı (örn. Gprolog) açın ve şunları yapın:

consult(golf).
u(101010).

trueSayının düzensiz olup olmadığını verecektir , aksi takdirde hayır.

Mathematica, 46 bayt

#!=Sort@#&&#!=Reverse@Sort@#&[IntegerDigits@n]

Örnekler (boşluk gerekli değildir):

# != Sort@# && # != Reverse@Sort@# &[IntegerDigits@5]
# != Sort@# && # != Reverse@Sort@# &[IntegerDigits@123]
# != Sort@# && # != Reverse@Sort@# &[IntegerDigits@132]
# != Sort@# && # != Reverse@Sort@# &[IntegerDigits@321]

(*  out *)
False  False  True  False

Scala, 141133129 97 bayt

def u(n:Int):Boolean=n>9&&{
val a=n%10
val b=(n/10)%10
a!=b&&n<99||(a-b*b-(n/100)%10)<0&&u(n/10)}

A = n% 10 ile b = (n / 10)% 10, c = (n / 100)% 10

if a > b and b < c or 
   a < b and b > c

Daha sonra a-b * b-c, ya bir x*-yya da -x*ybirlikte xve ypozitif sayı olarak ve ürün her iki durumda da negatif olmakla için -x*-yya da x*y(<b <c ve a> b> c) Ürün, her zaman pozitiftir.

Kodun geri kalanı özel durumları ele alır: bir basamak, iki basamak, iki özdeş basamak.

Perl, 78 bayt

sub u{@_=split//,$_=shift;s/.(?=.)/($&cmp$_[$+[0]])+1/ge;chop;$#_&&!/00|1|22/}

Q, 71 bayt

{$[x>9;any all a=#[;(1 -1;-1 1)](#)a:1_signum(-':){"I"$x}each -3!x;0b]}

Örnek kullanım:

q){$[x>9;any all a=#[;(1 -1;-1 1)](#)a:1_signum(-':){"I"$x}each -3!x;0b]} 5
0b
q){$[x>9;any all a=#[;(1 -1;-1 1)](#)a:1_signum(-':){"I"$x}each -3!x;0b]} 10101
1b
q){$[x>9;any all a=#[;(1 -1;-1 1)](#)a:1_signum(-':){"I"$x}each -3!x;0b]} 01010
1b
q){$[x>9;any all a=#[;(1 -1;-1 1)](#)a:1_signum(-':){"I"$x}each -3!x;0b]} 134679
0b
q){$[x>9;any all a=#[;(1 -1;-1 1)](#)a:1_signum(-':){"I"$x}each -3!x;0b]} 123456
0b
q){$[x>9;any all a=#[;(1 -1;-1 1)](#)a:1_signum(-':){"I"$x}each -3!x;0b]} 132436
1b

Julia 0.6 , 62 bayt

f(x,a=sign.(diff(digits(x))))=x>9&&-a*a[1]==(-1).^(1:endof(a))

Bir sayı alır, trueUndulant için geri döner ve falsedeğil. Örneğin f(163)geri döner true.

f(x,a=sign.(diff(digits(x))))=x>9&&-a*a[1]==(-1).^(1:endof(a))
f(x,                        )                                   # function definition
    a=sign.(diff(digits(x)))                                    # default 2nd argument is array of differences of signs of digits
                              x>9&&                             # short circuiting and to catch cases under 10
                                   -a*a[1]                      # make the first element of a always -1
                                          ==(-1).^(1:endof(a))  # check that a is an array of alternating -1 and 1 of correct length

Çevrimiçi deneyin!