Birbirini izleyen elemanlar arasındaki farkın mutlak değerleri 1'den n-1'e kadar tüm değerleri alırsa, n> 0 tamsayılar dizisine jolly atlama teli denir.

Böylece [4,1,2,4] dizisi, [1,2,3] kümesine eşdeğer olan mutlak farklılıklara [3,1,2] sahiptir (1 ila n-1; burada n, orijinal dizinin uzunluğudur) bu yüzden neşeli bir jumper.

Diziler n> 0 uzunluğuna sahiptir.

N = 1'in neşeli bir atlama kablosu olduğunu varsayın.

Kolay mod: Stdin / stdout için endişelenme. Ancak argümanlar ve iadeler kabul Sadece bir fonksiyon şey neşeli olmadığını gösterir

Sert mod: Stdin giriş (boşluk ayrılmış) ve çıkış "Jolly" / "Jolly değil" dir. Büyük harf kullanımı önemlidir.

Bu kod golf.

DÜZENLEME: Diziler negatif tamsayılar içerebilir ve stdin girdisi boşlukla ayrılmıştır.

$ jolly 2 -1 0 2
Jolly

$ jolly 19 22 24 25
Jolly

$ jolly 19 22 24 21
Not jolly

Haskell

Kolay 4 karakter

Yalnızca tam olarak bir tamsayı listesi girdi olarak verilmişse, bir tamsayılar listesi döndürür. Bu yasal olarak "Sadece argümanları kabul eden ve jolly olup olmadığını gösteren bir şey döndüren bir fonksiyon" temeline dayanır.

j=id

61 karakterli alternatif kolay çözüm:

Bir listeyi alır ve dizi neşeli ise boş listeyi döndürür.

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

Ruby, 92 93 karakter

STDIN üzerinde girişi olan sabit versiyon.

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

Eğer ile başlarsanız -pa(4 olarak sayılır) 5 karakter kaydedebilirsiniz:

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

Java (Sabit)

Girdinin stdin yoluyla verildiğini varsayar. (komut satırı bağımsız değişkenleri yoluyla değil)

Golf sahasında - 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");
}
}

Un-golfed

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, kolay mod, 123 karakter

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}

İdeone.com'da çalıştırmak veya test etmek için:

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, kolay mod, 21 18 karakter

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

Argümanları yığın üzerinde bir ints dizisi olarak kabul eder ve yığın üzerinde başka bir şey yoktur; eğer neşeli ise yığınta 1, aksi takdirde 0 bırakır. Stdin girdisini boşlukla ayrılmış bir ints listesi olarak almak için

~]

ve "Jolly" / "jolly değil" (bunu bir programa dönüştürdüğümüzü varsayarak)

"Not jJ"5/="olly"

J (kolay), 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 (sert), 68

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

$ jconsole jumper.ijs 2 -1 0 2
neşeli
$ jconsole jumper.ijs 19 22 24 25
neşeli
$ jconsole jumper.ijs 2 19 22 24 21
Neşeli değil

Brachylog , 11 bayt (kolay)

s₂ᶠ-ᵐȧᵐo~⟦₁

Çevrimiçi deneyin!

s₂ᶠ-ᵐ - Ardışık farklılıklar

ȧᵐ - Mutlak değerler

o - Çeşit

~⟦₁ - Sonuç 1 aralığına bir şey mi?

J, 30 26 kolay mod, 81 76 zor mod

düzenleme: 3'ten kısa listeleri işlemek, stdin okuma düzeltmek

İlk satır kolay modu, ikincisi zor modu ekler.

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

J genellikle sağdan sola okur:

2-/\ : listedeki birbirini izleyen her iki sayı için farkı alın

| : mutlak değer

/:~ : artan düzende sırala

>:@i.@#: 1 n , bir listesi için n numaralar

= : sıralanan farklılıkları sıra ile karşılaştırır (bir J "çatal" kullanarak)

*/: tüm element-bilge booleanları çarpın; tüm karşılaştırmalar 1 olsaydı, ürünleri 1'dir, bu yüzden neşeli

Yakut, 97 102 106 (sert)

Herkes olabilir, çünkü:

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"

Girdi stdin.

D

kolay ( 103 83 karakter)

Jolly'de başka bir sayı varsa 1..i.length toplamını döndürür (burada biraz kurallar dizilir)

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

sert (142 karakter)

girdi boşlukla sınırlandırılmış ve EOF ile bitiyor

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

harika

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

Zor: 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, sabit, 117126

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

Tarih:

• 2011-11-18 17:54 ( 123 , −3) - Var $nullolmayan bir değişken olarak değiştirildi
• 2011-11-18 18:02 ( 117 , −6) - tüm değişken bildirimleri satır içine aldı

Scala

Hızlı bir bıçak - muhtemelen iyileştirmeler mümkündür.

Kolay: 77

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

Zor: 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 (zor), 30 (kolay)

zor

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

kolay

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

J (kolay), 19 karakter

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

Kullanımı:

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

DCharness'ın cevabına benzer şekilde değişir ve bunu sadece bir yorum olarak eklerdim , ancak 23 Şubat'tan beri ziyaret etmediği için.

2-/\ ardışık sayı çiftleri arasındaki farkı alır,

| her sayının mutlak değerini alır,

/:~ artan düzende sıralar,

<: her sayıyı 1 azaltır,

(=i.@#)0'dan farklar listesi - 1 ( ) uzunluğuna kadar sayı dizisi üreten ve bu listeyle karşılaştıran bir J kancası .i.@#=

*/önceki fiil tarafından üretilen 1s ve 0s listesini çarpar.

Scala easy: 138155, 170 (hata oldu, daha sonra geliştirildi)

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}

ungolfed:

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
}

Fikir, ikinci türevi oluşturduğumuz:

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 172182 , 205 (hata / iyileştirme yapıldı):

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

aşağı yukarı yukarıdakiyle aynı.

PHP, kolay, 129

Belirli bir $stamsayı dizisi için:

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

Çözülmemiş versiyon:

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

Jöle , 7 6 bayt (kolay)

IAṢ⁼J$

Çevrimiçi deneyin!

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

İlk bağımsız değişkende girdiyi virgülle ayrılmış sayılar olarak alır. Sıra neşeli ise 1, değilse 0 döndürür!

7 baytlık çözelti:

LRṖḟIA$

Çevrimiçi deneyin!

İlk bağımsız değişkende girdiyi virgülle ayrılmış sayılar olarak alır. İade şey liste neşeli atlamacı dizisi ise ve bir şey o değilse.

Bu satırı eklemek, zor özelliklerle çalışmasını sağlar:

Jelly , 27 22 bayt (sert, geri bildirim hoş geldiniz!)

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

Çevrimiçi deneyin!

ɠḲ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 bayt (sert) çözelti:

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

Çevrimiçi deneyin!

Boşluklarla ayrılmış sayıları alır stdin ve "Jolly" veya "Jolly değil" çıktıları verir.

Açıklama:

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

Herhangi bir geri bildirim çok takdir!

Haskell , 59 57 bayt

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

Kolay mod, neşeli olmayı bir boole olarak döndürür. @Laikoni'ye iki bayt için teşekkürler.

Çevrimiçi deneyin!

Japt , 32 30 bayt Sabit

@Shaggy gelen -2 Bayt

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

Çevrimiçi deneyin!

Python 3, 117 (sert)

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

Çevrimiçi deneyin!

JavaScript: 105 (kolay mod)

golfed:

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}

Un-golfed:

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 (sert)

-pSeçenekle çalıştırmak için 86 kod + 3 karakter

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

Javascript (zor): 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, Kolay, 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)}

Kullanımı:

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 (kolay), 114 (zor)

Kolay:

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

Zor :

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 karakter

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 (sert), 97 (kolay)

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

Kolay çözüm, bağımsız değişkenlerden gelen girdiyi okur ve giriş jolly atlama teli dizisiyse çıkış kodu olarak 0 değerini döndürür:

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, sert)

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

Kolay (24):

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

İşlev bir dizi alır ve 0 veya 1 değerini döndürür.