জলি জাম্পার সিকোয়েন্স

15

ধারাবাহিক উপাদানগুলির মধ্যে পার্থক্যের নিরঙ্কুশ মানগুলি এন -1 এর মাধ্যমে 1 মানগুলিকে গ্রহণ করে তবে n> 0 পূর্ণসংখ্যার একটি ক্রমকে একটি জলি জাম্পার বলা হয়।

সুতরাং ক্রম [4,1,2,4] এর সম্পূর্ণ পার্থক্য রয়েছে [3,1,2] যা সমান [1,2,3] এর সমতুল্য (1 থেকে এন -1 যেখানে এন মূল ক্রমের দৈর্ঘ্য) সুতরাং এটি তাই একটি আনন্দময় জাম্পার।

সিকোয়েন্সগুলির দৈর্ঘ্য 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"?
— স্টিভেন রাম্বালস্কি
আমি মনে করি স্থান দ্বারা পৃথক করা সর্বাধিক সাধারণ সম্মেলন হবে, তাই আমি এটি বলব।
— চিরকালীন
6
আপনি বলছেন ইনপুট স্টিডিনে রয়েছে, তবে আপনার উদাহরণগুলি কমান্ড লাইন আর্গুমেন্ট হিসাবে ইনপুট নেয়। আমাদের কোনটি আশা করা উচিত?
— গ্যারেথ

উত্তর:

3

Haskell,

সহজ 4 টি অক্ষর

জলি পূর্ণসংখ্যার একটি তালিকা যদি ইনপুট হিসাবে দেওয়া হয় কেবল এবং যদি জলি পূর্ণসংখ্যার একটি তালিকা ফেরত দেয়। এটি "কেবলমাত্র একটি ফাংশন যা আর্গুমেন্টগুলি গ্রহণ করে এবং এমন কিছু দেয় যা হাস্যকর বা না বোঝায়" এর ভিত্তিতে আইনী।

j=id

Characters১ টি অক্ষর সহ বিকল্প সহজ সমাধান:

একটি তালিকাতে নিয়ে যায় এবং ক্রমটি যদি আনন্দময় হয় তবে খালি তালিকাটি দেয়।

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"

আপনি যদি এটি দিয়ে শুরু করেন -pa(4 হিসাবে গণনা করা হয়) আপনি 5 টি অক্ষর সংরক্ষণ করতে পারেন:

f=$F.each_cons(2).map{|a|eval(a*?-).abs}.sort
$_=(f==[*1..f.size]??J:"Not j")+"olly"
— হাওয়ার্ড
সূত্র
আহ, চমৎকার উন্নতি। প্রতিটি_কন্স পদ্ধতি আছে বুঝতে পারেনি।
— মাইগিমারু
আমি কেবল বুঝতে পেরেছি যে ক্রমটি যখন একক অঙ্ক হয় তখন এটি ব্যর্থ হয়। আপনি পরিবর্তে f.size দিয়ে চলা আবশ্যক চ [-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}

আইডোন.কম এ চালানোর জন্য বা পরীক্ষা করতে:

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"))
   }
}
— গ্যারেথ
সূত্র
নামটি জাম্পের পরিবর্তে জে হতে পারে।
— ব্যবহারকারী অজ্ঞাত
@ ব্যবহারকারী অজানা হ্যাঁ, আমি জানি। আমি এটি পোস্ট করার প্রায় আধা ঘন্টা পরে বুঝতে পারি যে ক) আমি পদ্ধতির নামটি সংক্ষিপ্ত করতে পারি এবং খ) আমাকে একটি সেটের পরিবর্তে একটি তালিকা ব্যবহার করতে হবে, বা এটি সঠিকভাবে কাজ করবে না। : -এস
— গ্যারেথ
এবং আপডেট হওয়া নিয়মগুলি আশা করে যে সংখ্যাগুলি স্থান দ্বারা বিভক্ত করা হবে, 4124 এক, দুই, তিন বা 4 সংখ্যা হতে পারে।
— ব্যবহারকারী অজ্ঞাত
@ ব্যবহারকারী অজানা ওহ দুর্দান্ত। অন্য একজন ব্যক্তি একটি প্রশ্ন পোস্ট করছেন এবং তারপরে নিয়মগুলি অর্ধেক করে পরিবর্তন করছেন।
— গ্যারেথ
আমি রিটার্ন টাইপ বুলিয়ান সরিয়ে ফেললাম, 'মিথ্যা' এর আগে আক্ষরিক 'রিটার্ন' এবং ম্যাথকে গণিতে পরিবর্তন করেছি। 137 থেকে 123 পর্যন্ত সংরক্ষণ করা হচ্ছে
— ব্যবহারকারী অজানা
2

গল্ফস্ক্রিপ্ট, সহজ মোড, 21 18 টি অক্ষর

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

স্ট্যাকের ইনটসের অ্যারে হিসাবে আর্গুমেন্টগুলি গ্রহণ করে, স্ট্যাকের সাথে অন্য কিছুই নেই; এটি স্টাঙ্কে 1 টি ছেড়ে যায় যদি এটি খুব আনন্দিত হয় এবং অন্যথায় 0। ইনটগুলির স্পেস-বিভাজিত তালিকা হিসাবে স্টিডিনে ইনপুট নিতে, প্রিপেন্ড করুন

~]

এবং "জলি" / "জলি নয়" আউটপুট (ধরে নিই যে আমরা এটিকে একটি প্রোগ্রামে রূপান্তর করছি) পোস্টপেন্ড করুন

"Not jJ"5/="olly"
— পিটার টেলর
সূত্র
আমি ভাবছিলাম যে এটি কীভাবে সম্ভবত কাজ করতে পারে - এটি বুঝতে আমার একটি মুহুর্ত লেগেছিল যে আপনি যখন "স্ট্যাকের অন্তর্বাসের একটি তালিকা" লেখেন, আপনি সত্যিকার অর্থে ইনটগুলির একটি তালিকা (অর্থাত্ [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_

con jconsole jumper.ijs 2 -1 0 2
বলিষ্ঠ
con jconsole jumper.ijs 19 22 24 25
বলিষ্ঠ
con jconsole jumper.ijs 2 19 22 24 21
হাসিখুশি নয়
— ephemient
সূত্র
1

জে, 30 26 সহজ মোড, 81 76 হার্ড মোড

সম্পাদনা: হ্যান্ডেল 3 টির চেয়ে কম সংক্ষিপ্ত তালিকা, স্টিডিন পঠন স্থির করুন

প্রথম লাইন সহজ মোডের যত্ন নেয়, দ্বিতীয়টি হার্ড মোড যুক্ত করে।

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

জে সাধারণত ডান থেকে বামে পড়ে:

2-/\ : তালিকার প্রতিটি দুটি ধারাবাহিক সংখ্যার জন্য, পার্থক্যটি গ্রহণ করুন

| : পরম মান

/:~ : আরোহী ক্রম বাছাই

>:@i.@#এন সংখ্যাগুলির তালিকার জন্য 1 থেকে এন

= : অনুসারে বাছাই করা পার্থক্যগুলির তুলনা করুন (জে "কাঁটাচামচ" ব্যবহার করে)

*/: সমস্ত উপাদান-ভিত্তিক বুলিয়ান গুন; সমস্ত তুলনা যদি 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 অক্ষর)

জোলির উপরে আরও কয়েকটি সংখ্যার পরিমাণ ১.ii দৈর্ঘ্য প্রদান করে না (এখানে কিছু বিধি বিধি বিধান)

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

হার্ড (১৪২ টি চর)

ইনপুট হ'ল স্পেস ডিলিট এবং ইওএফ-এ শেষ হয়

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"}
— করুন Armand
সূত্র
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

scala

একটি দ্রুত ছুরিকাঘাত - সম্ভবত উন্নতি সম্ভব।

সহজ: 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")
— লুইজি প্লিঞ্জ
সূত্র
ঠিক আছে - আমরা হারিয়ে গেছি, লুইজি আমাদের খুঁজে পেয়েছে! :) কোডগল্ফ এ আপনাকে স্বাগতম। তাত্ক্ষণিকভাবে আমি কিছু শিখতে শুরু করি। সনাক্তকারী হিসাবে প্রশ্ন চিহ্ন? হু - কে অনুমতি দিয়েছে? :)
— ব্যবহারকারী অজানা
হ্যাঁ, এবং সমস্ত 1 টি অক্ষর শেভ করার জন্য! এটি একটি বর্ণমালার অক্ষর এবং অপারেটর অক্ষরের মধ্যে পার্থক্য ( স্ট্যাকওভারফ্লো.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

পিএইচপি, সহজ, 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ṀȥƘạ»
— লিন
@ লিন আপনাকে ধন্যবাদ, আরও অনেক ভাল! চারদিকে এক-সূচকযুক্ত মোড়কের সাথে চতুর কৌশল এবং আমি ⁼পরমাণু সম্পর্কে আরও শিখেছি , কেবল তালিকার কয়েকটি অংশের তুলনা করতে সক্ষম।
— হ্যারি
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
এটি প্রথম পরীক্ষার মামলার জন্য ভুল উত্তর দেয়। প্রশ্নে অন্তর্ভুক্ত পরীক্ষার কেসগুলির জন্য আপনার প্রোগ্রামটি পরীক্ষা করুন check
— mbomb007
লজ্জা বোধ করবেন, যখন নির্দিষ্ট সংস্করণটি আউটপুটগুলি উল্টাতে ভুলে গিয়েছিল;
— Андрей Ломакин
পিপিসিজিতে আপনাকে স্বাগতম!
— লুইস ফেলিপ দে জেসুস মুনোজ
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))
— অশ্বিনী চৌধুরী
সূত্র
আমি আপনার উত্তরে ভাষার নাম এবং চরিত্রের সংখ্যা যুক্ত করেছি (এটি পাইথনের হিসাবে চলে তাই এটি আমি অনুমান করি)। অক্ষর সংখ্যা আমি দিয়েছি এক দিতে হয় userscript । আপনি এখানে কিছু অক্ষর সংরক্ষণ করতে সম্ভবত প্রথম স্থান নির্ধারণের এক স্থানকে কেটে ফেলতে পারেন।
— গ্যারেথ
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 টি ইনপুটটি যদি একটি জম্পার ক্রম হয় তবে প্রস্থান কোড হিসাবে 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 প্রদান করে।

— সামুদ্রিক
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.