Votre tâche consiste à créer un programme ou une fonction qui génère une fermeture éclair d'une longueur de 10 lignes. Chaque ligne de la fermeture éclair est représentée par deux tirets --:

--
--
--
--
--
--
--
--
--
--

Le programme / fonction prendra un pourcentage (divisible par 10) en entrée, et la sortie sera la fermeture éclair "décompressée" (tirets séparés) du haut par le pourcentage, révélant le niveau le plus bas indexé 1 répété 2 fois, avec tous les niveaux précédents répétés 4, 6, 8, ... etc. fois, tout en gardant le bas de la fermeture éclair centré.

Exemples

>>10%
-11-
 --
 --
 --
 --
 --
 --
 --
 --
 --

>>50%
-1111111111-
 -22222222-
  -333333-
   -4444-
    -55-
     --
     --
     --
     --
     --

>>100%
-11111111111111111111-
 -222222222222222222-
  -3333333333333333-
   -44444444444444-
    -555555555555-
     -6666666666-
      -77777777-
       -888888-
        -9999-
         -10-

L'entrée (pourcentage) peut être formatée comme vous le souhaitez (50%, 0,5, 50, 5 [zéro implicite], etc.), et elle sera toujours dans la plage de 0 à 100 et divisible par 10. L'espacement dans le les exemples doivent être conservés dans votre sortie.

Python 2 - 184 151 146 octets

def r(n):
  n/=10
  for i in range(1,11):
    if n<0:print"%s--"%p
    elif i>9:print" %s-10-"%p
    else:p=" "*~-i;print"%s-%s-"%(p,`i`*2*n);n-=1

Le dernier numéro m'a un peu dérangé. Je pourrais peut-être supprimer la deuxième instruction if si je la regarde plus tard.

EDIT: Thx à mbomb007 pour supprimer 3 octets. Merci à charredgrass pour les conseils de mise en forme pour aider à supprimer des tas d'octets! :-D Merci à TheBikingViking d'avoir aidé avec encore deux octets!

Python 2, 74 octets

n=input()
x=0
exec"print' '*x+'-'+`x+1`*(n-x<<1-x/9)+'-';x=min(x+1,n);"*10

Enregistré deux octets en exec-ification d'une boucle, grâce à Dennis.

EDIT: J'ai adopté une approche légèrement différente et enregistré deux octets supplémentaires.

PowerShell v2 +, 130 120 116 110 octets

param($n)$i=0;10..1|%{" "*$i+(("-"+("$($i+1)"*([math]::Max($n-10+$_,0))*2)),"-10")[$n-$_-eq9]+"-";$i+=$i-ne$n}

_{Edit 1 - Golfed 10 octets en éliminant les $xvariables et en refaisant légèrement la façon dont la chaîne est formulée.
Edit 2 - Golfed encore 4 octets en refaisant comment l'entrée se produit et en refaisant comment $iest calculé chaque boucle.
Edit 3 - 6 octets enregistrés par OP permettant l'entrée comme 0..10, donc pas besoin de diviser par 10.}

Étonnamment difficile!

Prend entrée comme 1, 5, etc., stockés dans $n. Définit la $ivariable d' assistance (l'une des rares fois où une variable doit être initialisée 0dans PowerShell), puis démarre une boucle de 10à 1.

À chaque itération, nous définissons start notre chaîne avec un nombre d'espaces égal à $i, suivi d'un pseudo-ternaire (... , ...)[]. À l'intérieur du pseudo-ternaire, nous sélectionnons une chaîne de soit -avec un nombre de chiffres (le plus élevé de $n-10+$_ou 0, multiplié par 2), soit la chaîne -10- la sélection est basée sur le fait que nous sommes à la 10e itération et notre entrée était 100. Nous concaténons cela avec une finale -. Cette chaîne résultante est placée sur le pipeline.

Enfin, nous incrémentons $i, et c'était vraiment délicat. Nous avons fini par utiliser une astuce de conversion binaire en entier pour incrémenter uniquement $ijusqu'à ce qu'il atteigne $n, puis le maintenir à la même valeur par la suite. Cela garantit que nous avons atteint la «fin» de l'empreinte de la fermeture éclair au niveau approprié.

Une fois la boucle terminée, les chaînes résultantes sont toutes accumulées sur le pipeline et la sortie est implicite.

Exemples

PS C:\Tools\Scripts\golfing> .\unzip-some-numbers.ps1 70
-11111111111111-
 -222222222222-
  -3333333333-
   -44444444-
    -555555-
     -6666-
      -77-
       --
       --
       --

PS C:\Tools\Scripts\golfing> .\unzip-some-numbers.ps1 100
-11111111111111111111-
 -222222222222222222-
  -3333333333333333-
   -44444444444444-
    -555555555555-
     -6666666666-
      -77777777-
       -888888-
        -9999-
         -10-

Pyth, 37 34 octets

= h / QTjm + *; thS, dQj <* `d20eS, 0y-Qd" - "ST
= h / QTjm + *; thS, dQj * `d / y-Qdl`d" - "ST

Suite de tests.

Python, 95 84 octets

Je ne savais pas que les lambdas étaient légaux, merci @Dr Green Eggs et Iron Man

lambda p:'\n'.join(' '*min(p,l)+'-'+(2-(l==9))*(p-l)*str(l+1)+'-'for l in range(10))

MATL , 48 41 35 octets

0:9"@GhX<Z"45h@QVG@-E@8>-OhX>Y"h45h

Essayez-le en ligne!

Rubis, 74 octets

Utilise le format implicite zéro spécifié dans la question, donc 40%est f[4]si la fonction anonyme est attribué à f. Si un pourcentage complet est nécessaire, +6 octets pourn/=10;

Essayez-le en ligne!

->n{10.times{|i|puts' '*[i,n].min+"-#{i>8?10:(i+1).to_s*2*(n-i)if i<n}-"}}

Python 3, 98, 90, 87 , 85 octets.

Prend le nombre déjà divisé par 10. Je peux probablement supprimer certaines des parens, mais c'est assez fermé pour jouer au golf.

lambda n:'\n'.join(' '*min(i,n)+'-%s-'%(str(i+1)*(n>i>8or(n-i)*2))for i in range(10))

Haskell, 83 octets

f n=unlines[[[1..y]>>" ",take(2*(n-y))$cycle$show$y+1]>>=(++"-")|y<-min n<$>[0..9]]

Javascript es7, 105 octets

A=>[...Array(10)].map((a,i)=>' '.repeat((d=A<i)?A:i)+('-'+(i+1+'').repeat(d?0:i<9?2*(A-i):1)+'-')).join`
`

appeler avec

f=A=>[...Array(10)].map((a,i)=>' '.repeat((d=A<i)?A:i)+('-'+(i+1+'').repeat(d?0:i<9?2*(A-i):1)+'-')).join`
`


f(10)
f(5)
f(0)

Python 2.7, 113 108 77 octets

n = entrée ()
pour x dans la plage (0,10):
v = str (x + 1) * (nx) 2
si x n> 89: v = '10 '
print' '* min (x, n) + «-» + v + «-»

Jouer au golf pour la première fois. Je vais continuer, essayez d'obtenir <100.
Suppose que l'entrée est 1-10.

Edit: J'ai utilisé quelques astuces de la réponse de @LeakyNun (merci), puis je l'ai croisé un peu plus et j'ai obtenu ... essentiellement la même réponse: / Je ne connaissais pas la conversion de chaîne `int`, et 2 - booléen, laissez-moi se débarrasser de l'instruction if, ce qui m'a permis de me débarrasser de toute la variable v. Très sympa.

Ma version:

n=input()
for x in range(10):print' '*min(x,n)+'-'+`x+1`*(n-x)*(2-(x>8))+'-'

Python 2, 81 octets

n=input()/10
for i in range(10):print(' '*min(i,n)+'-'+2*(n-i)/-~(i>8)*`i+1`+'-')

Ideone it!

Python 2.7, 110 99 95 91 octets:

G=input();i=1;exec"print' '*[~-i,G][i>G]+'-%s-'%[`i`*(2*-~G-i*2),'10'][(i>9)*G>9];i+=1;"*10

Un programme complet qui prend l'entrée par un entier dans la plage inclusive [1,10], où 10signifie 100%et 1signifie 10%. Peut probablement être joué un peu plus.

Essayez-le en ligne! (Ideone)

PHP 5.3, 92 91 octets

<?for(;$i<10;$i++)echo'
'.str_pad('-'.str_repeat($i+1,$n>9&&$i>8?:($n-$i)*2).'-',22,' ',2);

• pour PHP 5.3 avec register_globals=1et short_open_tags=1(et error_reporting=0)
  appelez en cli avecphp-cgi -f <filename> n=<number>
• nombre de 0 à 10

• appeler dans le navigateur Web avec <scriptpath>?n=<number>: pré-ajouter<pre>
• pour 4.0.1 <PHP <5.3: remplacer ?:par ?1:(+1)
• pour PHP> = 5.4: remplacez le premier $npar ($n=$_GET[n])(+11)

non golfé en tant que fonction (tout PHP> = 4.0.1)

function unzip($n) // $n from 0 to 10
{
    for($i=0;$i<10;$i++)                // $i = line number -1
        $s.='
'.str_pad(                              // pad the result of the following on both sides
            '-'.                            // prepend '-'
            str_repeat($i+1,                // print line number
                ($n>9&&$i>8 ? 1             // in tenth line, if $n is 10: once
                : ($n-$i)*2)                    // else  2*($n-$i) times
            ).'-'                           // append '-'
            , 22,' ', STR_PAD_BOTH);    // pad to 22 width with SPC on both sides
    return $s;
}

suite de tests

echo'<table border=1><tr>';
for($i=0;$i<11;$i++)echo'<th>',$i*10,'%</th>';
echo'</tr><tr>';
for($i=0;$i<11;$i++)echo'<td><pre>', unzip($i), '</pre></td>';
echo '</table>';

^{Maintenant, c'est nouveau pour moi: PHP bat JavaScript.}
Cette approche est golfée au minimum, je pense.

Julia, 73 octets

x->join([" "^min(x,a)*"-$("$(a+1)"^(x>a?a>8?1:2(x-a):0))-"for a=0:9],'
')

Première réponse de Julia! Les pourboires sont appréciés.

Essayez-le en ligne!

Perl, 122 octets

$k=<>;for(my $i=0;$i++<10;){$s="-"."$i"x($k/10-$i+1);$p=length $s;$l=$l>$p?$l:$p;printf "%${l}s%s\n",$s,scalar reverse $s}

Lisp commun (Lispworks), 314 octets

(defun f()(let((s(string(read))))(let((n(/(parse-integer(subseq s 0(1-(length s))))10)))(if(> n 0)(progn(dotimes(r n)(progn(dotimes(c r)#1=(format t" "))(format t"-")(if(=(1+ r)10)(format t"10")(dotimes(j(* 2(- n r)))(format t"~S"(1+ r))))(format t"-~%")))(dotimes(d(- 10 n))(dotimes(c n)#1#)(format t"--~%")))))))

non doré:

    (defun f ()
      (let ((s (string (read))))
        (let ((n (/ (parse-integer (subseq s 0 (1- (length s)))) 10)))
          (if (> n 0)
              (progn
                (dotimes (r n)
                  (progn
                    (dotimes (c r)
                      (format t " "))
                    (format t "-")
                    (if (= (1+ r) 10)
                        (format t "10")
                      (dotimes (j (* 2 (- n r)))
                        (format t "~S" (1+ r))))
                    (format t "-~%")))
                (dotimes (d (- 10 n))
                  (dotimes (c n)
                    (format t " "))
                  (format t "--~%")))))))

Usage:

    CL-USER 2515 > (f)
    10%
    -11-
     --
     --
     --
     --
     --
     --
     --
     --
     --
    NIL

    CL-USER 2516 > (f)
    50%
    -1111111111-
     -22222222-
      -333333-
       -4444-
        -55-
         --
         --
         --
         --
         --
    NIL

    CL-USER 2517 > (f)
    100%
    -11111111111111111111-
     -222222222222222222-
      -3333333333333333-
       -44444444444444-
        -555555555555-
         -6666666666-
          -77777777-
           -888888-
            -9999-
             -10-
    NIL

APL, 46 octets

{↑(⍳10){(''↑⍨1-⍺⌊a+1),1⌽'--',⍵⍴⍕⍺}¨10↑2×⌽⍳a←⍵}

L'argument doit être donné sous la forme d'un pourcentage divisé par 10 (c'est-à-dire: un entier simple, dans la plage [0,10]).