Eine Folge von n> 0 ganzen Zahlen wird als lustiger Jumper bezeichnet, wenn die absoluten Werte der Differenz zwischen aufeinanderfolgenden Elementen alle Werte 1 bis n-1 annehmen.

Die Folge [4,1,2,4] hat also absolute Differenzen [3,1,2], die der Menge [1,2,3] entsprechen (1 bis n-1, wobei n die Länge der ursprünglichen Folge ist). es ist also ein lustiger jumper.

Sequenzen haben die Länge n> 0.

Angenommen, n = 1 ist ein lustiger Jumper.

Einfacher Modus: Sorgen Sie sich nicht um stdin / stdout. Nur eine Funktion, die Argumente akzeptiert und etwas zurückgibt , das fröhlich ist oder nicht

Hard mode: Input on stdin (Leerzeichen getrennt) und Output ist "Jolly" / "Not Jolly". Kapitalisierung Angelegenheiten.

Das ist Code Golf.

BEARBEITEN: Sequenzen können negative Ganzzahlen enthalten und die Eingabe in stdin ist durch Leerzeichen getrennt.

$ jolly 2 -1 0 2
Jolly

$ jolly 19 22 24 25
Jolly

$ jolly 19 22 24 21
Not jolly

Haskell

Einfache 4 Zeichen

Gibt nur dann eine Liste mit lustigen Ganzzahlen zurück, wenn eine Liste mit lustigen Ganzzahlen als Eingabe angegeben wurde. Dies ist legal, basierend auf "Nur eine Funktion, die Argumente akzeptiert und etwas zurückgibt, das fröhlich ist oder nicht".

j=id

Alternative einfache Lösung mit 61 Zeichen:

Nimmt eine Liste auf und gibt die leere Liste zurück, wenn die Sequenz lustig ist.

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

Ruby, 92 93 Zeichen

Die harte Version mit STDIN-Eingaben.

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

Wenn Sie es mit -pa(zählt als 4) beginnen, können Sie 5 Zeichen sparen:

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

Java (schwer)

Angenommen, die Eingabe erfolgt über stdin. (nicht durch Kommandozeilenargumente wie im Beispiel)

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

Ungolfen

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, easy mode, 123 Zeichen

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}

Auf ideone.com ausführen oder testen:

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, easy mode, 21 18 Zeichen

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

Akzeptiert Argumente als ein Array von Ints auf dem Stapel, während sich nichts anderes auf dem Stapel befindet. Lässt 1 auf dem Stapel, wenn es lustig ist und 0 sonst. Wenn Sie stdin als durch Leerzeichen getrennte Liste von Ints eingeben möchten, müssen Sie voranstellen

~]

und "Jolly" / "Not Jolly" (vorausgesetzt, wir machen daraus ein Programm) postpend auszugeben

"Not jJ"5/="olly"

J (leicht), 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 (hart), 68

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

$ jconsole jumper.ijs 2 -1 0 2
Lustig
$ jconsole jumper.ijs 19 22 24 25
Lustig
$ jconsole jumper.ijs 2 19 22 24 21
Nicht lustig

Brachylog , 11 Bytes (einfach)

s₂ᶠ-ᵐȧᵐo~⟦₁

Probieren Sie es online!

s₂ᶠ-ᵐ - Aufeinanderfolgende Unterschiede

ȧᵐ - Absolute Werte

o - Sortieren

~⟦₁ - Liegt das Ergebnis im Bereich 1 bis etwas?

J, 30 26 easy mode, 81 76 hard mode

edit: liste kürzer als 3 handhaben, stdin lesung korrigieren

Die erste Zeile kümmert sich um den einfachen Modus, die zweite um den harten Modus.

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

J liest im Allgemeinen von rechts nach links:

2-/\ : Für jeweils zwei aufeinanderfolgende Nummern in der Liste den Unterschied nehmen

| : Absolutwert

/:~ : aufsteigend sortieren

>:@i.@#: 1 bis n , für eine Liste von n Zahlen

= : Vergleiche die sortierten Unterschiede mit der Reihenfolge (mit einer J "Gabel")

*/: multipliziere alle elementweisen Booleschen Werte; Wenn alle Vergleiche 1 waren, ist ihr Produkt 1, also ist es lustig

Ruby, 97 102 106 (schwer)

Könnte auch sein, denn alle anderen sind:

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"

Eingabe auf stdin übernommen.

D

leicht ( 103 83 Zeichen)

Gibt eine Summe von 1..i.length auf Jolly zurück, wenn nicht (ein paar Regeln, die hier festgelegt sind)

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

hart (142 Zeichen)

Die Eingabe ist durch Leerzeichen getrennt und endet mit 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

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

Schwer: 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, schwer, 117 126

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

Geschichte:

• 2011-11-18 17:54 ( 123 , −3) - In $nulleine nicht vorhandene Variable geändert
• 2011-11-18 18:02 ( 117 , −6) - Alle Variablendeklarationen wurden eingefügt

Scala

Ein kurzer Stich - es sind wahrscheinlich Verbesserungen möglich.

Einfach: 77

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

Schwer: 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 (schwer), 30 (leicht)

schwer

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

einfach

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

J (leicht), 19 Zeichen

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

Verwendung:

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

Variieren Sie ähnlich wie bei DCharness , und ich hätte es nur als Kommentar hinzugefügt, ohne dass er es seit dem 23. Februar nicht mehr besucht hat.

2-/\ Nimmt den Unterschied zwischen aufeinanderfolgenden Zahlenpaaren,

| erhält den absoluten Wert jeder Zahl,

/:~ sortiert in aufsteigender Reihenfolge,

<: verringert jede Zahl um 1,

(=i.@#)ein J-Hook, der die Folge von Zahlen von 0 bis zur Länge der Differenzliste - 1 ( i.@#) erzeugt und mit dieser Liste vergleicht =.

*/multipliziert die vom vorherigen Verb erzeugte Liste von 1s und 0s.

Scala easy: 138 153, 170 (war fehlerhaft, später verbessert)

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
}

Die Idee ist, dass wir die zweite Ableitung bauen:

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 (war fehlerhaft / verbessert):

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

mehr oder weniger das gleiche wie oben.

PHP, einfach, 129

Für ein bestimmtes Array $svon Ganzzahlen:

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

Die ungolfed Version:

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

Gelee , 7 6 Bytes (einfach)

IAṢ⁼J$

Probieren Sie es online!

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

Übernimmt die Eingabe als durch Kommas getrennte Zahlen im ersten Argument. Gibt 1 zurück, wenn die Sequenz lustig ist, und 0, wenn dies nicht der Fall ist!

7-Byte-Lösung:

LRṖḟIA$

Probieren Sie es online!

Übernimmt die Eingabe als durch Kommas getrennte Zahlen im ersten Argument. Returns nichts , wenn die Liste eine Jolly Jumper - Sequenz ist, und etwas wenn dies nicht der ist.

Wenn Sie diese Zeile hinzufügen, funktioniert dies mit der Hardspezifikation:

Jelly , 27 22 Bytes (hart, Feedback erwünscht!)

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

Probieren Sie es online!

ɠḲ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 Byte (harte) Lösung:

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

Probieren Sie es online!

Nimmt durch Leerzeichen getrennte Zahlen auf stdinund gibt "Jolly" oder "Not Jolly" aus.

Erläuterung:

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

Jedes Feedback sehr geschätzt!

Haskell , 59-57 Bytes

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

Einfacher Modus, gibt Lustigkeit als Booleschen Wert zurück. Danke an @Laikoni für zwei Bytes.

Probieren Sie es online!

Japt , 32 30 Bytes schwer

-2 Bytes von @Shaggy

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

Probieren Sie es online!

Python 3, 117 (schwer)

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

Probieren Sie es online!

JavaScript: 105 (einfacher Modus)

Golf gespielt:

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}

Nicht golfen:

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

86 Zeichen Code + 3 für die Ausführung mit der -pOption

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

Javascript (schwer): 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, leicht, 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)}

Verwendung:

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 (leicht), 114 (schwer)

Einfach:

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

Schwer :

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 Zeichen

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 (schwer), 97 (leicht)

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

Die einfache Lösung liest die Eingabe aus den Argumenten und gibt eine 0 als Exit-Code zurück, wenn die Eingabe eine lustige Jumpersequenz ist:

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

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

Leicht (24):

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

Die Funktion nimmt ein Array und gibt 0 oder 1 zurück.