Afficher les nombres entiers dans un ordre négatif, augmenter le nombre entier maximal à chaque fois


44

Tâche principale

Votre tâche consiste à imprimer les nombres entiers par ordre décroissant, en partant de 1 et en augmentant au fur et à mesure que vous appuyez à nouveau sur 1, jusqu’à ce que l’entrée donnée soit atteinte, puis imprimez le reste jusqu’à ce que vous frappiez à nouveau 1. Exemple avec entrée 6:

1
21
321
4321
54321
654321
Without newlines (valid output):
121321432154321654321
Note latérale: il s’agit du numéro A004736 dans le système OEIS. En outre, le premier exemple (avec des nouvelles lignes) est une sortie non valide, comme spécifié dans les règles.

Contribution

Votre code peut prendre n'importe quel type d’entrée (graphique, STDIN) sous forme d’entier ou de nombre.

Sortie

Votre code doit sortir la séquence décrite ci-dessus, jusqu'à atteindre le nombre saisi, puis terminer la sortie jusqu'à ce qu'il atteigne à nouveau 1. La sortie peut être n'importe quoi, donc des nombres, des chaînes, des entiers ou une sortie graphique. Il est nécessaire d'imprimer un seul numéro (pas de saut de ligne s'il s'agit d'une chaîne). Votre sortie peut être insérée et créée avec autant de caractères que vous le souhaitez (par exemple []).

Comme il y a eu un malentendu, voici un modèle de regex sur lequel vous pouvez essayer vos sorties.

^(\D*(\d)+\D*)$

Règles

  • La sortie doit être un nombre entier, ne pas être divisé par quoi que ce soit, même pas de nouvelles lignes.
  • L'algorithme ne doit pas vérifier si la première instance de N apparaît de quelque manière que ce soit (par exemple, le 21in 121321), mais plutôt pour la première instance de N en tant que nombre réel.
  • Un seul retour à la ligne est autorisé.
  • Le traitement des entrées négatives est entièrement votre choix, les nombres négatifs ne sont pas des cas à tester.

Cas de test

Input: 6
Output: 121321432154321654321

Input: 1 Output: 1

Input: 26 Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321222120191817161514131211109876543212322212019181716151413121110987654321242322212019181716151413121110987654321252423222120191817161514131211109876543212625242322212019181716151413121110987654321

Input: 0 Output: 0, Empty, or Error

Input: 21 Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321

Merci @ Emigna, j'ai utilisé son algorithme pour calculer ces cas de test.

Gagnant

Le gagnant a été choisi! C'était la réponse d' ErikGolfer avec un impressionnant 5 octets! Toutes nos félicitations!


The output must be a full number ...Voulez-vous dire la séquence entière, ou seulement les différentes chaînes (1, 2-1, 3-1 ...)? Votre premier exemple ne semble pas correspondre à cette déclaration.
Steenbergh

1
Si la sortie doit être un nombre unique, comment peut-il s'agir de "tableaux"?
smls

Ce tableau serait-il acceptable en sortie? [1, 21, 321, 4321, 54321, 654321] Celui-ci, ça va? [1,2,1,3,2,1,4,3,2,1,5,4,3,2,1,6,5,4,3,2,1] Ou parlez-vous simplement de tableaux contenant un seul élément, comme [121321432154321654321]?
smls

1
Je suis confus sur le format de sortie. Pouvez-vous donner des exemples de ce qui est acceptable? Tableau de nombres? Chaîne avec des nombres séparés par des espaces?
Luis Mendo

1
Votre regex autorise la sortie de mickey321211mouse. Vraiment les \Dparties n'ont aucune raison d'être là
edc65

Réponses:



19

05AB1E , 6 octets

L€LíJJ

Essayez-le en ligne!

Explication

Exemple d'entrée 4

L       # range [1 ... input]
        # STACK: [1,2,3,4]
 €L     # map: range
        # STACK: [[1],[1,2],[1,2,3],[1,2,3,4]]
   í    # reverse each
        # STACK: [[1],[2,1],[3,2,1],[4,3,2,1]]
    J   # join inner lists
        # STACK: ['1','21','321','4321']
     J  # join list
        # OUTPUT: 1213214321

13

JavaScript (ES6), 37 octets

f=(n,k=1)=>k>n?n--?f(n):'':f(n,k+1)+k

Démo

Autre méthode pour n <10, 34 octets (non en concurrence)

f=(n,s='1')=>--n?s+f(n,++s[0]+s):s

En JavaScript, les chaînes sont immuables. Par conséquent, il est impossible de modifier le contenu du Nième caractère d'une chaîne sen affectant une nouvelle valeur à s[N].

Cependant, l'expression ++s[N]est valide et est évaluée comme prévu, même si la chaîne reste inchangée. Par exemple:

++"1"[0] // equals 2

Et par extension:

s = "21"
++s[0] + s // equals "321"

Ne semble pas fonctionner pour n> 9
edc65

@ edc65 Vous avez raison, bien sûr. Je ne sais pas pourquoi je pensais que je pouvais m'arrêter à 9
heures

12

V, 29 28 27 23 19 17 16 octets

8 octets sauvés grâce à @DJMcMayhem

3 octets sauvegardés grâce à @ nmjcman101

"apÀ­ñÄòy$jpkgJ

Personnages cachés:

"apÀ<C-x>ñÄ<C-x>òy$jpkgJ

C-x est Ctrl + x.

Essayez-le en ligne! prend une entrée via des arguments en ligne de commande

Hexdump:

0000000: 2261 70c0 adf1 c418 f279 246a 706b 674a  "ap......y$jpkgJ

Explication

"ap            Paste the argument
À<C-x>         Argument minus 1 times (so that we exclude the 0)
ñ ... ò        Loop (for some weird reason the ò closes the ñ)
Ä<C-x>         paste current line above and decrement it

Maintenant, il ressemble à:

1
2
...
n

a continué...

ò             recursively do (until a breaking error)
y$             yank this line
  jp           paste it down
    kgJ        go up and join
              implicit ò end

GIF (obsolète)

(pour arg 6)

gif


J'en ai eu quelques-uns en changeant votre boucle en a) fin implicitement et b) joindre les lignes au fur et à mesure (plutôt qu'à la fin)òy$jpkgJ
nmjcman101

@ nmjcman101 Merci de m'aider à économiser 2 octets!
Kritixi Lithos

C'est assez bien joué au golf. Je me suis creusé la cervelle pendant 20 bonnes minutes et je ne peux penser à rien de plus court. :)
DJMcMayhem

@DJMcMayhem C'est parce que j'ai eu une aide
précieuse

Je l'ai fait! Vous pouvez obtenir jusqu'à 16 octets. Si vous collez l'argument, puis dupliquez / décrémentez vers le haut, vous devez supprimer le H. Ensuite, si vous utilisez l'opérateur de décrémentation sur votre À, vous n'aurez pas le 0 en haut pour pouvoir supprimer le x. APPARENTLY a òfermera a ­ñpour que vous puissiez supprimer le second ­ñ(qui est l'octet que vous enregistrez). Lien parce que ça n'avait aucun sens
nmjcman101

11

C #, 72 69 65 octets

n=>{for(int i=0,j;i<n;)for(j=++i;j>0;)System.Console.Write(j--);}

Si la sortie peut simplement être renvoyée plutôt que d'être écrite sur la console

C #, 71 68 64 octets

n=>{var s="";for(int i=0,j;i<n;)for(j=++i;j>0;)s+=j--;return s;}

Merci à @VisualMelon pour avoir économisé beaucoup d'octets

Testez-le ici (avec humour, le compilateur en ligne rompt à un nombre supérieur à 420)


C'était vraiment rapide.
devRicher

@devRicher Que puis-je dire, j'attendais que quelque chose soit posté: P
Alfie Goodacre

2
Il n'y a jamais de raison d'utiliser une boucle while dans le golf en code C #, une boucle for sera toujours aussi performante, sinon meilleure. Dans ce cas, vous pouvez inclure l'affectation de j=1dans la boucle for et enregistrer un point-virgule. Vous pouvez également déclarer javec i, pour enregistrer le fichier int. Le i++peut également être déplacé vers l' j=iaffectation, en sauvegardant un octet. Vous devriez aussi pouvoir remplacer le i<=navec i<nsi vous le faites à la j=++iplace et que vous commencez ipar 0.
VisualMelon

@VisualMelon l'a édité, sauvegardé 3 octets! Déclarer les ints ensemble n'a en réalité aucune incidence sur le nombre d'octets, mais rend les boucles un peu plus agréables
Alfie Goodacre

@AlfieGoodacre si vous les déclarez ensemble dans la boucle for, vous économiserez 2 octets supplémentaires for(int i=0,j;i<n;);) Il n'est pas non plus nécessaire d'utiliser la {}boucle for interne.
VisualMelon

8

Pure bash, 34

eval eval printf %s \\{{1..$1}..1}

Deux niveaux d'expansion de corset. Avec l'entrée 6, le premier niveau se développe à {1..1} {2..1} {3..1} {4..1} {5..1} {6..1}. Cela se développe ensuite à 1 2 1 3 2 1 4 3 2 1 5 4 3 2 1 6 5 4 3 2 1, qui est mélangé à une chaîne avec printf %s. eval's sont requis aux deux niveaux d'expansion - pour le premier niveau afin que le $1paramètre soit développé en premier, et pour le deuxième niveau afin qu'il se développe après le premier niveau.

Essayez-le en ligne


8

Perl, 21 octets

Utilisations -Esans frais supplémentaires.

say map$}=$_.$},1..<>

Usage

perl -E 'say map$}=$_.$},1..<>' <<< 6
121321432154321654321

7

Pyth, 7 octets

jks}R1S

Un programme qui prend l'entrée d'un entier et imprime le résultat.

Essayez-le en ligne!

Comment ça marche

jks}R1S   Program. Input: Q
jks}R1SQ  Implicit input fill
    R     Map
      SQ  over [1, 2, 3, 4, ..., Q] with i:
   } 1     Yield [i, i-1, i-2, i-3, ..., 1]
  s       Merge
jk        Join
          Implicitly print

Personnellement, je suis très déçu que ce jk_hC.:Ssoit plus long, mais beau travail!
FryAmTheEggman

7

GeoGebra , 67 octets

1
InputBox[a]
Sum[Join[Sequence[Sequence[Text[j],j,i,1,-1],i,1,a]]]

Chaque ligne est entrée séparément dans la barre de saisie. L'entrée est prise à partir d'une zone de saisie.

Voici un gif de l'exécution:

Exécution du programme

Comment ça marche

La saisie 1attribue implicitement aà 1et la InputBoxcommande associe une zone de saisie à a. Ensuite, pour chaque ientrée {1, 2, 3, ..., a}, la liste {i, i-1, i-2, ..., 1}est créée à l'aide de la Sequencecommande et chaque élément jde cette liste est convertie en chaîne à l'aide de Text. Enfin, Joinfusionne toutes les listes et Sumconcatène tous les éléments en un seul objet texte affiché.


@devRicher Cela semble raisonnable. Merci!
TheBikingViking


7

Retina , 26 22 bytes

Le nombre d'octets suppose un codage ISO 8859-1.

.+
$*

$`¶
1
$.%'
0?¶

Essayez-le en ligne!

Explication

.+
$*

Convertir une entrée en unaire.


$`¶

À chaque position, insérez le préfixe jusqu’à ce point, ainsi qu’un saut de ligne. Cela crée une plage unaire allant de 2à n+1, une valeur par ligne.

1
$.%'

Remplacez chacun 1par le nombre de caractères après celui-ci sur la même ligne. Cela tourne quelque chose comme 11111dans 43210.

0?¶

Supprimez tous les sauts de ligne et les zéros qui les précèdent.


5

Langue GameMaker, 65 octets

b=""for(i=1;i<=argument0;i++){c=i while(j)b+=string(c--)}return b

5

APL, 10 octets

∊⍕¨∘⌽∘⍳¨∘⍳

Par exemple:

      (∊⍕¨∘⌽∘⍳¨∘⍳)6
121321432154321654321

Explication:

  • : obtenez les nombres de 1 à N.
  • ⍳¨∘: pour chacune d’elles, obtenez les nombres de 1 à N.
  • ⌽∘: inverser cette liste
  • ⍕¨∘: obtenir la représentation en caractères de chaque élément (pour ne pas afficher les nombres avec des espaces entre eux)
  • : aplatit le tableau résultant

Donc, c'est analyser le code à l'envers?
devRicher

est la composition des fonctions, j’ai donné l’explication dans l’ordre dans lequel les fonctions sont réellement évaluées
marinus

1
Pour les curieux, voici l'arbre d'analyse: tryapl.org/…
marinus

5

Python 2, 71 68 octets

Je parie qu'une solution récursive pourrait être plus courte, mais j'ai du mal à formuler cela en une.

n=input()
i=0
o=""
while i<n:
    i+=1;j=i
    while j:o+=`j`;j-=1
print o

Essayez-le en ligne


5

En fait 8 octets

RR♂RΣRεj

La première fois que vous postez une réponse dans En fait, vous pouvez probablement jouer au golf.

Comment ça marche

Program takes implicit input, implicit print at EOF
R           Takes the input and creates a range (1, input)   
                STACK = [1,2,..,n]
 R          Reverse the top stack item (our range)
                STACK = [n,..,2,1]
  ♂R        For each item in our range, create a range (1, rangeitem)
                STACK = [[1,2,..,n], .., [1,2], [1]]
    Σ       Stitch the items of the list together
                STACK = [n,..,1,2,3,1,2,1]
     R      Reverse the top stack item again (our answer)
                STACK = [1,2,1,3,2,1,..n]
      εj    Create an empty string and append each item from the list to it.
            (turns non string items into strings)

Essayez-le en ligne!


1
Je ne suis pas sûr qu'il y est une solution plus courte, mais je me suis prouvé mal avant. Dans tous les cas, voici un lien Essayez-le en ligne pour votre réponse.
Sherlock9

1
Le code R♂R♂RΣεjest le même nombre d'octets, mais il peut être plus facile d'écrire une explication pour.
Sherlock9

@ Sherlock9 ton chemin est un peu plus élégant, j'ai ajouté le lien et une explication que j'ai oublié d'ajouter hier pour essayer de l'expliquer un peu plus.
Pélican sarcelle

4

Brachylog , 8 octets

yb@[rcw\

Essayez-le en ligne!

Explication

yb         The list [1, ..., Input]
  @[       Take a prefix of that list
    rc     Reverse it and concatenate into an integer
      w    Write to STDOUT
       \   Backtrack: try another prefix

4

Perl 6 , 22 octets

{[~] flat [\R,] 1..$_}

Un lambda qui retourne une chaîne.

( Essayez-le en ligne. )

Explication:

  • 1..$_: Gamme d'entiers ... (1 2 3 4)
  • [,] 1..$_: Réduisez ("pliez") l'opérateur de virgule ... (1 2 3 4)
  • [\,] 1..$_: Avec résultats intermédiaires ( réduction triangulaire ) ...((1) (1 2) (1 2 3) (1 2 3 4))
  • [\R,] 1..$_: Appliquer le méta-opérateur d' inversion à la virgule ...((1) (2 1) (3 2 1) (4 3 2 1))
  • [~] flat ...: Supprimer l'imbrication de la liste et replier l'opérateur de concaténage ... 1213214321

4

Haskell, 35 octets

f x=[1..x]>>= \y->[y,y-1..1]>>=show

Exemple d'utilisation: f 6-> "121321432154321654321".

Pour tous les nombres xde 1 ... xla liste x,x-1, ... ,1, convertissez-les en chaîne et concaténez-les en une seule chaîne. Encore une fois, concaténez ces chaînes en une seule chaîne.


4

C89, 54 octets

i,j;f(n){for(i=1;j<=n;j=i++)while(j)printf("%d",j--);}

56 -2 = 54 grâce à ErikGolfer!


Je pense que vous pouvez faire (j=i++)au lieu de (j=i)et supprimer le dernier i++(non testé).
Erik l'Outgolfer

Voici une version récursive plus courte: i,j;f(n){j=++i;while(j)printf("%d",j--);i-n?f(n):0;}(52 octets)
Steadybox

@Steadybox Vous pouvez ajouter cela comme votre propre réponse si vous le souhaitez, mais merci!
Chat

@cat Ok, merci, je viens de le faire. Je ne savais pas si je devrais le faire puisque je n'ai fait que modifier votre solution.
Steadybox

4

Python 3, 87 92 83 74 octets

lambda n:"".join(["".join([str(i)for i in range(1,k)][::-1])for k in range(1,n+2)])

Réponse plus courte en utilisant la récursivité:

f=lambda n:f(n-1)+"".join([str(i)for i in range(1,n+1)][::-1])if n>0else""

Ce n'est peut-être pas le plus court, mais il est uniquement réalisé avec la compréhension de liste de Python!

(Edité pour ajouter la fonction d'impression et supprimer le \ n)

(Edité pour supprimer la fonction d'impression et changer n + 1, k + 1 en n, k + 2)


Fonctionne avec k, n + 2 mais pas avec k + 2, n, merci pour l'idée :)
Sygmei

Le code que vous notez devrait être le premier. En outre, vous devez utiliser Python 2, puis utiliser à la `i`place de str(i). Et vous pouvez utiliser "".join(...)au lieu de "".join([...]), et range(1,k,-1)pour supprimer le fichier [...][::-1].
mbomb007

Aussi, n>0peut être n. Et je voulais dire range(n,0,-1). Et utiliser n and f(n-1)+...)or"".
mbomb007

1
62 octets . En fait, cela peut être trop proche de cette réponse .
mbomb007

Oui ça devient assez proche, j'ai vu qu'après avoir fait ma deuxième version :(
Sygmei

3

Pyth, 8 octets

jks_M._S

Explication

jks_M._SQ   Implicit input
       SQ   Get the range [1, 2, ..., N]
     ._     Get each prefix
   _M       Reverse each prefix
jks         Join everything as a string


3

Mathematica, 36 octets

ToString/@(""<>Range[Range@#,1,-1])&

Lance une série d’avertissements qui peuvent être ignorés en toute sécurité.

Explication

En utilisant l’entrée 5comme exemple:

Range@#

Crée une plage {1, 2, 3, 4, 5}.

Range[...,1,-1]

Rangeest listable afin que nous puissions lui donner une liste pour n’importe lequel de ses arguments et il sera automatiquement passé au-dessus de cet argument. Cela nous donne donc un tas de listes inversées:

{{1}, {2, 1}, {3, 2, 1}, {4, 3, 2, 1}, {5, 4, 3, 2, 1}}

Prochain:

(""<>...)

Cela joint la liste imbriquée à la chaîne vide. Comme la liste imbriquée ne contient aucune chaîne, elle ne peut pas joindre les valeurs (c'est là que sont générés les avertissements), mais ""<>a pour effet secondaire d’aplatir la liste. Donc cela nous donne

1 <> 2 <> 1 <> 3 <> 2 <> 1 <> 4 <> 3 <> 2 <> 1 <> 5 <> 4 <> 3 <> 2 <> 1

Vient maintenant la belle fonctionnalité de Mathematica qui Mapne se soucie pas de la structure sur laquelle elle est en train d'être cartographiée Vous l'appliquez normalement à une liste, mais cela fonctionne avec n'importe quelle tête. f /@ h[a, b, c]vous donne simplement h[f[a], f[b], f[c]]. Dans notre cas, la tête est StringJoinet les valeurs sont les entiers.

ToString/@...

Donc, cela transforme simplement les nombres entiers en chaînes. À ce stade, il StringJoin[...]sait quoi faire avec et les joint tous en une seule chaîne:

"121321432154321"

1
C'est tout simplement méchant. :)
Greg Martin

3

GolfScript , 14 octets

~,{),{)}%-1%}%

Essayez-le en ligne!

Méthode habituelle bien sûr, mais c'est GolfScript.

Explication de ce code VAST :

~,{),{)}%-1%}% # Code
               # Initial stack.      ["n"]
~              # Eval ToS.           [n]
 ,             # ToS' lowered range. [[0..n)]
  {),{)}%-1%}  # Block. 1 argument.  [a]
   )           # Increment.          [a+1]
    ,          # Range.              [[0..a)]
     {)}       # Block. 1 argument.  [b]
      )        # Increment.          [b+1]
        %      # Map.                [[1..a]]
         -1    # Integer. -1         [[1..a] -1]
           %   # Each nth element.   [[a..1]]
             % # Map.                [[[1],[2,1],...,[n..1]]]
               # Implicit output.    121...n..1

Notez que la sortie est sous la forme d’un nombre unique. Trailing \n.


3

R, 38 33 44 octets

if((n=scan())>0)for(i in 1:n)cat(i:1,sep="")

Prend une entrée dans STDIN, et boucle de 1 à n, créant la séquence i à 1 pour chaque étape et l’imprimant.

Edit: remplacé seq(i,1)par la i:1sauvegarde de 5 octets et montrant pourquoi je ne devrais pas jouer au golf pendant les réunions.


Ceci produit 101si l'entrée est 0. if((n=scan())>0)for(i in 1:n)cat(i:1,sep="")fait le tour.
Frédéric

Putain, supposé entrée non nulle :(
JAD

if(n<-scan())devrait être suffisant.
Giuseppe

3

MATL , 14 à 11 octets

:"@:P]v!VXz

Essayez-le en ligne!

Explication

:      % Input N implicitly. Push range [1 2 ...N]
"      % For each k in [1 2 ...N]
  @:   %   Push range [1 2 ... k]
  P    %   Reverse
]      % End
v!     % Concatenate all arrays horizontally
V      % Convert to string
Xz     % Remove spaces. Display implicitly

not split up by anything, ne pense pas que le second est autorisé.
JAD

2
@JarkoDubbeldam Je vais supprimer celui-ci jusqu'à ce que l'OP clarifie
Luis Mendo

1
@ Jarko Le PO a clarifié. La solution actuelle est conforme à la spécification
Luis Mendo

3

brainfuck, 17 octets

>,[>[+.>]+.[<]>-]

Explication

>           keep the first cell at 0
 ,          input of the decimal number into the cell
  [>        start a conditionnal loop and go to the next cell
   [+.>]    while it don't find 0, increment each cells and output the value
    +.      increment the new cell and output
     [<]    go to the first cell
      >-]   decrement the second cell and restart

Essayez-le en ligne!


Bienvenue chez PPCG! Avez-vous lu la page de la tournée et les méta-questions les plus chaudes à ce jour? Je vous le conseille, ils sont utiles! En outre, enveloppez votre code dans le formatage de code! Avez-vous lu l'aide au formatage? Vous devriez également expliquer comment fonctionne votre code, si vous le pouvez!
devRicher

@muddyfish Je viens d'ajouter l'explication
Milihhard

J'ai utilisé une application mobile. Vous pouvez voir l'écran du résultat.
Milihhard

Non ça va. Mais dans le lien, la sortie est en ascii et non en décimale, donc vous ne voyez pas vraiment la sortie
Milihhard

@muddyfish Votre lien permanent est un peu déroutant. Il y a un invisible 0x06 dans l'entrée, suivi du chiffre décimal 6 .
Dennis

3

Python , 63 57 59 octets

Une solution récursive qui fonctionne à la fois en Python 2 et 3. Cela peut probablement être joué davantage. Suggestions de golf bienvenues! Essayez-le en ligne!

Edit: -6 octets grâce à Jonathan Allan. +2 octets, merci à mbomb007 pour avoir signalé un problème avec ma réponse.

f=lambda n:n and f(n-1)+"".join(map(str,range(n,0,-1)))or""

Ungolfing

def f(n):
    s = ""
    for i in range(n+1):
        m = map(str, range(n, 0, -1))
        s += "".join(m)
    return s

2
Utilisez a mappour économiser 6 octets:lambda n:n and f(n-1)+"".join(map(str,range(n,0,-1)))or""
Jonathan Allan

2

PHP, 35 34 33 octets

Enregistré un octet parce que j'ai mal compté, merci Titus! Et un autre!

while($i++<$argv[1])echo$s=$i.$s;

Exécuter en ligne de commande avec -r.

Réponse assez simple, boucle de 1 à travers notre entrée n, collant le numéro sur le début de la chaîne et l'imprimer.


Je compte 34. Un octet plus court avec post-incrémentation.
Titus

33 octets:while($i++<$argv[1])echo$s=$i.$s;
aross

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.