Một undulant số là một số nơi chữ số của nó luân phiên giữa lên và xuống như số sau: 461.902 hoặc 708.143, hoặc thậm chí 1.010.101, nhưng không phải 123, vì 2 <3.

Viết một chương trình hoặc chức năng mà trả về một giá trị truthy nếu một số là undulant , và một giá trị falsy khác. Mã ngắn nhất sẽ thắng.

Lưu ý : Các số có một chữ số là một đầu vào hợp lệ nhưng không được coi là udulant , do đó isUndulanttrả về false cho n <10.

J, 45

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

Sử dụng mẫu:

   *./(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

Tôi khá chắc chắn rằng có một cách xoắn tốt hơn Chèn /để thực hiện nhiều công việc hơn, nhưng tôi đã ít J hơn trong nhiều tháng, tôi cần phải quay lại với nó.

Ruby, 72 70 ký tự

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

Cách sử dụng và kiểm tra:

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

Các chữ số đơn mang lại sai :

p u[5]       # <= false

Các chữ số giống nhau liên tiếp cũng trả về false :

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

J, 30 byte

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

Một cách tiếp cận khác với các câu trả lời J khác.

   * / 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

Sẽ ngắn hơn 3 ký tự nếu 5 được coi là không có giá trị.

(pdf) eTeX, 129 ký tự

\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

Biên dịch với pdfetex filename.tex 1324?cho một đầu ra pdf. TeX chủ yếu là một ngôn ngữ sắp chữ, và thay vào đó, xuất ra thiết bị xuất chuẩn sẽ mất khoảng 20 ký tự nữa. Ngoài ra, yêu cầu kỳ lạ đối với các số có một chữ số (sai chứ không phải đúng) đưa tôi 26 ký tự.

Haskell, 88 77 73 65 ký tự

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

Điều này đòi hỏi pragma ngôn ngữ thường được sử dụng (hoặc -Xcờ) : NoMonomorphismRestriction. Nếu bạn không thừa nhận điều đó, chúng tôi phải thêm 4 ký tự và xác định znhư vậy:

z s=zipWith compare s$tail s

Sage, 83 76 byte

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

Có ý tưởng sử dụng cmp (* [..]) từ JBernardo. Trong Sage, uniq(...)là một bí danh cho list(set(...)).

Chỉnh sửa: chỉ cần lưu ý rằng với x <10, uniq(cmp(...)) == []không bật [[1],[-1]]. Nếu x là đầu vào dưới dạng chuỗi, thay vì số nguyên, tôi có thể lấy thêm 4 ký tự!

Python: 101 100 ký tự

Trước khi giảm thiểu:

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:])))))

Sau khi giảm thiểu:

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 ký tự

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])

Ung dung:

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 ký tự

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}

Về bản chất, biến số thành một chuỗi và so sánh các ký tự liền kề, lật ngược kỳ vọng cho từng ký tự.

K, 41 byte

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

Ví dụ

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

Cà phê 98 67 53 byte

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

Các xét nghiệm:

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

Không nén

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 byte

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

Cách sử dụng như trước.

Tôi đã không nhận thấy rằng lần chỉnh sửa cuối cùng của mình khiến bất bình đẳng với 0 kiểm tra hoàn toàn không cần thiết. :-)

Câu trả lời trước (+ giải thích):

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

Sử dụng:

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

Câu trả lời có bốn phần:

1. u=.".;' ',.": Điều này đọc số dưới dạng một chuỗi ":, chia nó thành một danh sách các ký tự đứng trước dấu cách ' ',., ghép nó lại với nhau ;, chuyển đổi lại thành số ".và sau đó lưu kết quả u=.Điều này về cơ bản biến 461902 thành 4 6 1 9 0 2 mà tôi thấy dễ dàng hơn để xử lý trong J.

2. */2~:/\2<:/\ Điều này hoạt động trên giá trị được lưu trữ trong u. Phải mất từng cặp ký tự và kiểm tra xem một bên trái nhỏ hơn hoặc bằng một bên phải 2<:/\sao cho 4 6 1 9 0 2 trở thành 1 0 1 0 1. Sau đó, kết quả của điều này và kiểm tra từng cặp số cho bất đẳng thức 2~:/\vì vậy 1 0 1 0 1 trở thành 1 1 1 1. Cuối cùng, nó nhân tất cả chúng lại với nhau để có 0 hoặc 1 */Tại thời điểm này, chúng ta có thể trả lời câu trả lời nếu không có 2 điều: một chữ số duy nhất trả về 1 khi câu hỏi yêu cầu 0; và các số bằng nhau được xử lý giống như 'nhỏ hơn', vì vậy 461900 trả về 1 thay vì 0. Bummer. Chúng ta đi ...

3. (1<#u) Điều này kiểm tra xem số lượng mục được lưu trữ trong u #ulớn hơn 1 và trả về false nếu đó chỉ là một số có một chữ số.

4. (0=+/2=/\u) Điều này nhận từng cặp số được lưu trữ trong u và kiểm tra sự bằng nhau 2=/\u. Sau đó, nó tổng hợp các câu trả lời và kiểm tra nếu nó có 0.

Kết quả của các phần 2, 3 và 4 sau đó được nhân với nhau để (hy vọng) tạo ra 1 khi số đáp ứng các yêu cầu được chỉ định trong câu hỏi.

Haskell, 82 byte

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

Hãy thử trực tuyến!

Python, 119 108 byte

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 ký tự

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 ký tự

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

cùng một phương thức như Erlang awnser của tôi với một vòng lặp for hơn là đệ quy.

Python 105 101 100 ký tự

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)

Giải pháp đệ quy. c(r,t)kiểm tra nếu char thứ nhất rít hơn (t==-1)hoặc lớn hơn (t==1)char thứ hai và gọi kiểm tra ngược lại trên chuỗi rút gọn.

Perl / re, 139 byte

Làm mọi thứ trong regex là một ý tưởng tồi.

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

Tôi đang sử dụng Perl 5.12 nhưng tôi nghĩ nó sẽ hoạt động trên Perl 5.10. Khá chắc chắn 5,8 là ra mặc dù.

cho (qw (461902 708143 1010101 123 5)) {
    in "$ _ là". (/ regex điên ở đây /? '': 'không'). "không mong muốn \ n";
}

461902 là không mong muốn
708143 là bất tử
1010101 là bất tử
123 không phải là bất tử
5 không phải là bất tử

GolfScript, 48 byte

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

Hy vọng đánh bại J, lần đầu tiên tôi sử dụng GolfScript. Không thành công lắm.

JavaScript, 66 65 62 60 byte

Lấy đầu vào dưới dạng một chuỗi, trả về truecác số không có giá trị, một chuỗi trống (falsey) cho các số có một chữ số và mặt falsekhác.

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

Thử nó

Chạy đoạn trích dưới đây để kiểm tra 0-9và 25 số ngẫu nhiê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>

Giải trình

Một vài thủ thuật nhỏ thú vị trong bài này vì vậy tôi nghĩ rằng nó đảm bảo một lời giải thích hiếm hoi cho một giải pháp JS từ tôi.

()=>

Chúng ta bắt đầu, đơn giản, với một hàm ẩn danh lấy chuỗi số nguyên làm đối số khi được gọi.

[s,...a]

Đối số đó ngay lập tức bị phá hủy thành 2 tham số: slà ký tự đầu tiên trong chuỗi và alà một mảng chứa các ký tự còn lại (ví dụ: "461902"trở thành s="4"và a=["6","1","9","0","2"]).

a+a&&

Đầu tiên, chúng ta ghép nối avới chính nó, điều này tạo ra cả hai lần xuất hiện cho chuỗi. Nếu đầu vào là một số có một chữ số thì asẽ trống và do đó, trở thành và chuỗi rỗng; một chuỗi rỗng cộng với một chuỗi rỗng vẫn là một chuỗi rỗng và vì đó là lỗi trong JS, chúng ta dừng xử lý ở logic VÀ và xuất chuỗi rỗng của chúng ta. Trong tất cả các trường hợp khác a+asẽ là sự thật và vì vậy chúng tôi tiếp tục đến phần tiếp theo của chức năng.

a.every(x=>)

Chúng tôi sẽ kiểm tra nếu mọi phần tử xtrong alợi nhuận truekhi đi ngang qua một hàm.

y=s<a

Điều này xác định so sánh đầu tiên của chúng tôi sẽ là ( <hoặc >) và sau đó chúng tôi sẽ thay thế từ đó. Chúng tôi kiểm tra xem chuỗi scó nhỏ hơn mảng không a, có được truyền thành chuỗi trong quy trình hay không, nếu sít hơn ký tự đầu tiên trong a, ysẽ truehoặc falsenếu không.

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

Chúng tôi xây dựng một chuỗi với giá trị hiện stại ở đầu và xcuối. Ở giữa, chúng tôi lập chỉ mục vào chuỗi "<>"bằng cách tăng y, chuyển giá trị boolean ban đầu của nó thành một số nguyên và modulo bằng 2, cho chúng ta 0hoặc 1.

eval()

Eval chuỗi đó.

s=x

Cuối cùng, chúng ta chuyển một đối số thứ hai eval, mà nó bỏ qua và sử dụng nó để đặt giá trị của sgiá trị hiện tại xcho lần lặp tiếp theo.

PowerShell, 88

Ngây thơ và tầm thường. Tôi sẽ chơi gôn sau.

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

Trường hợp thử nghiệm của tôi .

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}

Bạn chỉ cần vượt qua nó một đối số. Tôi có thể chơi golf này hơn nữa với một vòng lặp for.

Erlang, 137 123 118 ký tự

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 byte

CJam mới hơn thử thách này, vì vậy điều này không cạnh tranh cho dấu kiểm màu xanh lá cây, nhưng dù sao nó cũng không phải là người chiến thắng (mặc dù tôi chắc chắn rằng điều này thực sự có thể được đánh golf khá nhiều).

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

Kiểm tra nó ở đây.

Làm thế nào nó hoạt động

Đầu tiên, tôi đang thực hiện một số thao tác chuỗi (tiếp theo là eval) để lưu 5 byte trên mã trùng lặp:

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

Vì vậy, trong thực tế mã của tôi là

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

Đầu tiên, đây là cách tôi xử lý trường hợp đặc biệt kỳ lạ của một chữ số. Tôi sao chép chữ số tại chỉ mục 1và thêm nó vào số. Chúng ta cần phân biệt 3 trường hợp:

• Hai chữ số đầu tiên là khác nhau, như 12..., sau đó chúng tôi nhận được 212..., do đó, bắt đầu là không có giá trị, và sẽ không ảnh hưởng đến việc toàn bộ số có phải là không.
• Hai chữ số đầu tiên giống nhau, giống như 11..., sau đó chúng ta nhận được 111.... Bây giờ, sự khởi đầu không phải là bất khả xâm phạm, nhưng dù sao con số cũng không bị ảnh hưởng, vì vậy điều này cũng không ảnh hưởng đến kết quả.
• Nếu số chỉ có một chữ số, chữ số tại chỉ mục 1sẽ là chữ số đầu tiên (vì các vòng lặp lập chỉ mục mảng của CJam ở cuối), do đó, điều này dẫn đến hai chữ số giống nhau và số này không bị suy giảm .

Bây giờ nhìn vào mã chi tiết:

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.";

Tôi chắc chắn có một cách ngắn hơn để thực sự kiểm tra các chữ số (có độ dài lớn hơn 1) để xem chúng có khác nhau hay không (cụ thể là không sử dụng hai nếp gấp), nhưng tôi chưa thể tìm thấy nó.

Prolog 87 byte

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]).

Để chạy nó, chỉ cần lưu nó dưới dạng golf.pl, mở trình thông dịch prolog (ví dụ: gprolog) trong cùng thư mục, sau đó làm:

consult(golf).
u(101010).

Nó sẽ cung cấp truenếu số lượng là không mong muốn, nếu không thì không.

Toán học, 46 byte

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

Ví dụ (không bắt buộc phải có không gian):

# != 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, 141 133 129 97 byte

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

Với a = n% 10, b = (n / 10)% 10, c = (n / 100)% 10

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

Sau đó a-b * b-clà một x*-yhoặc -x*ycó xvà ylà số dương và sản phẩm trong cả hai trường hợp đều âm, nhưng với -x*-yhoặc x*y(a <b <c hoặc a> b> c) sản phẩm luôn dương.

Phần còn lại của mã đang xử lý các trường hợp đặc biệt: một chữ số, hai chữ số, hai chữ số giống nhau.

Perl, 78 byte

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

Q, 71 byte

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

Sử dụng mẫu:

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 byte

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

Lấy một số, trả về truecho Undulant, và falsekhông. Ví dụ f(163)trả về 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

Hãy thử trực tuyến!