Một chuỗi gồm n> 0 số nguyên được gọi là jumper jolly nếu các giá trị tuyệt đối của sự khác biệt giữa các phần tử liên tiếp đảm nhận tất cả các giá trị từ 1 đến n-1.

Vì vậy, chuỗi [4,1,2,4] có sự khác biệt tuyệt đối [3,1,2] tương đương với tập [1,2,3] (1 đến n-1 trong đó n là độ dài của chuỗi gốc) do đó, nó là một jumper jolly.

Chuỗi có độ dài n> 0.

Giả sử n = 1 là một jumper jolly.

Chế độ dễ dàng: Đừng lo lắng về stdin / stdout. Chỉ là một hàm chấp nhận đối số tuy nhiên và trả về một cái gì đó chỉ ra sự vui vẻ hay không

Chế độ cứng: Đầu vào trên stdin (phân tách không gian) và đầu ra là "Jolly" / "Không jolly". Vấn đề vốn.

Đây là mã golf.

EDIT: Chuỗi có thể chứa số nguyên âm và đầu vào trên stdin được phân tách không gian.

$ jolly 2 -1 0 2
Jolly

$ jolly 19 22 24 25
Jolly

$ jolly 19 22 24 21
Not jolly

Haskell

Dễ dàng 4 ký tự

Trả về danh sách các số nguyên jolly khi và chỉ khi một danh sách các số nguyên jolly được đưa ra làm đầu vào. Đây là hợp pháp dựa trên "Chỉ là một chức năng chấp nhận các đối số tuy nhiên và trả về một cái gì đó chỉ ra sự vui vẻ hay không".

j=id

Giải pháp dễ dàng thay thế với 61 ký tự:

Đưa vào một danh sách và trả về danh sách trống nếu chuỗi là jolly.

import List
j n=zipWith(\x->abs.(x-))n(tail n)\\[1..length n]

Ruby, 92 93 ký tự

Phiên bản cứng với đầu vào trên STDIN.

f=gets.split.each_cons(2).map{|a|eval(a*?-).abs}.sort
$><<(f==[*1..f.size]??J:"Not j")+"olly"

Nếu bạn bắt đầu với -pa(tính là 4), bạn có thể lưu 5 ký tự:

f=$F.each_cons(2).map{|a|eval(a*?-).abs}.sort
$_=(f==[*1..f.size]??J:"Not j")+"olly"

Java (Cứng)

Giả sử rằng đầu vào được đưa ra thông qua stdin. (không thông qua các đối số dòng lệnh như ví dụ)

Chơi gôn - 325

class JollyJumper {
public static void main(String[] args) {
String[] in = new Scanner(System.in).nextLine().split(" ");
int[] j=new int[in.length-1],k=j.clone();
for(int i=0;i<in.length-1;i++){j[i]=Math.abs(Integer.parseInt(in[i])-Integer.parseInt(in[i+1]));k[i]=i+1;}
Arrays.sort(j);System.out.println(Arrays.equals(j, k)?"Jolly":"Not jolly");
}
}

Không chơi gôn

public class JollyJumper {
public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int[] jolly;
    String[] in;

    in = sc.nextLine().split(" ");
    jolly = new int[in.length-1];

    for (int i = 0; i < in.length-1; i++)
        jolly[i] = Math.abs(Integer.parseInt(in[i]) - Integer.parseInt(in[i+1]));

    Arrays.sort(jolly);

    for (int i = 1; i <= in.length-1; i++) {
        if (jolly[i-1] != i) {
            System.out.println("Not jolly");
            return;
        }
    }
    System.out.println("Jolly");
}
}

Scala, chế độ dễ dàng, 123 ký tự

def j(s:String)={var a=s.sliding(2,1).map(x=>math.abs(x(0)-x(1))).toList
for(c<-1 to a.size)
if(!a.contains(c))false
true}

Để chạy hoặc kiểm tra trên ideone.com:

object Main
{
   def main(args:Array[String])
   {
      def j(s:String):Boolean=
      {
         var a=s.sliding(2,1).map(x=>math.abs(x(0)-x(1))).toList
         for(c<-1 to a.size)
            if(!a.contains(c)) false
         true
      }
      println(j("4124"))
   }
}

Golfscript, chế độ dễ dàng, 21 18 ký tự

{.@-abs\}*;0]$.,,=

Chấp nhận các đối số như một mảng các số nguyên trên ngăn xếp, không có gì khác trên ngăn xếp; để lại 1 trên ngăn xếp nếu nó vui vẻ và 0 khác. Để lấy đầu vào trên stdin làm danh sách ints được phân tách bằng dấu cách, hãy thêm vào

~]

và để xuất "Jolly" / "Không phải jolly" (giả sử rằng chúng tôi đang biến điều này thành một chương trình) hoãn lại

"Not jJ"5/="olly"

J (dễ), 18

(i.@#-:<:/:])|2-/\

   (tôi. @ # -: <: /:]) | 2 - / \ 2 _1 0 2
1
   (tôi. @ # -: <: /:]) | 2 - / \ 19 22 24 25
1
   (tôi. @ # -: <: /:]) | 2 - / \ 19 22 24 21
0

J (khó), 68

2!:55]1!:2&2'olly',~>('Not j';'J'){~(i.@#-:<:/:])|2-/\".@>2}.ARGV_j_

$ jconsole jumper.ijs 2 -1 0 2
Vui vẻ
$ jconsole jumper.ijs 19 22 24 25
Vui vẻ
$ jconsole jumper.ijs 2 19 22 24 21
Không vui vẻ

Brachylog , 11 byte (dễ dàng)

s₂ᶠ-ᵐȧᵐo~⟦₁

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

s₂ᶠ-ᵐ - Sự khác biệt liên tiếp

ȧᵐ - Giá trị tuyệt đối

o - Sắp xếp

~⟦₁ - Là kết quả phạm vi 1 đến một cái gì đó?

J, 30 26 chế độ dễ, 81 76 chế độ cứng

chỉnh sửa: xử lý danh sách ngắn hơn 3, sửa lỗi đọc stdin

Dòng đầu tiên chăm sóc chế độ dễ, thứ hai thêm chế độ cứng.

j=:[:*/[:(>:@i.@#=/:~)[:|2-/\]
exit('olly',~[:>('Not j';'J'){~[:j 0".}:)&.stdin''

J thường đọc từ phải sang trái:

2-/\ : cứ hai số liên tiếp trong danh sách, hãy lấy chênh lệch

| : giá trị tuyệt đối

/:~ : sắp xếp theo thứ tự tăng dần

>:@i.@#: 1 đến n , cho danh sách n số

= : so sánh sự khác biệt được sắp xếp với trình tự (sử dụng "ngã ba" J)

*/: nhân tất cả các booleans phần tử khôn ngoan; nếu tất cả các so sánh là 1, sản phẩm của họ là 1, vì vậy nó rất vui

Ruby, 97 102 106 (cứng)

Cũng có thể, vì những người khác là:

h,*t=gets.split
d=t.map{|i|h,i=i,h;eval(i+?-+h).abs}.sort
$><<(d==[*1..d.size]??J:"Not j")+"olly"

Đầu vào lấy trên stdin.

D

dễ dàng ( 103 83 ký tự)

trả về tổng số 1..i.length trên Jolly một số số khác nếu không (một chút quy tắc nằm ở đây)

import std.math;auto jolly(I)(I i){int t,l;foreach(r;i){t+=abs(l-r);l=r;}return t;}

cứng (142 ký tự)

đầu vào là khoảng trắng được phân tách và kết thúc trên EOF

import std.stdio;import std.math; void main(){int i,j,l,t;while(readf("%d ",&i)>0){t+=abs(l-i);l=i;j++;}write(t==j*++j/2?"J":"Not j","olly");}

Groovy

Dễ dàng: 78

j={m=[];it[1..-1].inject(it[0]){p,n->m<<p-n;n};m*.abs().sort()==1..<it.size()}

assert [[2, -1, 0, 2,], [19, 22, 24, 25], [19, 22, 24, 21]].collect { j(it) } == [true, true, false]

Cứng: 151

j={m=[];it[1..-1].inject(it[0]){p,n->m<<p-n;n};m*.abs().sort()==1..<it.size()};System.in.eachLine{println "${j(it.split()*.toLong())?'J':'Not j'}olly"}

PowerShell, cứng, 117 126

('Not j','J')["$(($a=-split$input)|%{if($x-ne$0){[math]::abs($x-$_)}$x=$_}|sort)"-eq"$(1..($a.Count-1)|sort)"]+'olly'

Lịch sử:

• 2011-11-18 17:54 ( 123 , 3) - Thay đổi $nullthành một biến không tồn tại
• 2011-11-18 18:02 ( 117 , 6) - nội tuyến tất cả các khai báo biến

Scala

Một cú đâm nhanh - có thể có những cải tiến có thể.

Dễ dàng: 77

def j(? :Int*)=(?tail,?).zipped.map(_-_).map(math.abs).sorted==(1 to?.size-1)

Cứng: 124

val? =args.map(_.toInt)toSeq;print(if((?tail,?).zipped.map(_-_).map(math.abs).sorted==(1 to?.size-1))"Jolly"else"Not jolly")

Q, 64 (khó), 30 (dễ)

cứng

{$[(1_(!)(#)x)~asc abs 1_(-':)x;(-1"Jolly";);(-1"Not jolly";)];}

dễ dàng

{(1_(!)(#)x)~asc abs 1_(-':)x}

J (dễ), 19 ký tự

*/(=i.@#)<:/:~|2-/\

Sử dụng:

    */(=i.@#)<:/:~|2-/\4 2 1 4
1

Thay đổi tương tự như câu trả lời của DCharness , và tôi sẽ chỉ thêm nó dưới dạng một nhận xét nhưng thực tế là anh ấy đã không truy cập kể từ ngày 23 tháng 2.

2-/\ có sự khác biệt giữa các cặp số liên tiếp

| nhận giá trị tuyệt đối của mỗi số,

/:~ sắp xếp theo thứ tự tăng dần,

<: giảm mỗi số 1

(=i.@#)một móc J tạo ra chuỗi các số từ 0 đến độ dài của danh sách khác biệt - 1 ( i.@#) và so sánh nó với danh sách đó =.

*/nhân danh sách 1s và 0s được tạo bởi động từ trước.

Scala dễ dàng: 138 153, 170 (đã bị lỗi, được cải thiện sau)

def j(i:String)={
def a(s:Seq[Int])=(s zip s.tail).map(x=>(x._2-x._1))
a(a(i.split(" ").map(_.toInt)).map(math.abs).sorted).toSet.size==1}

vô dụng:

def jolly (input: String) = { 
      val list = input.split (" ").map (_.toInt)

      def stepsize (s: Seq[Int]) = 
        (s zip s.tail).map (x=> (x._2 - x._1))

      val first = stepsize (input.split (" ").map (_.toInt))
      val pos = first.map (math.abs)
      val unique = stepsize (pos.sorted).toSet
      (unique.size) == 1
}

Ý tưởng là, chúng tôi xây dựng đạo hàm thứ hai:

Original: 4 1 2 4
Stepsize:  -3 1 2 (first)
     abs:   3 1 2
  sorted:   1 2 3 
Stepsize:     1 1 
  to Set:       1 
    size:       1

Scala hard 172 182, 205 (bị lỗi / cải thiện):

def j{
def a(s:Seq[Int])=(s zip s.tail).map(x=>(x._2-x._1))
println((if(a(a(readLine.split(" ").map(_.toInt)).map(math.abs).sorted).toSet.size==1)"J"else"Not j")+"olly")}
j

ít nhiều giống như trên.

PHP, dễ dàng, 129

Đối với một mảng $ssố nguyên đã cho:

for($i=1;$i<count($s);$i++)$a[abs($s[$i]-$s[$i-1])]=1;
for($i=1;$i<count($s);$i++)if(!isset($a[$i]))die('Not Jolly');echo 'Jolly';

Phiên bản chưa được chỉnh sửa:

for( $i=1; $i<count( $s ); $i++ )
    $a[ abs( $s[$i] - $s[$i-1] ) ] = 1;

for( $i=1; $i < count($s); $i++ )
    if( !isset( $a[$i] ) )
        die( 'Not Jolly' );

echo "Jolly";        

Jelly , 7 6 byte (dễ dàng)

IAṢ⁼J$

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

IAṢ⁼J$    jolly function on N:
IAṢ       the increment list: get all the Increments, take their Absolute values, and Ṣort them
   ⁼      compare that to...
    J$    range from 1 to len(N) -- this has an extra number, but that's fine because...
          ...the increment list is one shorter, and ⁼ will only compare that many values

Lấy đầu vào là các số được phân tách bằng dấu phẩy trong đối số đầu tiên. Trả về 1 nếu chuỗi là jolly và 0 nếu không!

Giải pháp 7 byte:

LRṖḟIA$

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

Lấy đầu vào là các số được phân tách bằng dấu phẩy trong đối số đầu tiên. Trả về không có gì nếu danh sách là một chuỗi jumper jolly, và một cái gì đó nếu nó không.

Thêm dòng này làm cho nó hoạt động với thông số kỹ thuật cứng:

Jelly , 27 22 byte (khó, phản hồi chào mừng!)

ɠḲVIAṢ⁼J$ị“¢⁼D“¡KṀȥƘạ»

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

ɠḲVIAṢ⁼J$ị“¢⁼D“¡KṀȥƘạ»
ɠḲV                     read a line, split on spaces and eValuate the numbers
   IAṢ⁼J$               jolly function: see above!
         ị              ịndex the result into (remember Jelly is one-indexed, so 0 wraps around to the back):
          “¢⁼D“          "Jolly" compressed if true,
              ¡KṀȥƘạ»   or, "Not jolly" compressed if false!

Giải pháp 27 byte (cứng):

LRṖḟIA$
ɠḲVÇ“¡KṀȥƘạ»“¢⁼D»L?

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

Bật các số được phân tách bằng dấu cách stdinvà xuất ra "Jolly" hoặc "Không jolly".

Giải trình:

LRṖḟIA$               jolly function:
LRP                   make a range (R) from 1 to the input length (L), popping off (P) the last number to make it 1 to N-1.
   ḟ                  reverse filter: remove all the elements from that range that are members of...
    IA$               the increment list: get all the increments, take their absolute values (expressed as one monad via '$').
ɠḲVÇ“¡KṀȥƘạ»“¢⁼D»L?    i/o main function:
ɠḲV                   read a line from stdin, split it on spaces and have Python parse each number (handling negative signs)
   Ç             ?    run the above, and use the result on the following conditional:
                L?    if the length of the result is truthy (non-empty):
    “¡KṀȥƘạ»          then, return Jelly compressed string "Not jolly",
            “¢⁼D»     else, return Jelly compressed string "Jolly".

Bất kỳ thông tin phản hồi đánh giá cao!

Haskell , 59 57 byte

f n=all(`elem`map abs(zipWith(-)n$tail n))[1..length n-1]

Chế độ dễ dàng, trả về sự vui nhộn như một boolean. Cảm ơn @Laikoni cho hai byte.

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

Japt , 32 30 byte cứng

-2 byte từ @Shaggy

`not jo¥y`s4*Näa n äa e¥1
hUÎu

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

Python 3, 117 (cứng)

l=[*map(int,input().split())]
print(["Not j","J"][{abs(a-b)for a,b in zip(l[1:],l[:-1])}=={*range(1,len(l))}]+"olly")

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

JavaScript: 105 (chế độ dễ)

Chơi gôn

function a(l){for(r=i=1;i<(m=l.length);i++){for(j=t=0;j+1<m;)t+=(d=l[j]-l[++j])*d==i*i;t||(r=0)}return r}

Chưa chơi gôn:

function isJolly(list){
    //Iterate over i to list.length-1
    for(r=i=1;i<(length=list.length);i++){
        //Check the differences between all consecutive elements squared minus i squared.  Set t to true if one was found.
        for(j=t=0;j+1<length;)t+=(diff=list[j]-list[++j])*diff==i*i;

        //if t is not true, return value is 0
        t||(r=0)
    }
    return r
}

Perl, 89 (khó)

86 ký tự mã + 3 để chạy với -ptùy chọn

@a=0;$a[abs($1-$2)]=1while s/(\S+) (\S+)/$2/;$_='Jolly';(grep{!defined}@a)&&s/J/Not j/

Javascript (cứng): 138

a=prompt().split(" ")
i=0;b=[];c=[]
while(b[i]=Math.abs(a[i]-a[++i]),c[i-1]=i,i<a.length-1);b.sort()
alert(b+""==c+""?"Jolly":"Not jolly")

    #!/usr/bin/env python

def main():
    pass

if __name__ == '__main__':
    main()

numbers = []
jolly_list = []

numbers = raw_input("Enter Numbers: ").split()
for count in range ( len(numbers)-1 ) :
    jolly_list.append ( abs( int(numbers[count]) - int(numbers[count+1]) ) )

jolly_list = sorted(jolly_list)
for count in range(len(jolly_list)) :
    flag = 0
    if count+1 == jolly_list[count] :
        flag = 1
    else :
        flag = 0
        print "Not Jolly"
        break
if flag == 1:
    print "Jolly"

R, Dễ, 110

f=function(s){p=NULL;l=length;for (i in 2:l(s))p=c(p,abs(s[i]-s[i-1]));ifelse(all(sort(p)==(1:(l(s)-1))),1,0)}

Sử dụng:

f(c(2, -1, 0, 2))
[1] 1
f(c(19, 22, 24, 25))
[1] 1
f(c(19, 22, 24, 21))
[1] 0

Python, 72 (dễ), 114 (cứng)

Dễ dàng:

def f(a):return len(set(map(lambda x,y:abs(x-y),a[1:],a[:-1])))>len(a)-2

Khó :

a=map(int,raw_input().split())
print('Not j','J')[len(set(map(lambda x,y:abs(x-y),a[1:],a[:-1])))>len(a)-2]+'olly'

Python, 255 ký tự

r=[19,22,24,25]
i=0
k=[ i+1 for i in range(len(r)-1)]
def jolly(a):
    p=[]
    i=0
    while i<len(a)-1: 
       p.append(abs(a[i+1]-a[i]))
       i+=1
    p.sort() 
    if p==k:
       return 'jolly'
    else:
       return 'Not jolly'

print(jolly(r))

C, 119 (khó), 97 (dễ)

b,c,a[];main(k){while(~scanf("%d",a+c))k=c++;for(c=k;b<c*c;)k-abs(a[b%c]-a[b++%c+1])?:k--;puts(k?"Not jolly":"Jolly");}

Giải pháp dễ dàng đọc đầu vào từ các đối số và trả về 0 dưới dạng mã thoát nếu đầu vào là một chuỗi jumper jolly:

i,k;main(int c,char**a){for(k=c-=2,a++;i<c*c;)k-abs(atoi(a[i%c])-atoi(a[i++%c+1]))?:k--;exit(k);}

APL ( 50 49 47, cứng)

'Not jolly' 'Jolly'[1+K[⍋K←¯1↓|Z-1⌽Z]≡¯1↓⍳⍴Z←⎕]

Dễ dàng (24):

{K[⍋K←¯1↓|⍵-1⌽⍵]≡¯1↓⍳⍴⍵}

Hàm lấy một mảng và trả về 0 hoặc 1.