연속적인 요소들 사이의 차이의 절대 값이 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]

루비, 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"

자바 (하드)

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

스칼라, 쉬운 모드, 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"))
   }
}

골프 스크립트, 쉬운 모드, 21 18 자

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

스택에 다른 인수를 사용하지 않고 스택에 정수 배열을 인수로 허용합니다. 유쾌한 경우 스택에 1을 남기고 그렇지 않으면 0을 남깁니다. 공백으로 구분 된 정수 목록으로 stdin에 입력을 받으려면 앞에 추가하십시오.

~]

그리고 "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보다 짧은 목록 처리, stdin 판독 수정

첫 번째 줄은 easy 모드를 처리하고 두 번째 줄은 hard 모드를 추가합니다.

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

J는 일반적으로 오른쪽에서 왼쪽으로 읽습니다.

2-/\ : 목록에있는 두 개의 연속 된 숫자마다 차이를 가져옵니다.

| : 절대 값

/:~ : 오름차순으로 정렬

>:@i.@#: 1 ~ n , n 목록 숫자

= : 정렬 된 차이를 순서와 비교 (J "포크"사용)

*/: 모든 요소 별 부울을 곱합니다. 모든 비교가 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"

stdin에서 가져온 입력

디

쉬운 ( 103 83 문자)

그렇지 않으면 다른 숫자 Jolly에서 1.i 길이의 합을 반환합니다 (여기서는 약간의 규칙이 적용됩니다)

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

그루비

쉬움 : 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을 하드 117 126

('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.@#)과 그리스트와 비교한다 =.

*/배수의 목록 1들과 0이전의 동사에 의해 생성 된의.

스칼라이지 : 138 138153, 170 (에러 노스, 나중에 개선)

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

스칼라 하드 172182, 205 172182 (오류 / 개선) :

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

모든 의견에 감사드립니다!

하스켈 , 59 57 바이트

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

쉬운 모드, 유쾌함을 부울로 반환합니다. 2 바이트 동안 @Laikoni에게 감사드립니다.

온라인으로 사용해보십시오!

Japt , 32 30 바이트 하드

@Shaggy에서 -2 바이트

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

온라인으로 사용해보십시오!

파이썬 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")

온라인으로 사용해보십시오!

자바 스크립트 : 105 (easy 모드)

골프 :

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
}

펄, 89 (하드)

-p옵션으로 실행하기위한 86 자 코드 + 3

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

자바 스크립트 (하드) : 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

파이썬, 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'

파이썬, 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을 반환합니다.