मेरी पर्वत श्रृंखला में कितनी चोटियाँ हैं?

27

सकारात्मक पूर्णांक की एक सूची को एक परिमाणित पर्वत श्रृंखला के रूप में देखा जा सकता है जहां प्रत्येक सूची प्रविष्टि पहाड़ों के एक ऊर्ध्वाधर खंड की ऊंचाई का प्रतिनिधित्व करती है।

उदाहरण के लिए, सूची

1, 2, 2, 3, 4, 3, 5, 3, 2, 1, 2, 3, 3, 3, 2, 2, 1, 3

सीमा बन सकती है

      x
    x x      
   xxxxx   xxx   x
 xxxxxxxx xxxxxx x
xxxxxxxxxxxxxxxxxx

(कम काव्यात्मक लोग इसे बार चार्ट कह सकते हैं, लेकिन मैं पछताता हूं।)

इस चुनौती में सवाल यह है: कुछ मनमानी सूची की पर्वत श्रृंखला में कितने शिखर हैं? अनिवार्य रूप से, सूची में कितने स्थानीय मैक्सिमा हैं?

एक चोटी को पर्वत श्रृंखला के एक या अधिक स्तंभों के एक सन्निहित खंड के रूप में परिभाषित किया गया है जो ऊंचाई में सभी समान हैं, जहां स्तंभ तुरंत बाईं और दाईं ओर ऊंचाई में कम हैं।

नेत्रहीन को यह बताना आसान है कि उदाहरण में इन छोटे स्थानों पर चार चोटियाँ हैं:

1, 2, 2, 3, (4), 3, (5), 3, 2, 1, 2, (3, 3, 3), 2, 2, 1, (3)

ध्यान दें कि (3, 3, 3)पठार खंड एक चोटी के रूप में कैसे गिना जाता है क्योंकि यह ऊंचाई में बराबर स्तंभों का एक सेट है, जो अपने पड़ोसी स्तंभों की तुलना में अधिक है।

आखिरी (3)चोटी के रूप में अच्छी तरह से गिना जाता है, क्योंकि इस चुनौती के प्रयोजनों के लिए, हम बाएं स्तंभ के बाएं पड़ोसी को परिभाषित करेंगे और सबसे दाहिने स्तंभ के दाएं पड़ोसी को ऊंचाई शून्य होगा।

इसका मतलब है कि उदाहरण के लिए केवल एक मान के साथ एक सूची, के 1, 1, 1रूप में व्याख्या की जा सकती है 0, 1, 1, 1, 0, और इस प्रकार एक चोटी है, कोई नहीं 0, (1, 1, 1), 0:।

शून्य चोटियों वाली एकमात्र सूची खाली सूची है।

चुनौती

एक फ़ंक्शन या प्रोग्राम लिखें, जो सकारात्मक पूर्णांक और प्रिंट की एक मनमानी सूची में लेता है या संबंधित पर्वत श्रृंखला में चोटियों की संख्या लौटाता है।

बाइट्स में सबसे छोटा कोड जीतता है। टाईब्रेकर पहले की पोस्ट है।

परीक्षण के मामलों

Input List -> Output Peak Count

[empty list] -> 0
1, 1, 1 -> 1
1, 2, 2, 3, 4, 3, 5, 3, 2, 1, 2, 3, 3, 3, 2, 2, 1, 3 -> 4
1 -> 1
1, 1 -> 1
2, 2, 2, 2, 2 -> 1
90 -> 1
2, 1, 2 -> 2
5, 2, 5, 2, 5 -> 3
2, 5, 2, 5, 2, 5, 2 -> 3
1, 2, 3, 4 -> 1
1, 2, 3, 4, 1, 2 -> 2
1, 3, 5, 3, 1 -> 1
7, 4, 2, 1, 2, 3, 7 -> 2
7, 4, 2, 1, 2, 1, 2, 3, 7 -> 3
1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2 -> 10
1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1 -> 10
2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2 -> 10
1, 3, 3, 3, 1, 3, 3, 1, 3, 1, 3, 3, 3, 3, 1 -> 4
12, 1, 2, 1, 2, 3, 3, 3, 2, 4, 4, 4, 1, 5, 5, 4, 7, 9 -> 6
87, 356, 37673, 3676, 386, 909, 909, 909, 909, 454, 909, 909 -> 3
87, 356, 37673, 3676, 386, 909, 909, 909, 909, 454, 909, 908, 909 -> 4
code-golf  number  arithmetic 
— केल्विन के शौक
स्रोत
तो, पठार लंबे समय तक मनमाना हो सकता है?
— निकेल
@nicael हाँ, यह हो सकता है
— केल्विन के शौक
क्या हम एक सरणी के रूप में इनपुट ले सकते हैं, स्ट्रिंग के रूप में नहीं?
— निकेल
@nicael हां, कुछ भी उचित है
— केल्विन के शौक

जवाबों:

2

पायथ, 18 बाइट्स

su_>VGtG2eMr++ZQZ8

पीटरटायलर के समाधान से अधिक बार दोहराया गया, लेकिन एक मोड़ के साथ।

++ZQZ: दोनों तरफ शून्य जोड़ें।

eMr ... 8: दोहराएं हटाएं।

u ... 2 ...: निम्नलिखित दो बार लागू करें:

>VGTG: संख्या के प्रत्येक जोड़े को मैप करें कि क्या वे घटते क्रम में हैं।

_: और रिवर्स।

आउटपुट में ए 1 1, 0पूर्व चरण में मेल खाती है, जो a < b > cउलटफेर के कारण इनपुट में मेल खाती है ।

s: सम (और प्रिंट)

— isaacg
स्रोत
10

CJam ( 32 26 24 21 बाइट्स)

0q~0]e`1f=2ew::>2,/,(

अपेक्षित इनपुट अंतरिक्ष-पृथक संख्याएं हैं।

ऑनलाइन डेमो ; पूर्ण परीक्षण सूट (अपेक्षित उत्पादन 1प्रति परीक्षण मामला है)।

मार्टिन को धन्यवाद कि मुझे सूचित करने के लिए कि सीजेएम के वर्तमान संस्करण में इस्तेमाल किए गए ऑपरेटरों में से एक में सुधार होता है, जिससे 2 चार्ट बचते हैं; और एक और 3-चार बचत के लिए।

विच्छेदन

दो चरण: डुप्लिकेट, फिर तीन के प्रत्येक सेट में स्थानीय मैक्सिमा की पहचान करें।

0q~0]      e# Put the input in an array wrapped in [0 ... 0]
e`1f=      e# Use run-length encoding to deduplicate
2ew::>     e# Map [a b c ...] to [(a>b) (b>c) ...]
2,/        e# Split on [0 1], which since we've deduplicated occurs when (a<b) (b>c)
,(         e# Count the parts and decrement to give the number of [0 1]s
— पीटर टेलर
स्रोत
7

जावास्क्रिप्ट (ईएस 6), 54 51 बाइट्स

m=>m.map(n=>{h=n<p?h&&!++r:n>p||h;p=n},r=h=p=0)|r+h

व्याख्या

संख्याओं की एक सरणी लेता है

m=>
  m.map(n=>{       // for each number n in the mountain range
      h=
        n<p?       // if the number is less than the previous number:
          h&&      // if the previous number was greater than the number before it
          !++r     // increment the number of peaks and set h to 0
        :n>p||h;   // if the number is greater than the previous number, set h to 1
      p=n          // set p to the current number
    },
    r=             // r = number of peaks
    h=             // h = 1 if the previous number was higher than the one before it
    p=0            // p = previous number
  )|r+h            // return the output (+ 1 if the last number was higher)

परीक्षा

कोड स्निपेट दिखाएं

— user81655
स्रोत
5

पायथ, 25 23 बाइट्स

L._M-M.:b2s<R0y-y+Z+QZZ

स्पष्टीकरण:

L              y = lambda b:
  ._M -M .:          signs of subsets
           b          of b
           2          of length 2. That is, signs of differences.

s <R              number of elements less than
     0              0 in
     y -            y of ... with zeroes removed
         y +          y of
             Z        the input with zeroes tacked on both sides
             + Q Z
       Z
— lirtosiast
स्रोत
अच्छा लगा। असामान्य रूप से, CJam के लिए एक बंदरगाह छोटा है: 0q~0]{2ew::-:g0-}2*1-,22 के लिए।
— पीटर टेलर
4

जूलिया, 66

x->(y=diff([0;x;0]);y=y[y.!=0];sum((y[1:end-1].>0)&(y[2:end].<0)))

पैड, अंतर y=diff([0;x;0]):।
पठारों पर ध्यान न दें y=y[y.!=0]:। शून्य क्रॉसिंग की
गणना +करें :।-sum((y[1:end-1].>0)&(y[2:end].<0))

— रेनर पी।
स्रोत
3

MATLAB, 29 27 बाइट्स

@(a)nnz(findpeaks([0 a 0]))

बेनामी फ़ंक्शन जो डेटा में चोटियों को ढूंढता है और गिनता है कि कितने हैं। प्रश्न के अनुसार चोटियों का पता लगाने के लिए 0 को पूर्व निर्धारित और संलग्न किया गया है ताकि चोटियों का पता लगाया जा सके।

यह ऑक्टेव के साथ भी काम करेगा । आप यहाँ ऑनलाइन कोशिश कर सकते हैं । बस उपरोक्त कोड को कमांड लाइन में पेस्ट करें, और फिर इसे ans([1,2,1,3,4,5,6,1])(या जो भी अन्य इनपुट) के साथ चलाएं ।

जैसा कि संख्याएं हमेशा + ve होती हैं, हम मान सकते हैं कि वे शून्य से अधिक हैं, इसलिए nnzइसके बजाय का उपयोग करके 2 बाइट्स बचा सकते हैं numel।

— टॉम बढ़ई
स्रोत
3

पायथन 3, 75 बाइट्स

def m(t):
 a=p=d=0
 for n in t+[0]:a+=(n<p)&d;d=((n==p)&d)+(n>p);p=n
 return a

यह मेरा पहला कोडगोल्फ है, इसलिए इसमें कुछ हिस्सों को काटने की जगह हो सकती है, विशेष रूप से d=((n==p)&d)+(n>p)भाग। हालाँकि यह सभी परीक्षण मामलों पर काम करता है

— कैमरन अविक
स्रोत
क्या वे 78 बाइट्स नहीं हैं ?
— जोनाथन फ्रेच
3

गणितज्ञ, 42 36 33 32 बाइट्स

1 बाइट बचाने के लिए मार्टिन ब्यूटनर को धन्यवाद।

Tr@PeakDetect[#&@@@Split@#,0,0]&

PeakDetect बस लगभग सब कुछ करता है!

परीक्षण के मामलों:

Total@PeakDetect[#&@@@Split@#,0,0]&@{12,1,2,1,2,3,3,3,2,4,4,4,1,5,5,4,7,9}
(* 6 *)
Total@PeakDetect[#&@@@Split@#,0,0]&@{87,356,37673,3676,386,909,909,909,909,454,909,908,909}
(* 4 *)
— njpipeorgan
स्रोत
मुझे लगता है कि मेरा जवाब आपके लिए एक दूसरे को पोस्ट करने के लिए पर्याप्त रूप से अलग है।
— लेजिओनमल 978
@ LegionMammal978 इनपुट का परिणाम {1} 1 है, जैसा कि अपेक्षित है।
— njpipeorgan
मेरा मतलब है {1, 2, 2, 3, 4, 3, 5, 3, 2, 1, 2, 3, 3, 3, 2, 2, 1, 3}
— LegionMammal978
@ LegionMammal978 यह मुश्किल है। मुझे कोई हल नहीं मिला है।
— njpipeorgan
मेरा अद्यतन समाधान सिर्फ "पठारों" को समतल करता है।
— लेजिओनम्मल 978
2

सीजेएम, 27 26 बाइट्स

A0q~0A]e`1f=3ew{~@e>>}%1e=

डुप्लिकेट को निकालने के लिए रन लंबाई कोडिंग का उपयोग करता है। उसके बाद हम हर ट्रिपल के लिए जाँच करते हैं यदि मध्य सबसे बड़ी संख्या है।

यहाँ कोशिश करो! पासेस पीटर टेलर का टेस्ट स्वीट ।

— randomra
स्रोत
2

MATL , 22 बाइट्स

0ih0hdZS49+c'21*?0'XXn

भाषा / संकलक के वर्तमान संस्करण का उपयोग करता है ।

उदाहरण

>> matl
 > 0ih0hdZS49+c'21*?0'XXn
 >
> [1, 2, 2, 3, 4, 3, 5, 3, 2, 1, 2, 3, 3, 3, 2, 2, 1, 3]
4

व्याख्या

0ih0h           % input array. Append and prepend 0
dZS             % sign of difference between consecutive elements. Gives -1, 0, 1
49+c            % convert to a string of '0','1','2' 
'21*?0'XX       % use (lazy) regular expression to detect peaks: '20' or '210' or '2110'...
n               % number of matches. Implicity print
— लुइस मेंडो
स्रोत
2

गणितज्ञ, 55 39 36 35 बाइट्स

Length@FindPeaks[#&@@@Split@#,0,0]&

अब सभी परीक्षण मामलों पर काम करता है!

— LegionMammal978
स्रोत
ठंडा! लेकिन FindPeaks [#, 0,0, -P] की आवश्यकता है, अन्यथा यह अंतिम परीक्षण के मामले में विफल रहता है।
— njpipeorgan 12
अंतिम / @ एक बाइट बचाता है। और आखिरी ", 0" अनावश्यक हो सकता है?
— njpipeorgan
आपके लिए एक ही ट्रिक: Last/@->#&@@@
— मार्टिन एंडर
2

रेटिना , 33 31 बाइट्स

2 बाइट बचाने के लिए नील को धन्यवाद।

\b(1+)(?<!\1,\1)(,\1)*\b(?!,\1)

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

इनपुट को अल्पविराम-पृथक, अनारक्षित सूची के रूप में लेता है ।

— मार्टिन एंडर
स्रोत
\b(1+)(?<!\1 \1)( \1)*\b(?! \1)2 बाइट्स बचाने के लिए लगता है?
— नील
@ निश्चित रूप से, धन्यवाद! :)
— मार्टिन एंडर
1

जावास्क्रिप्ट ईएस 6 , 96 94 बाइट्स

t=>(a=t.filter((x,i)=>x!=t[i-1])).filter((x,i)=>(x>(b=a[i-1])||!b)&&(x>(c=a[i+1])||!c)).length

सिद्धांत: एकल चोटियों में पठारों को ढहते हुए, उन अचारों को खोजें, जिन्हें अगले और पिछले दोनों तत्वों की तुलना में अधिक ऊंचा माना जाता है।

एक सरणी के रूप में इनपुट लेता है।

डेमो:

f=t=>
(a=t.filter((x,i)=>x!=t[i-1]))    //collapse every plateau into the pick
    .filter((x,i)=>
       (x>(b=a[i-1])||!b)&&(x>(c=a[i+1])||!c)    //leave only those values which are greater than the succeeding and preceding ones
    ).length

document.write(
  f([])+"<br>"+
  f([1, 1, 1])+"<br>"+
  f([1, 2, 2, 3, 4, 3, 5, 3, 2, 1, 2, 3, 3, 3, 2, 2, 1, 3])+"<br>"+
  f([1])+"<br>"+
  f([1, 1])+"<br>"+
  f([2, 2, 2, 2, 2])+"<br>"+
  f([90])+"<br>"+
  f([2, 1, 2])+"<br>"+
  f([5, 2, 5, 2, 5])+"<br>"+
  f([2, 5, 2, 5, 2, 5, 2])+"<br>"+
  f([1, 2, 3, 4])+"<br>"+
  f([1, 2, 3, 4, 1, 2])+"<br>"+
  f([1, 3, 5, 3, 1])+"<br>"+
  f([7, 4, 2, 1, 2, 3, 7])+"<br>"+
  f([7, 4, 2, 1, 2, 1, 2, 3, 7])+"<br>"+
  f([1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2])+"<br>"+
  f([1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1])+"<br>"+
  f([2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2])+"<br>"+
  f([1, 3, 3, 3, 1, 3, 3, 1, 3, 1, 3, 3, 3, 3, 1])+"<br>"+
  f([12, 1, 2, 1, 2, 3, 3, 3, 2, 4, 4, 4, 1, 5, 5, 4, 7, 9])+"<br>"+
  f([87, 356, 37673, 3676, 386, 909, 909, 909, 909, 454, 909, 909])+"<br>"+
  f([87, 356, 37673, 3676, 386, 909, 909, 909, 909, 454, 909, 908, 909])
)
स्निपेट का विस्तार करें

— nicael
स्रोत
1

ईएस 6, 50 48 बाइट्स

m=>m.map(h=>{f=h>p?c+=!f:f&&h==p;p=h},p=c=f=0)|c

सहेजे गए 2 बाइट @ user81655 की बदौलत।

Ungolfed:

function peaks(mountains) {
    var previous = 0;
    var count = 0;
    var plateau = false;
    for (var height of mountains) {
        if (height > previous) {
            if (!plateau) count++;
            plateau = true;
        } else if (height != previous) {
            plateau = false;
        }
    }
    return count;
}
— नील
स्रोत
@ user81655 उस सूक्ष्मता पर मेरा ध्यान आकर्षित करने के लिए धन्यवाद। (मैंने पहले इस्तेमाल नहीं किया है .map()|।)
— नील
1

MATL, 23

चूंकि हमें प्रतिस्पर्धी होने के लिए स्टैक आधारित एसोलंग्स का उपयोग करने की आवश्यकता है, इसलिए मैंने MATL में अपने जूलिया समाधान को फिर से लागू किया।

0i0hhdtg)t5L)0>w6L)0<*s

पुश 0, इनपुट 0, कंसीनेट दो बार। 0i0hh=>x = [0, input(''), 0]

अंतर करें। d=>x = diff(x)

डुप्लिकेट करें t, एक को बूलियन में बदलें और दूसरे को अनुक्रमित करने के लिए इसका उपयोग करें। tg)=>x=x(x!=0)

फिर से नकल। t

पहला: [1,G])0>=>y1 = x(1:end-1)>0

अदला बदली। w

दूसरा: [2,0])0<=>y2 = x(2:end)<0

तर्क और, सच मानों की गिनती। *s=>sum(y1 & y2)

— रेनर पी।
स्रोत
या आप पाइथ कर सकते हैं, एक प्रक्रियात्मक / कार्यात्मक गोल्फ भाषा!
— इसहाक
ठीक है, MATL गोल्फिंग के लिए MATLAB है, लेकिन MATLAB MATL को हरा रहा है।
— जेनेरिक यूजर
बहुत अच्छा! कुछ सुझाव: [1,G]-> 5L3 बाइट्स बचाता है। [2,0]-> 6L3 बाइट्स बचाता है
— लुइस मेंडो
1
@GenericUser अब और नहीं है :-) codegolf.stackexchange.com/a/69050/36398
— लुइस
@ रेनर मैं MATL (और उसी के लिए ) से हटाने and( &) के बारे में सोच रहा हूं or। यह हमेशा इस मामले में के रूप में *o, और अक्सर द्वारा प्रतिस्थापित किया जा सकता है *। तुम क्या सोचते हो? इस तरह से पात्रों &और |भविष्य में अन्य कार्यों के लिए इस्तेमाल किया जा सकता है।
— लुइस मेंडो
1

जाप, 19 बाइट्स

जितना मैंने सोचा था, उससे ज्यादा आसान था, लेकिन शुरुआत बग के कारण थोड़ी बेकार है।

Uu0;Up0 ä< ä> f_} l

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

यह काम किस प्रकार करता है

Uu0;Up0 ä< ä> f_} l  // Implicit: U = input
Uu0;Up0              // Add 0 to the beginning and end of U. If this isn't done, the algorithm fails on peaks at the end.
        ä<           // Compare each pair of items, returning true if the first is less than the second, false otherwise.
                     // This leaves us with a list e.g. [true, false, false, true, false].
           ä>        // Repeat the above process, but with greater-than instead of less-than.
                     // JS compares true as greater than false, so this returns a list filled with false, with true wherever there is a peak.
              f_} l  // Filter out the falsy items and return the length.

गैर-प्रतिस्पर्धात्मक संस्करण, 15 बाइट्स

Uu0 p0 ä< ä> è_

इससे पहले आज, मैंने èफंक्शन जोड़ा , जो कि पसंद है fलेकिन मैचों की संख्या को खुद मैचों के बजाय लौटाता है। मैंने एक बग भी तय किया जहां Array.uसरणी के बजाय सरणी की लंबाई वापस आ जाएगी।

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

— ETHproductions
स्रोत
1

05AB1E , 9 बाइट्स

Ô0.ø¥0‹ÔO

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

स्पष्टीकरण:

Ô0.ø¥0‹ÔO      Full program
Ô              Uniquify (= remove plateaus)
 0.ø           Surround with zeros
    ¥          Push deltas
     0‹        Test each element if lower than 0
               --- we now have a list with 0's (= going uphill) and 
                   1's (going downhill). Since we removed plateaus, all
                   we have to do now is to count the number of ramps
                   going downhill
       Ô       Uniquify (reduce ramps to length 1)
        O      Total sum of the list
— scottinet
स्रोत
1

जेली , 27 बाइट्स

ṡ2EÐḟFs2ḣ€1S€ṡ3M€Fċ2
0;⁸;0Ç

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

— जाकारी
स्रोत
जेली बिना TIO ??? lol
— क्रिस्टोफर
यह एक लंबे समय पहले था, इससे पहले कि मैं जानता था कि टीआईओ से कैसे लिंक किया जाए। मैं इसे पोस्टीरिटी के लिए ऐसे ही छोड़ दूंगा।
— ज़ाचारि
स्क्रू डेट I फिक्स
— क्रिस्टोफर
> _ <_> _ <_> _ <_> _ <
— Zacharý
0

GolfScript, 35

~0+0\{.@=!},+:a,2-,{a\>3<.$2=?1=},,

ऑनलाइन टेस्ट करें

मूल रूप से डुप्लिकेट को हटाता है, दोनों छोरों पर एक 0 जोड़ता है, और जांचता है कि केंद्र में कितने त्रिभुज अधिकतम हैं।

— अस्थिरता
स्रोत
0

जावा 8, 141 बाइट्स

l->{int r=0,i=1,t;for(l.add(0,0),l.add(0);i<l.size()-1;r+=t>l.get(i-1)&t>l.get(++i)?1:0)for(;(t=l.get(i))==l.get(i+1);)l.remove(i);return r;}

शायद सूची के बजाय एक अलग दृष्टिकोण, या इनपुट के रूप में एक सरणी का उपयोग करके गोल्फ किया जा सकता है।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

l->{                     // Method with ArrayList<Integer> parameter and int return-type
  int r=0,               //  Result-integer
      i=1,               //  Index-integer
      t;                 //  Temp integer
  for(l.add(0,0),        //  Add a 0 at the start of the list
      l.add(0);          //  Add a 0 at the end of the list
      i<l.size()-1;      //  Loop (1) from index 1 through length-1 (0-indexed)
      r+=                //    After every iteration, raise the result-integer by:
         t>l.get(i-1)    //     If the current item is larger than the previous
         &t>l.get(++i)?  //     and larger than the next:
          1              //      Increase `r` by 1
         :               //     Else:
          0)             //      `r` remains the same
    for(;(t=l.get(i))==l.get(i+1);
                         //   Inner loop (2) as long as there are two adjacent equal items
      l.remove(i)        //    And remove one of those two equal integers
    );                   //   End of inner loop (2)
                         //  End of loop (1) (implicit / single-line body)
  return r;              //  Return the result-integer
}                        // End of method
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.