একটি পার্থক্য তালিকা বাছাই করুন

22

পূর্ণসংখ্যার তালিকার পার্থক্য তালিকাটি ক্রমাগত সদস্যদের তালিকার পার্থক্য।

উদাহরণস্বরূপ পার্থক্য তালিকা

1, 3, 2 ,4

হয়

2, -1, 2

আপনার কাজটি হ'ল আসল তালিকাটি বাছাই করা হলে পার্থক্য তালিকাটি কেমন হবে তা ইনপুট হিসাবে একটি পার্থক্য তালিকা এবং আউটপুট হিসাবে নেওয়া।

উদাহরণস্বরূপ পার্থক্য তালিকা

2, 1, -2, -1

একটি তালিকা হতে পারে

2 4 5 3 2

যা বাছাই করা হয় যখন

2 2 3 4 5

যার পার্থক্যের তালিকা রয়েছে

0 1 1 1

এটি কোড-গল্ফ তাই কম বাইট ভাল হওয়ার সাথে উত্তরগুলি বাইটে স্কোর করা হবে।

code-golf  array-manipulation 
— গম উইজার্ড
সূত্র
সমাধানগুলি কি অনন্য হওয়ার গ্যারান্টিযুক্ত?
— এইচ.পি.উইজ
@ এইচপিউইজ হ্যাঁ তারা।
— গম উইজার্ড
— সম্পূর্ণমানবিক
1
@ এইচ.পি.উইজ কুইক প্রুফ: প্রথম তালিকার মানের সাথে মিলিত একটি পার্থক্য তালিকা (ডিএল) থেকে একটি তালিকা পুরোপুরি পুনর্গঠনযোগ্য, সুতরাং এল থেকে (এফভি, ডিএল) এক-এক-এক রূপান্তর আছে। যে কোনও পরিমাণ দ্বারা এফভি বৃদ্ধি করা সমান যা এল এর প্রতিটি উপাদানগুলিতে সেই পরিমাণ যুক্ত করে এবং তাই যদি তুলনাটি যথাযথ একঘেয়ে হয় তবে এটি এল এর বাছাই পরিবর্তন করতে পারে না। (অন্য কথায়, আপনি যে সংখ্যাটি যোগ করছেন তাতে পূর্ণসংখ্যার ওভারফ্লো হওয়ার কারণটি বাছাইয়ের ক্ষেত্রে এটি প্রভাবিত করে না)।
— সিআর ড্রস্ট
1
আপনি আরও কয়েকটি পরীক্ষার মামলা যুক্ত করতে পারেন? আমি [-2, 100, -2, -1]উদাহরণস্বরূপ পৃথক আউটপুট দেওয়ার কিছু সমাধান লক্ষ্য করি notice
— শেগি

উত্তর:

16

05 এ বি 1 ই , 4 বাইট

.¥{¥

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

.¥{¥
.¥   # Undelta the input list
  {  # Sort it
   ¥ # And get the deltas
— Datboi
সূত্র
Undelta05AB1E এর সর্বাধিক কুলুঙ্গি অন্তর্নির্মিত রয়েছে। o0
— সম্পূর্ণমানবিক
2
আহ আহস, আমাকে মারতে। আমি সবসময় আন্ডেলটা ব্যবহার করতে চাইতাম।
— ম্যাজিক অক্টোপাস উরন
16
Undeltaಠ ___ ಠ
— ব্যবসায় ক্যাট
1
"আনডেল্টা" কি কেবল যোগফলের যোগফল, তাই না?
— জাগারব
2
@ জাগারব আনডেলটা তালিকার প্রথম উপাদান হিসাবে 0 যুক্ত করছে, তারপরে যেমনটি আপনি বলেছেন ঠিক তত পরিমাণে বা বিপরীত ডেল্টা।
— ম্যাজিক অক্টোপাস আরন
9

নম্পির সাথে পাইথন 3 , 56 54 53 বাইট

@ আর্টিয়ারকে ( sortস্ট্যান্ডার্ডের পরিবর্তে নম্পি sorted) ধন্যবাদ জানাতে 2 বাইট বন্ধ রয়েছে । ধন্যবাদ বন্ধ 1 বাইট থেকে @notjagan (চলন্ত 0মধ্যে cumsum)

lambda x:diff(sort(cumsum([0]+x)))
from numpy import*

কোডটি একটি বেনামি ফাংশন সংজ্ঞায়িত করে যা একটি তালিকা বা নম্পি অ্যারে এবং একটি নম্পি অ্যারের আউটপুট দেয়।

এটি অনলাইন চেষ্টা করুন!

— লুইস মেন্ডো
সূত্র
1
ওহ, আপনি আমাকে আজ নতুন কিছু শিখিয়েছেন। আমার সাথে যোগাযোগ numpyঅনেক দীর্ঘ ছিল। আমি আগামীকাল ফিরে আসব এটি উজাড় করার জন্য, কারণ আমি আপনাকে ইতিমধ্যে আবদ্ধ দেখছি। খুব সুন্দর!
— মিঃ এক্সকডার
@ মিঃ এক্সকোডার ধন্যবাদ! আমি নম্পির কোনও বিশেষজ্ঞ নই, মতলব-এ আমি যা করেছি তা আমি কেবল অনুসরণ করেছি: diff(sort([0 cumsum(x)]))( মতলব ভাষায়, সমালোচনা করা [ ]হচ্ছে)
— লুইস মেন্ডো
দায়িত্ব পালন!
— মিঃ এক্সকোডার
-1 বাইটটি সরিয়ে নিয়ে 0যান cumsum।
— notjagan
4

কাস্তে , 4 বাইট

Ẋ-O∫

এটি অনলাইন চেষ্টা করুন!

Explaination

      -- implicit input, e.g                               [2,1,-2,-1]
   ∫  -- cumulative sum                                    [0,2,3,1,0]
  O   -- sort                                              [0,0,1,2,3]
Ẋ     -- apply function to all adjacent pairs in the list  [(0,0),(0,1),(1,2),(2,3)]
 -    --   subtract                                        [0,1,1,1]
— H.PWiz
সূত্র
আরেকটি ভাষা যে ওনডেল্টা আছে? নাকি কিছু ফ্যানসিয়ার অন্তর্নির্মিত?
— মিঃ এক্সকডার
@জনাব. এক্সকোডার এটি ঘটে যে চামসামটি আন্ডেলটার মতোই
— H.PWiz
@ এইচ.পিউইজ আসলে আমরা এটাকেই চামসাম বলি না ... যদি না আপনি খালি উপসর্গটিকে অ্যাকাউন্টে নেন।
— এরিক আউটগল্ফার
@ এরিকথ আউটগল্ফার হ্যাঁ, কুঁড়ি এটিই করেন, যেমনটি scanl(+)0হাস্কেলের মতো।
— এইচ.পি.উইজ
4

পাইথ , 9 বাইট

-1 বাইট @ ইরিকথ আউটগল্ফারকে ধন্যবাদ ।

.+S+0sM._

পরীক্ষা স্যুট.

পাইথ , 10 বাইট

.+S.u+YNQ0

এটি অনলাইন চেষ্টা করুন! বা আরও পরীক্ষার কেস চেষ্টা করুন ।

— মিঃ এক্সকোডার
সূত্র
আমার (মুছে ফেলা) উত্তর হিসাবে, আপনি -1 এর +0sM._পরিবর্তে ব্যবহার করতে পারেন .u+YNQ0।
— এরিক দ্য আউটগল্ফার
আপনি এটি কেন মুছলেন?
— মিঃ এক্সকোডার
ভেবেছিলেন মূল ধারণাটিও আপনার মতো।
— এরিক দ্য আউটগল্ফার
@ এরিকথ আউটগল্ফার ঠিক আছে, ধন্যবাদ
— জনাব এক্সকডার
m=+ZsM._এটির জন্য একই দৈর্ঘ্যের বৈকল্পিক , তবে দুঃখজনকভাবে এটি কোনও ছোট হতে পারে বলে মনে হয় না।
— FryAmTheEggman
4

জাভাস্ক্রিপ্ট (ES6), 57 56 বাইট

@ বুদ্ধিমানের জন্য 1 টি বাইট সংরক্ষণ করা হয়েছে

a=>a.map(n=>t-=n,p=t=0).sort((a,b)=>b-a).map(n=>p-(p=n))

ডেমো

কোড স্নিপেট দেখান

— Arnauld
সূত্র
.sort((a,b)=>a-b)ডেল্টাস পাওয়ার উপায় কি? বিয়োগের সাথে বাছাই করে? : পি
— সম্পূর্ণরূপে
@ টোটালিহুমান প্রথমটি ডেল্টাস map()দেয়। এই কোড তাদের বাছাই। ২ য় মানচিত্র নতুন ডেল্টাস পুনর্নির্মাণ করে। জেএস sort()পদ্ধতিটি ডিফল্টরূপে ডিক্সিকোগ্রাফিক অর্ডার ব্যবহার করে। সুতরাং,> 9 নম্বরের জন্য আমাদের এই বিশেষায়িত কলব্যাকের প্রয়োজন (দুঃখের সাথে)।
— আর্নল্ড
যে -p+(p=n)আমার গিয়ারের grinds কিন্তু দুঃখিতভাবে কোন ভাল উপায় আছে ... যদি না ...
— ETHproductions
কি হেক, আমি সাবমিট বাটন
— টিপলাম
@ETHproductions ধন্যবাদ :-)
— Arnauld
3

জাভা 8, 123 বাইট

স্ট্যান্ডার্ড সমাধান: ক্রমসংখ্যা যোগ ইনপুট, সাজান, তারপরে পৃথক। কোনও কার্যকর বাস্তবায়ন কৌশল।

l->{int s=l.length,d[]=new int[s+1],i=0;while(i<s)d[i+1]=d[i]+l[i++];for(java.util.Arrays.sort(d);i-->0;)l[i]=d[i+1]-d[i];}

কাস্ট Consumer<int[]>। আউটপুটটি রূপান্তরিত ইনপুট।

এটি অনলাইন চেষ্টা করুন

অবহেলিত ল্যাম্বদা

l -> {
    int
        s = l.length,
        d[] = new int[s + 1],
        i = 0
    ;
    while (i < s)
        d[i + 1] = d[i] + l[i++];
    for (java.util.Arrays.sort(d); i-- > 0; )
        l[i] = d[i + 1] - d[i];
}

প্রাপ্তি স্বীকার

  • -3 বাইট ধন্যবাদ অলিভার গ্রাগোয়ারকে ধন্যবাদ, master of unholy autoincrementation
  • -1 বাইট নেভাকে ধন্যবাদ
— জ্যাকব
সূত্র
1
আপনি গলফ অবস্থানের যেখানে আপনি আপনার বাড়তি এবং আপনার সামগ্রিক কম্পিউটেশন না সাজানোর দ্বারা 3 বাইট: l->{int s=l.length,d[]=new int[s+1],i=0;for(;i<s;)d[i+1]=d[i]+l[i++];java.util.Arrays.sort(d);for(i=0;i<s;)l[i]=-d[i]+d[++i];}(দঃপূঃ অদৃশ্য অক্ষর হুঁশিয়ার যখন কপি / পেস্ট)
— অলিভিয়ের Gregoire
1
আমার নতুন শিরোনামের জন্য ধন্যবাদ;) উদযাপনের জন্য আরও হ্রাসের অশুচিতা for(;i>0;)l[i-1]=d[i]-d[--i];(শেষ লুপ)
— অলিভিয়ের গ্রাগোয়ার
আমি নিজেই সেই লুপটি পুনরায় তৈরি করেছি, for(;i-->0;)l[i]=d[i+1]-d[i];একই দৈর্ঘ্যে পৌঁছেছি। আপডেট আসতে হবে।
— জ্যাকব
2
আপনি ব্যবহার করে 1 বাইট সংরক্ষণ করতে পারেন l->{int s=l.length,d[]=new int[s+1],i=0;while(i<s)d[i+1]=d[i]+l[i++];for(java.util.Arrays.sort(d);i-->0;l[i]=d[i+1]-d[i]);}।
— নেভায়ে
Ah yes, of course. Thanks!
— Jakob
2

R, 31 32 bytes

-4 bytes thanks to @user2390246 for diffinv

+5 bytes from Jarko for cat

cat(diff(sort(diffinv(scan()))))

Reads from stdin, writes to stdout. diffinv is an inverse of diff for a given starting value (0 by default). Since it's diffed again, it doesn't matter what that value is.

As pointed out by Jarko Dubbeldam, I needed to properly output the result, at the cost of five bytes. Alas.

Try it online!

— Giuseppe
সূত্র
That's what I had in mind as well. Does need to handle printing though, as running this as a full program (through source) this doesn't output anything.
— JAD
1
If you use diffinv rather than cumsum you don't need to prepend zero.
— user2390246
@user2390246 wow, very nice! TIL about diffinv.
— Giuseppe
Me too! I was just having a quick search to see if there were any previous answers I could have applied it to.
— user2390246
1

Perl 6, 46 bytes

{[\+](0,|@_).sort.rotor(2=>-1).flat.map(*R-*)}

Try it

Expanded:

{  # bare block lambda with implicit signature :(*@_)

  [\+](         # triangle reduce using &infix:«+»
    0,          # start with 0
    |@_         # Slip in the arguments from the outer block
  )             #                  (0, 2, 3, 1, 0)

  .sort         # sort the results (0,0,1,2,3)
  .rotor(2=>-1) # group in twos    ((0,0),(0,1),(1,2),(2,3))
  .flat         # flatten          (0,0,0,1,1,2,2,3)
  .map(*R-*)    # grab 2 values at a time, and subtract first from second
                # (0, 1, 1, 1)
}
— Brad Gilbert b2gills
সূত্র
1

Haskell, 74 bytes

import Data.List
g=sort.scanl(+)0
h l|k<-g l=map(\(x,y)->x-y)$zip(tail$k)k

Try it online!

Straightforward.

— jferard
সূত্র
3
=<<ফাংশন থেকে মোনাড কাজে আসে: (zipWith(-)=<<tail).sort.scanl(+)0
— নিমি
@ নিমিমি খুব সুন্দর আমি মনদেদের বিশেষজ্ঞ নই, তবে আমার ভেবে দেখা উচিত ছিল zipWith।
— jferard
1

টিআই-বেসিক (টিআই -৪৮ প্লাস সিই), 23 বাইট

Prompt X
augment({0},cumSum(LX→X
SortA(LX
ΔList(LX

ব্যবহারকারী ইনপুট জন্য অনুরোধ। তালিকাটি অবশ্যই একটি নেতৃত্বের সাথে ইনপুট থাকতে হবে {, পৃথক সংখ্যার ,সাথে এবং একটি alচ্ছিক ট্রেলিং সহ }।

টিআই-বেসিক একটি টোকেনাইজড ভাষা ; ΔList(এবং cumSum(দ্বি-বাইট টোকেন, ব্যবহৃত অন্যান্য সমস্ত টোকেনগুলি প্রতিটি বাইট।

উদাহরণ রান ( NAMEপ্রোগ্রামের নাম এবং {4,-2,7,-4,0}ইনপুট হিসাবে):

prgmNAME
X=?{4,-2,7,-4,0}
               {2 2 1 0 4}

ব্যাখ্যা:

Prompt X                  # 3 bytes, get list input, store in LX
augment({0},cumSum(LX→X   # 12 bytes, 
          # store the list ({0} prepended to the cumulative sum of LX) to LX
SortA(LX                  # 4 bytes, sort LX ascending
ΔList(LX                  # 4 bytes, implicitly print the difference list of LX
— pizzapants184
সূত্র
আপনার কি দরকার L?
— জাকারি
@ জ্যাচারý আপনি কোনও তালিকা সংরক্ষণের সময় এগুলি বাদ দিতে পারেন, তবে রেফারেন্সিংয়ের সময় বাদ দেওয়ার পরে তালিকার পরিবর্তে সংখ্যাসূচক ভেরিয়েবল এক্সের উল্লেখ করা যেতে পারে
— pizzapants 184
1

সি ++ (জিসিসি) , 136 বাইট

নামবিহীন জেনেরিক ল্যাম্বদা হিসাবে, ইনপুটটিকে এমন মনে করা std::listএবং রেফারেন্স প্যারামিটারের মাধ্যমে ফিরে আসা।

[](auto&L){auto r=L.begin(),l=L.insert(r,0);while(r!=L.end())*r+++=*l++;for(L.sort(),l=r=--L.end();--l!=L.begin();*r---=*l);L.erase(l);}

এটি অনলাইন চেষ্টা করুন!

Ungolfed:

[](auto&L){
 auto r=L.begin(),
      l=L.insert(r,0); //adds a zero right in front
 while(r!=L.end())
   *r++ += *l++;       //sum left to right
 for(
  L.sort(),            //sorting invalidates the iterators
  l=r=--L.end();       //so, reinit
  --l!=L.begin();      //decrement l beforehand 
  *r-- -= *l           //diff right to left
 );
 L.erase(l);           //l==L.begin(), so this removes the temporary 0
}
— কার্ল ন্যাপ
সূত্র
1

পাইথ, 8 বাইট

.+S+M.uP

প্রদর্শন

.+S+M.uP
.+S+M.uPNQ    Implicit variables
     .u  Q    Apply the following function to the input repeatedly until it
              stops changing, then output the list of values, including the
              starting value.
       PN     Remove the last element. No-op if the list is empty.
   +M         Sum each list. This gives the cumulative sums in reverse order,
              including a 0 at the end for the empty list.
  S           Sort
.+            Deltas
— isaacg
সূত্র
+1 এটি মোটামুটি স্থির পয়েন্ট সহ একটি ঝরঝরে কাজ। আমি ব্যক্তিগতভাবে এ সম্পর্কে ভাবিনি।
— মিঃ এক্সকোডার
1

টিআই-বেসিক, 20 বাইট

cumSum(augment({0},Ans->L1
SortA(L1
ΔList(L1
— Timtech
সূত্র
1

VB.NET (.NET 4.5), 109 বাইট

Sub A(n)
Dim c=n.count-1
For i=1To c
n(i)+=n(i-1)
Next
n.Sort()
For i=c To 1 Step-1
n(i)-=n(i-1)
Next
End Sub

একটি ফাংশন যা ইনপুট হিসাবে কোনও তালিকা প্রত্যাশা করে এবং সরাসরি এটি সংশোধন করে। আসল পরামিতি তারপরে আউটপুট ব্যবহার করা যেতে পারে

  1. তালিকার মাধ্যমে ফরওয়ার্ড যুক্ত করে একটি আসল তালিকা পুনরুদ্ধার করে (প্রথম উপাদান হিসাবে একটি অন্তর্ভুক্ত 0 ধরে)
  2. মূল তালিকাটি বাছাই করে
  3. পিছনে গিয়ে পার্থক্যগুলি পেয়ে যায় (সুতরাং আমার আলাদা তালিকার ট্র্যাক রাখার দরকার নেই) (0 এর অন্তর্নিহিত প্রথম উপাদানটির অর্থ প্রথম পার্থক্যটি ক্ষুদ্রতম উপাদানের মতোই)

এটি অনলাইন চেষ্টা করুন!

— ব্রায়ান জে
সূত্র
টিআইও লিঙ্কটি আপডেট করার বিষয়ে আপনি কি আপত্তি জানবেন?
— টেলর স্কট
@ টেলরস্কট কীভাবে আপডেট করবেন?
— ব্রায়ান জে
আপনার টিআইও লিঙ্কটি আপনার উত্তরের চেয়ে সম্পূর্ণ আলাদা কোড দেখায়
— টেলর স্কট
1
@ টেলরস্কট আহ্ .... আমি দেখছি। আমাকে কিছু সামঞ্জস্য করতে হয়েছিল কারণ টিআইও মনো ব্যবহার করে তবে আমি নেট নেট 4.5 সংকলকটি ব্যবহার করছিলাম
— ব্রায়ান জে
1

এপিএল (ডায়ালগ) , 15 14 বাইট

-1 বাইট এনএনজি ধন্যবাদ ।

(¯2-/⍋⊃¨⊂)0,+\

+\ সমষ্টিগত যোগফল

0, একটি শূন্য preend

(… ) এটিতে নিম্নলিখিত সূক্ষ্ম ফাংশন প্রয়োগ করুন:

 ⊂ ঘেরযুক্ত (যাতে আমরা একাধিক আইটেম বাছাই করতে পারি)

 ⍋⊃¨ যে সূচকগুলি আর্গুমেন্টটিকে বাছাই করে তার প্রত্যেকটি সেই থেকে বেছে নিন

 ¯2-/ বিপরীত যুগল পার্থক্য

এটি অনলাইন চেষ্টা করুন!

ডায়ালগ '17 ব্যবহারকারী সভায় কোড গল্ফ হ্যাকাথনের অংশগ্রহণকারীদের দ্বারা মূল সমাধানটি পাওয়া গেছে :

¯2-/l[⍋l←+\0,⎕]

এটি অনলাইন চেষ্টা করুন!

⎕ ইনপুট জন্য প্রম্পট

0, একটি শূন্য preend

+\ সমষ্টিগত যোগফল

l← হিসাবে সঞ্চয় l

⍋ অনুসারে বাছাই করা সূচকগুলি সন্ধান করুন l

l[… ] এটিকে সূচীতে ব্যবহার করুনl

¯2-/ বিপরীত যুগল পার্থক্য

— Adám
সূত্র
1
হ্যাকাথনে এটি অনুমোদিত হয়েছিল কিনা তা আমি জানি না তবে আপনি এটি বিন্দু মুক্ত স্টাইলে পুনরায় লিখলে আপনি একটি চর সংরক্ষণ করতে পারেন: (¯2- / ⍋⊃¨⊂) 0, + \
— ngn
@ngn কর্মশালার এই অংশটি অংশগ্রহণকারীদের পিপিসিজি দিয়ে শুরু করার চেষ্টা করছিল, তাই এখানে বিধিগুলি পিপিসিজির ছিল। ধন্যবাদ।
— অ্যাডম
0

রাদা , 42 বাইট

{i=0{[0];[i]if i+=_}|sort|slide 2|[_2-_1]}

এটি অনলাইন চেষ্টা করুন!

এটি পার্ল 6 উত্তরের অনুরূপ । .sortহয় |sort, .rotor(2=>-1).flatহয় |slide 2 এবং .map(*R-*)হয়|[_2-_1] ।

ব্যাখ্যা:

{
  i=0 /* initialize variable i */
  /* the following block recreates the original list from differences: */
  {
    [0];       /* push 0 to the stream */
    [i]if i+=_ /* add every number in the stream to i and push i back */
  }|
  sort|    /* sort the numbers */
  slide 2| /* for values i1, i2, i3, ... in the stream
              push pairs i1, i2, i2, i3, ... */
  [_2-_1]  /* calculate difference of numbers in each pair in the stream */
}

বিবৃতি [i]if i+=_সমান

for sfv do
  if i += sfv do
    push(i)
  done
done

+=অপারেটর প্রবাহে মান ঠেলে দেন না, তাই এটি truthy হয়। {|j|i+=j;[i]}_সংযোজনটি বাঁধার জন্য এবং ধাক্কা দিয়ে বক্তব্যগুলি একসাথে রাখার জন্য আমি কিছু ধরণের ব্লক (উদাহরণস্বরূপ ) ব্যবহার করতে পারতাম , তবে ifসংক্ষিপ্ত।

— fergusq
সূত্র
0

জুলিয়া 0.6.0 (34 বাইট)

খুব সুন্দর আর এবং পাইথন 3 এ যা করা হয়েছে তার একটি অনুলিপি

x->diff(sort(cumsum(vcat([0],x))))

— Goysa
সূত্র
0

জে, 10 বাইট

/:~&.(+/\)

ব্যাখ্যা

"স্ক্যানের যোগফল অনুসারে বাছাই করুন": জে, আন্ডার সংযোগটি &.ইনপুটটিতে তার ডানদিকে রূপান্তরটি প্রয়োগ করে, তারপরে বামে ক্রিয়াটি প্রয়োগ করে (এই ক্ষেত্রে সাজানোর ক্ষেত্রে /:~) এবং তারপরে বিপরীত রূপান্তর ঘটে। এটি হ'ল জে বুঝতে পারে যে স্ক্যানের যোগফলকে কীভাবে রূপান্তর করা যায়, যা এখানে ঠিক প্রয়োজন তা: পরের পার্থক্যগুলি হ'ল ইনপুট যা স্ক্যান-সমষ্টি করা হলে সেই স্ক্যান-যোগফল তৈরি করে।

এটি অনলাইন চেষ্টা করুন!

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