如果连续元素之间的差值的绝对值取从1到n-1的所有值，则n> 0整数的序列称为“欢乐跳线”。

因此序列[4,1,2,4]的绝对差[3,1,2]等于集合[1,2,3]（1到n-1，其中n是原始序列的长度）因此，它是一个快乐的跳线。

序列的长度为n> 0。

假设n = 1是一个快乐的跳线。

简易模式：不用担心stdin / stdout。只是一个函数，它接受参数并返回一些表明是否快乐的信息

硬模式：在stdin上输入（以空格分隔），输出为“ Jolly” /“ Not jolly”。资本化问题。

这是代码高尔夫。

编辑：序列可以包含负整数，并且stdin上的输入以空格分隔。

$ jolly 2 -1 0 2
Jolly

$ jolly 19 22 24 25
Jolly

$ jolly 19 22 24 21
Not jolly

哈斯克尔

简单的4个字符

当且仅当将欢乐整数列表作为输入给出时，才返回欢乐整数列表。这是基于“仅是一个接受参数并返回表明快慢的函数”的合法方法。

j=id

带有61个字符的替代简单解决方案：

接收列表，如果序列是快乐的，则返回空列表。

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

Ruby，92 93个字符

带有STDIN输入的硬版本。

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

如果以-pa（计数为4）开头，则可以节省5个字符：

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

Java（硬）

假设输入是通过stdin给出的。（不按照示例通过命令行参数）

高尔夫-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");
}
}

未打高尔夫球

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，简易模式，123个字符

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}

要在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，简易模式，21 18个字符

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

接受参数作为堆栈上的一个int数组，堆栈上没有其他内容；如果是欢乐，则在堆栈上保留1，否则保留0。要将标准输入输入为以空格分隔的整数列表，请添加前缀

~]

并输出“ Jolly” /“ Not jolly”（假设我们将其转换为程序）

"Not jJ"5/="olly"

J（轻松），18岁

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

   （i。@＃-：<：/：]）| 2-/ \ 2 _1 0 2
1个
   （i。@＃-：<：/：]）| 2-/ \ 19 22 24 25
1个
   （i。@＃-：<：/：]）| 2-/ \ 19 22 24 21
0

J（难），68

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

$ jconsole jumper.ijs 2 -1 0 2
欢乐
$ jconsole jumper.ijs 19 22 24 25
欢乐
$ jconsole jumper.ijs 2 19 22 24 21
不愉快

Brachylog，11个字节（简单）

s₂ᶠ-ᵐȧᵐo~⟦₁

在线尝试！

s₂ᶠ-ᵐ -连续差异

ȧᵐ -绝对值

o -排序

~⟦₁ -结果是1到某范围吗？

J，30 26简易模式，81 76硬模式

编辑：处理列表少于3个，修复标准输入

第一行处理简单模式，第二行增加硬模式。

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

J通常从右到左读取：

2-/\ ：对于列表中的每两个连续数字，取差值

| ： 绝对值

/:~ ：升序排列

>:@i.@#：1至n，用于n个数字的列表

= ：比较排序后的差异与序列（使用J“ fork”）

*/：将所有元素级布尔值相乘；如果所有比较均为1，则其乘积为1，所以很高兴

红宝石，97 102 106（硬）

可能也是如此，因为其他所有人都是：

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"

输入在标准输入上。

d

简单（103 83个字符）

如果不返回，则在Jolly上返回1..i.length的总和（如果没有，则在此处放一些规则）

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

辛苦（142个字符）

输入是由空格分隔并以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

易：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]

硬性：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硬117126

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

历史：

• 2011-11-18 17:54（123，-3）–更改$null为不存在的变量
• 2011-11-18 18:02（117，−6）–内联所有变量声明

斯卡拉

快速刺刺-可能会有改进。

易：77

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

硬性：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（困难），30（容易）

硬

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

简单

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

J（简单），19个字符

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

用法：

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

变化与DCharness的答案类似，我只是将其添加为评论，但因为自2月23日以来他没有来过。

2-/\ 取连续数字对之间的差，

| 获取每个数字的绝对值，

/:~ 升序排列

<: 将每个数字减1，

(=i.@#)一个J钩子，生成从0到差异列表-1（i.@#）长度的数字序列，并将其与该列表进行比较=。

*/将前一个动词生成的1s和0s 的列表乘以。

阶容易：138 153 170（是errornous，后来改进的）

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}

松开

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
}

这个想法是，我们建立第二个推导：

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

斯卡拉硬172 182，205（是errornous /改善）：

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

与上面大致相同。

简易PHP，129

对于给定$s的整数数组：

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

非高尔夫版本：

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

果冻，7 6个字节（简单）

IAṢ⁼J$

在线尝试！

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

在第一个参数中将输入作为逗号分隔的数字。如果序列是快乐的，则返回1，否则返回0！

7字节解决方案：

LRṖḟIA$

在线尝试！

在第一个参数中将输入作为逗号分隔的数字。返回咱这列表是一个快活的跳线序列，以及东西，如果它不是。

添加此行使其适用于严格规格：

果冻，27 22字节（辛苦，欢迎反馈！）

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

在线尝试！

ɠḲ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!

27字节（硬）解决方案：

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

在线尝试！

用空格分隔数字 stdin，并输出“ Jolly”或“ Not jolly”。

说明：

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

任何反馈非常感谢！

Haskell，59 57字节

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

简易模式，将欢乐作为布尔值返回。感谢@Laikoni提供了两个字节。

在线尝试！

Japt，32个 30字节硬

@Shaggy的-2字节

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

在线尝试！

Python 3，117（困难）

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

在线尝试！

JavaScript：105（简易模式）

打高尔夫球：

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}

未打高尔夫球：

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（难）

86个字符的代码+ 3个可与-p选项一起运行

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

Javascript（硬）：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，易，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)}

用法：

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（简单），114（困难）

简单：

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

硬：

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个字符

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（难），97（易）

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

简单的解决方案从参数中读取输入，如果输入是一个欢乐的跳线序列，则返回0作为退出代码：

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，硬）

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

易（24）：

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

该函数接受一个数组并返回0或1。