Une séquence de n> 0 entiers est appelée un jolly jumper si les valeurs absolues de la différence entre les éléments successifs prennent toutes les valeurs 1 à n-1.

Donc la séquence [4,1,2,4] a des différences absolues [3,1,2] qui est équivalente à l'ensemble [1,2,3] (1 à n-1 où n est la longueur de la séquence originale) c'est donc un jolly jumper.

Les séquences ont une longueur n> 0.

Supposons que n = 1 est un cavalier joyeux.

Mode facile: ne vous inquiétez pas de stdin / stdout. Juste une fonction qui accepte cependant les arguments et renvoie quelque chose qui indique joyeux ou non

Mode difficile: entrée sur stdin (séparés par des espaces), et la sortie est "Jolly" / "Not jolly". La capitalisation est importante.

C'est le golf de code.

EDIT: Les séquences peuvent contenir des entiers négatifs et les entrées sur stdin sont séparées par des espaces.

$ jolly 2 -1 0 2
Jolly

$ jolly 19 22 24 25
Jolly

$ jolly 19 22 24 21
Not jolly

Haskell

Facile 4 caractères

Renvoie une liste d'entiers joyeux si et seulement si une liste d'entiers joyeux est donnée en entrée. C'est légal basé sur "juste une fonction qui accepte des arguments cependant et retourne quelque chose qui indique joyeux ou pas".

j=id

Solution alternative facile avec 61 caractères:

Prend une liste et renvoie la liste vide si la séquence est joyeuse.

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

Ruby, 92 93 caractères

La version hard avec entrée sur STDIN.

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

Si vous le démarrez avec -pa(compte pour 4), vous pouvez enregistrer 5 caractères:

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

Java (difficile)

Suppose que l'entrée est donnée via stdin. (pas via des arguments de ligne de commande comme par exemple)

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

Non-golfé

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, mode facile, 123 caractères

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}

Pour exécuter ou tester sur 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, mode facile, 21 18 caractères

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

Accepte les arguments comme un tableau d'entiers sur la pile, avec rien d'autre sur la pile; laisse 1 sur la pile si c'est gai et 0 sinon. Pour prendre l'entrée sur stdin en tant que liste d'entiers séparés par des espaces, ajoutez

~]

et pour sortir "Jolly" / "Not jolly" (en supposant que nous transformons cela en un programme) postpend

"Not jJ"5/="olly"

J (facile), 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 (dur), 68

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

$ jconsole jumper.ijs 2 -1 0 2
Gai
$ jconsole jumper.ijs 19 22 24 25
Gai
$ jconsole jumper.ijs 2 19 22 24 21
Pas joyeux

Brachylog , 11 octets (facile)

s₂ᶠ-ᵐȧᵐo~⟦₁

Essayez-le en ligne!

s₂ᶠ-ᵐ - Différences consécutives

ȧᵐ - Valeurs absolues

o - Trier

~⟦₁ - Le résultat est-il la plage 1 à quelque chose?

J, 30 26 en mode facile, 81 76 en mode difficile

modifier: gérer les listes inférieures à 3, corriger la lecture stdin

La première ligne s'occupe du mode facile, la seconde ajoute le mode difficile.

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

J lit généralement de droite à gauche:

2-/\ : pour chaque deux nombres successifs de la liste, faites la différence

| : valeur absolue

/:~ : trier par ordre croissant

>:@i.@#: 1 à n , pour une liste de n nombres

= : comparer les différences triées avec la séquence (à l'aide d'un "fork" J)

*/: multiplie tous les booléens par élément; si toutes les comparaisons étaient 1, leur produit est 1, donc c'est gai

Ruby, 97 102 106 (dur)

Peut-être aussi, puisque tout le monde est:

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"

Entrée prise sur stdin.

ré

facile ( 103 83 caractères)

renvoie la somme de 1..i.length sur Jolly un autre nombre sinon (un peu de règles qui traînent ici)

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

difficile (142 caractères)

l'entrée est délimitée par des espaces et se termine sur 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");}

Sensationnel

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

Difficile: 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, dur, 117126

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

Histoire:

• 2011-11-18 17:54 ( 123 , −3) - Changé $nullen une variable inexistante
• 2011-11-18 18:02 ( 117 , −6) - a inséré toutes les déclarations de variables

Scala

Un coup rapide - il y a probablement des améliorations possibles.

Facile: 77

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

Difficile: 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 (difficile), 30 (facile)

difficile

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

facile

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

J (facile), 19 caractères

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

Usage:

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

Varient comme la réponse de DCharness , et je l'aurais juste ajouté en tant que commentaire, mais pour le fait qu'il n'a pas visité depuis le 23 février.

2-/\ prend la différence entre des paires de nombres successifs,

| obtient la valeur absolue de chaque nombre,

/:~ trie par ordre croissant,

<: décrémente chaque nombre de 1,

(=i.@#)un crochet J qui génère la séquence de nombres de 0 à la longueur de la liste des différences - 1 ( i.@#) et la compare avec cette liste= .

*/multiplie la liste des 1s et 0s générée par le verbe précédent.

Scala facile: 138 153, 170 (était erroné, amélioré plus tard)

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}

non golfé:

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
}

L'idée est que nous construisons la deuxième dérivation:

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 dur 172 182, 205 (était erroné / amélioré):

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

plus ou moins les mêmes que ci-dessus.

PHP, facile, 129

Pour un tableau $sd'entiers donné:

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

La version non golfée:

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

Gelée , 7 6 octets (facile)

IAṢ⁼J$

Essayez-le en ligne!

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

Prend l'entrée sous forme de nombres séparés par des virgules dans le premier argument. Renvoie 1 si la séquence est joyeuse et 0 si elle ne l'est pas!

Solution à 7 octets:

LRṖḟIA$

Essayez-le en ligne!

Prend l'entrée sous forme de nombres séparés par des virgules dans le premier argument. Ne renvoie rien si la liste est une séquence de cavaliers joyeux et quelque chose si ce n'est pas le cas.

L'ajout de cette ligne le fait fonctionner avec la spécification difficile:

Jelly , 27 22 bytes (hard, feedback welcome!)

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

Essayez-le en ligne!

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

Solution (dure) de 27 octets:

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

Essayez-le en ligne!

Prend des nombres séparés par des espaces stdinet affiche "Jolly" ou "Not jolly".

Explication:

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

Tout commentaire très apprécié!

Haskell , 59 57 octets

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

Mode facile, renvoie la gaieté comme un booléen. Merci à @Laikoni pour deux octets.

Essayez-le en ligne!

Japt , 32 30 octets Hard

-2 octets de @Shaggy

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

Essayez-le en ligne!

Python 3, 117 (dur)

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

Essayez-le en ligne!

JavaScript: 105 (mode facile)

Golfé:

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}

Non golfé:

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

86 caractères de code + 3 pour courir avec l' -poption

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

Javascript (dur): 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, facile, 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)}

Usage:

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 (facile), 114 (difficile)

Facile:

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

Difficile :

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 caractères

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 (difficile), 97 (facile)

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

La solution facile lit l'entrée des arguments et retourne un 0 comme code de sortie si l'entrée est une séquence de cavaliers joyeux:

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

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

Facile (24):

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

La fonction prend un tableau et retourne 0 ou 1.