जॉली जम्पर सीक्वेंस

15

N> 0 पूर्णांक के एक अनुक्रम को जॉली जम्पर कहा जाता है, यदि क्रमिक तत्वों के बीच अंतर का निरपेक्ष मान सभी मानों को n-1 के माध्यम से लेता है।

तो अनुक्रम [4,1,2,4] में पूर्ण अंतर है [3,1,2] जो सेट के बराबर है [1,2,3] (1 से n-1 जहां n मूल अनुक्रम की लंबाई है) इसलिए यह एक जॉली जम्पर है।

दृश्यों की लंबाई n> 0 है।

मान लें कि n = 1 एक जॉली जम्पर है।

आसान तरीका: स्टड / स्टडआउट के बारे में चिंता न करें। बस एक फ़ंक्शन जो तर्कों को स्वीकार करता है और कुछ ऐसा लौटाता है जो जॉली को इंगित करता है या नहीं

हार्ड मोड: स्टड पर इनपुट (अंतरिक्ष अलग), और आउटपुट "जॉली" / "जॉली नहीं" है। पूंजीकरण मामलें।

यह कोड गोल्फ है।

संपादित करें: अनुक्रम में नकारात्मक पूर्णांक हो सकते हैं और स्टड पर इनपुट अलग हो जाता है।

$ jolly 2 -1 0 2
Jolly

$ jolly 19 22 24 25
Jolly

$ jolly 19 22 24 21
Not jolly
code-golf  sequence 
— eternalmatt
स्रोत
1
अनुक्रम कैसे दिया जाता है? एक तार के रूप में? "4124"?
— स्टीवन रूंबल्स्की
मुझे लगता है कि अंतरिक्ष-पृथक सबसे आम सम्मेलन होगा, इसलिए मैं कहूंगा कि।
— शाश्वत 15
6
आप कहते हैं कि इनपुट स्टडिन पर है, लेकिन आपके उदाहरण इनपुट को कमांड लाइन तर्क के रूप में लेते हैं। हमें किससे उम्मीद करनी चाहिए?
— गैरेथ

जवाबों:

3

हास्केल

आसान 4 वर्ण

जॉली पूर्णांकों की सूची लौटाता है यदि और केवल जॉली पूर्णांकों की सूची इनपुट के रूप में दी जाती है। यह "बस एक फ़ंक्शन पर आधारित है, जो कि तर्कों को स्वीकार करता है और कुछ ऐसा लौटाता है जो जॉली या नहीं इंगित करता है" पर आधारित है।

j=id

61 पात्रों के साथ वैकल्पिक आसान समाधान:

एक सूची में ले जाता है और यदि अनुक्रम जॉली है तो खाली सूची देता है।

import List
j n=zipWith(\x->abs.(x-))n(tail n)\\[1..length n]
— थॉमस ईडिंग
स्रोत
1
+1 अच्छे नियम कानून। हालाँकि मुझे कहना चाहिए कि गोल्फस्क्रिप्ट में खाली कार्यक्रम पर्याप्त होगा ...
— पीटर टेलर
वैकल्पिक समाधान गलत परिणाम देता है। [1,3]जॉली नहीं है, क्या यह है? मुझे लगता है कि आपको length n-1इसके बजाय पुनरावृत्त होना चाहिए ।
— रतसर
2

रूबी, 92 93 वर्ण

STDIN पर इनपुट के साथ हार्ड संस्करण।

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

यदि आप इसे -pa4 के रूप में गिनते हैं, तो आप 5 वर्णों को बचा सकते हैं:

f=$F.each_cons(2).map{|a|eval(a*?-).abs}.sort
$_=(f==[*1..f.size]??J:"Not j")+"olly"
— हावर्ड
स्रोत
आह, अच्छा सुधार। महसूस नहीं किया था कि प्रत्येक_कोन्स विधि थी।
— मिग्मारू
मुझे बस एहसास हुआ कि यह तब विफल होता है जब अनुक्रम एक अंक होता है। आपको f.size के बजाय f [-1] के साथ रहना होगा।
— मिगिमारू
यदि आप इसे विकल्पों के साथ चलाते हैं, तो ओह, आप 5 वर्णों को भी सहेज सकते हैं -pa।
— मिगिमारू
2

जावा (हार्ड)

मान लेता है कि इनपुट स्टड के माध्यम से दिया गया है। (उदाहरण के अनुसार कमांड लाइन तर्कों के माध्यम से नहीं)

गोल्फ - 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");
}
}

संयुक्त राष्ट्र के 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");
}
}
— जोश-fuggle
स्रोत
2

स्काला, आसान मोड, 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"))
   }
}
— गैरेथ
स्रोत
नाम कूदने के बजाय j हो सकता है।
— उपयोगकर्ता अज्ञात
@user अज्ञात हाँ, मुझे पता है। मुझे यह पोस्ट करने के आधे घंटे बाद पता चला कि a) मैं विधि नाम को छोटा कर सकता हूं, और b) मुझे सेट के बजाय एक सूची का उपयोग करने की आवश्यकता है, या यह ठीक से काम नहीं करेगा। : -एस
— गैरेथ
और अद्यतन नियमों से उम्मीद है कि संख्या को अंतरिक्ष से विभाजित किया जाएगा, 4124 एक, दो, तीन या 4 संख्याएं हो सकती हैं।
— उपयोगकर्ता अज्ञात
@user अज्ञात ओह महान। एक अन्य व्यक्ति ने एक प्रश्न पोस्ट किया और फिर नियमों को आधे रास्ते से बदल दिया।
— गैरेथ
मैंने 'झूठी' से पहले वापसी प्रकार बूलियन, एक शाब्दिक 'वापसी' को हटा दिया और गणित को गणित में बदल दिया। 137 से 123 तक की बचत।
— उपयोगकर्ता अज्ञात
2

गोल्फस्क्रिप्ट, आसान मोड, 21 18 वर्ण

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

ढेर पर और कुछ नहीं के साथ ढेर पर एक सरणी के रूप में तर्क स्वीकार करता है; स्टैक पर 1 छोड़ देता है अगर यह जॉली है और 0 अन्यथा। स्टेंट पर इनपुट को अंतरिक्ष की अलग-अलग सूची के रूप में इनपुट करने के लिए, पूर्व निर्धारित करें

~]

और उत्पादन करने के लिए "जॉली" / "जॉली नहीं" (यह मानते हुए कि हम इसे एक कार्यक्रम में बदल रहे हैं) स्थगित करें

"Not jJ"5/="olly"
— पीटर टेलर
स्रोत
मैं सोच रहा था कि यह संभवतः कैसे काम कर सकता है - मुझे यह महसूस करने में एक पल लगा कि जब आप "स्टैक पर ints की एक सूची" लिखते हैं, तो आप वास्तव में ints (यानी , नहीं ) की एक सूची का मतलब है । [4 1 2 4]4 1 2 4
— इल्मरी करोनें
@ इल्मारियारोन, अब यकीन नहीं होता कि मैंने "लिस्ट" क्यों लिखी। मैंने इसे स्पष्ट करने के लिए "सरणी" में संपादित किया है।
— पीटर टेलर
2

जे (आसान), 18

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

   (i। @ # -: <: /:]) | 2 - / \ 2 _1 0 2
1
   (i। @ # -: <: /:]) | 2 - / \ 19 22 24 25
1
   (i। @ # -: <: /:]) | 2 - / \ 19 22 24 21
0

जे (हार्ड), 68

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

$ जोंको कंसोल जम्पर.जिस 2 -1 0 2
विनोदी
$ जोंक कंसोल जम्पर.जिस 19 22 24 25
विनोदी
$ जोंकोलास जम्पर.जिस 2 19 22 24 21
जॉली नहीं
— ephemient
स्रोत
1

जे, 30 26 आसान मोड, 81 76 हार्ड मोड

संपादित करें: 3 से छोटी हैंडल की सूचियाँ, स्टड रीडिंग को ठीक करें

पहली पंक्ति आसान मोड का ख्याल रखती है, दूसरा हार्ड मोड जोड़ता है।

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

J आमतौर पर दाएं-बाएं पढ़ता है:

2-/\ : सूची में प्रत्येक दो क्रमिक संख्याओं के लिए, अंतर लें

| : निरपेक्ष मूल्य

/:~ : आरोही क्रम में क्रमबद्ध करें

>:@i.@#: N संख्याओं की सूची के लिए 1 से n

= अनुक्रम के साथ क्रमबद्ध मतभेदों की तुलना करें (J "कांटा" का उपयोग करके)

*/: सभी तत्व-वार बूलियन को गुणा करें; यदि सभी तुलना 1 थीं, तो उनका उत्पाद 1 है, इसलिए यह जॉली है

— DCharness
स्रोत
इनपुट पर विचार करें 1 3।
— पीटर टेलर
धन्यवाद, @ पेटर। फिक्स्ड ... और अभी भी अपने गोल्फस्क्रिप्ट के साथ प्रतिस्पर्धी नहीं है। बहुत बढ़िया।
— DCharness
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"

स्टड पर इनपुट लिया गया।

— migimaru
स्रोत
आप (1..d.size).to_aद्वारा प्रतिस्थापित कर सकते हैं [*1..d.size]। स्विचिंग ऑपरेंड अब संभव है, एक दूसरे को बचाता है (कुल -5 वर्ण)।
— हॉवर्ड
@ ओह ओह, तो यह है कि आप इसे कैसे करते हैं! मैं थोड़ी देर के लिए रेंज को सरणियों में परिवर्तित करने के लिए एक गोल्फ तरीका जानने की कोशिश कर रहा हूं। धन्यवाद!
— मिग्मारू
1

डी

आसान ( 103 83 वर्ण)

1. राशि की वापसी। जॉली पर किसी अन्य संख्या में गति। यदि नहीं (नियमों का एक सा भाग यहाँ)

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

कठिन (142 वर्ण)

इनपुट व्हॉट्सएप सीमांकित है और ईओएफ पर समाप्त होता है

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");}
— शाफ़्ट सनकी
स्रोत
1

ग्रूवी

आसान: 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"}
— आर्मंड
स्रोत
1

पॉवरशेल, हार्ड, 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) - सभी परिवर्तनीय घोषणाओं को झुका दिया
— एक छोटा सा सिक्का
स्रोत
1

स्काला

एक त्वरित छुरा - वहाँ संभव सुधार कर रहे हैं।

आसान: 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")
— लुइगी प्लिंज
स्रोत
ठीक है - हम खो गए हैं, लुइगी हमें मिल गया! :) CodeGolf पर आपका स्वागत है। तुरंत मैंने कुछ सीखना शुरू कर दिया। पहचानकर्ता के रूप में प्रश्न चिह्न? Whooo - किसने अनुमति दी? :)
— उपयोगकर्ता अज्ञात
हाँ, और सभी 1 चरित्र को दाढ़ी करने के लिए! यह एक अल्फ़ान्यूमेरिक वर्णों और ऑपरेटर वर्णों के बीच अंतर है (देखें stackoverflow.com/q/7656937/770361 ) जिसका अर्थ है कि आप कभी-कभी रिक्त स्थान छोड़ सकते हैं (लेकिन कभी-कभी अतिरिक्त की आवश्यकता होती है) और डॉट्स। कोड गोल्फ हालांकि सीखने के लिए बहुत अच्छा है - उड़ान के लिए एयरोबेटिक्स जैसा एक सा।
— लुइगी प्लिंज
1

क्यू, 64 (कठिन), 30 (आसान)

कठिन 

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

आसान

{(1_(!)(#)x)~asc abs 1_(-':)x}
— tmartin
स्रोत
1

जे (आसान), 19 अक्षर

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

उपयोग:

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

DCharness के उत्तर के समान भिन्न , और मैंने इसे केवल एक टिप्पणी के रूप में जोड़ा होगा, लेकिन इस तथ्य के लिए कि वह 23 फरवरी के बाद से दौरा नहीं किया है।

2-/\ क्रमिक जोड़े के बीच अंतर लेता है,

| प्रत्येक संख्या का पूर्ण मूल्य मिलता है,

/:~ आरोही क्रम में सॉर्ट करें,

<: 1 से प्रत्येक संख्या को घटाता है,

(=i.@#)एक जे हुक जो संख्याओं के क्रम को 0 से अंतर सूची की लंबाई तक उत्पन्न करता है - 1 ( i.@#) और उस सूची के साथ तुलना करता है= ।

*/पिछली क्रिया द्वारा उत्पन्न 1s और 0s की सूची को गुणा करता है।

— गैरेथ
स्रोत
जब तक मैंने अपना जवाब प्रस्तुत नहीं किया, तब तक हमें एहसास नहीं हुआ: हमने एक ही तरीका अपनाया, लेकिन मैंने एक चरित्र को बचाने के x-:yबजाय इस्तेमाल किया */x=y।
— एपेमिएंट
1

स्केल आसान: 138 153, 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}

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
}

विचार यह है, कि हम दूसरी व्युत्पत्ति का निर्माण करते हैं: 

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 (त्रुटिपूर्ण / बेहतर था):

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

कमोबेश यही हाल ऊपर का भी है।

— अज्ञात उपयोगकर्ता
स्रोत
इनपुट 4 1 2 5सही है। अभी भी मेरे सिर को पाने में कामयाब नहीं हुए हैं, हालांकि बाईं ओर ...
— गैरेथ
अरे हाँ, मुझे अपनी त्रुटि मिली। इसे दुरुस्त करने की जरूरत है।
— उपयोगकर्ता अज्ञात
readLineकंसोल से इनपुट लेता है, args
— स्टडिन
और j("1")फेंकता हैUnsupportedOperationException: empty.max
— लुइगी प्लिंज
क्षमा - आप स्टडिन और "कंसोल से इनपुट" के बीच अंतर को कैसे परिभाषित करते हैं?
— उपयोगकर्ता अज्ञात
1

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";
— बैरी ओ डोनोवन
स्रोत
1

जेली , 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 , और "जॉली" या "जॉली नहीं" आउटपुट।

स्पष्टीकरण:

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

किसी भी प्रतिक्रिया बहुत सराहना की!

— सताना
स्रोत
1
LRहै J। यदि आप कुछ लिखते हैं जैसे IAṢ⁼J$आपको एक अच्छा परिणाम मिलता है 1/0, और आप इसका उपयोग उस पर अनुक्रमित करने के लिए कर सकते हैं “Not jolly“Jolly”:ɠḲVIAṢ⁼J$ị“¢⁼D“¡KṀȥƘạ»
— Lynn
@Lynn धन्यवाद, यह बहुत बेहतर है! चारों ओर एक-अनुक्रमित रैपिंग के साथ चालाक चाल, और मैंने ⁼परमाणु के बारे में और भी सीखा , सूचियों के कुछ हिस्सों की तुलना करना आसान है।
— हैरी
1

जप , 32 30 बाइट्स हार्ड

-2 @ बग्गी से बाइट्स

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

इसे ऑनलाइन आज़माएं!

— लुइस फेलिप डी जीसस मुनोज
स्रोत
1
30 बाइट्स । मैंने केवल अंतिम सेकंड में पूंजीकरण की आवश्यकता पर ध्यान दिया है ताकि संभवत: इसे और बेहतर बनाया जा सके।
— झबरा
1

अजगर 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")

इसे ऑनलाइन आज़माएं!

— Андрей Ломакин
स्रोत
आपके प्रोग्राम में कोई त्रुटि है। इसे ऑनलाइन
— आजमाएं
यह पहले टेस्ट केस के लिए गलत उत्तर देता है। कृपया प्रश्न में निहित परीक्षण मामलों के लिए अपना कार्यक्रम देखें।
— mbomb007
शर्म महसूस करें, क्योंकि जब गलत संस्करण निश्चित रूप से रिवर्स आउटपुट भूल गया है, (
— Андрей Ломакин
PPCG में आपका स्वागत है !!
— लुइस फेलिप डी जीसस मुनोज
0

जावास्क्रिप्ट: 105 (आसान मोड)

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}

संयुक्त राष्ट्र के 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
}
— Briguy37
स्रोत
0

पर्ल, 89 (कठोर)

-pविकल्प के साथ चलने के लिए कोड + 3 के 86 अक्षर

@a=0;$a[abs($1-$2)]=1while s/(\S+) (\S+)/$2/;$_='Jolly';(grep{!defined}@a)&&s/J/Not j/
— DCharness
स्रोत
0 
    #!/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"
— जॉन मिलर
स्रोत
2
नमस्ते जॉन और आपका स्वागत है। कोड गोल्फ का विचार है, जहां तक ​​आप कर सकते हैं आकार को कम करना। मैं एक अजगर नहीं हूँ, लेकिन "नंबर दर्ज करें" निश्चित रूप से बहुत ही कम है।
— उपयोगकर्ता अनजान
0

आर, आसान, 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
— पाओलो
स्रोत
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'
— hallvabo
स्रोत
0

पायथन, 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))
— अश्विनी चौधरी
स्रोत
मैंने आपके उत्तर में भाषा का नाम और वर्ण गणना जोड़ दी है (यह पायथन के रूप में चलता है, इसलिए मैं यही मानता हूं)। मेरे द्वारा दिया गया कैरेक्टर काउंट यूजर्सस्क्रिप्ट द्वारा दिया गया है । आप शायद कुछ पात्रों को सहेजने के लिए पहले इंडेंटेशन स्तर को एक स्थान तक काट सकते हैं।
— गारेथ
0

सी, 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);}
— Quasimodo
स्रोत
0

एपीएल ( 50 49 47, कठोर)

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

आसान (24):

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

फ़ंक्शन एक सरणी लेता है और 0 या 1 देता है।

— मारीनस
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.