Ihre Aufgabe ist es, ein Programm oder eine Funktion zu erstellen, die einen Reißverschluss mit einer Länge von 10 Zeilen erzeugt. Jede Zeile des Reißverschlusses wird durch zwei Bindestriche dargestellt --:

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

Das Programm / die Funktion nimmt einen Prozentsatz (teilbar durch 10) als Eingabe, und die Ausgabe ist der Reißverschluss, der von oben durch den Prozentsatz "entpackt" (Bindestriche getrennt) wird. Dabei wird die 1-indizierte niedrigste Ebene angezeigt, die zweimal mit wiederholt wird Alle vorherigen Levels wurden wiederholt 4, 6, 8, ... usw. Mal, während der Boden des Reißverschlusses zentriert bleibt.

Beispiele

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

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

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

Die Eingabe (in Prozent) kann beliebig formatiert werden (50%, .5, 50, 5 [impliziert null] usw.) und liegt immer im Bereich von 0 bis 100 und ist durch 10 teilbar Beispiele müssen in Ihrer Ausgabe erhalten bleiben.

Python 2 - 184 151 146 Bytes

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

Die letzte Nummer hat mich ein bisschen durcheinander gebracht. Ich kann die zweite if-Anweisung möglicherweise entfernen, wenn ich sie später anschaue.

EDIT: Danke an mbomb007 zum Entfernen von 3 Bytes. Vielen Dank an charredgrass für die Formatierungstipps, mit denen Sie viele, viele Bytes entfernen können! :-D Danke an TheBikingViking für die Hilfe bei zwei weiteren Bytes!

Python 2, 74 Bytes

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

Zwei Bytes von gespeichert exec gespart, dank Dennis eine Schleife aktiviert wurde.

EDIT: Ich habe einen etwas anderen Ansatz gewählt und zwei weitere Bytes gespeichert.

PowerShell v2 +, 130 120 116 110 Byte

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

_{Edit 1 - 10 Bytes durch Eliminieren von $xVariablen und leichtes Wiederholen der Formulierung der Zeichenfolge.
Edit 2 - Weitere 4 Bytes durch Wiederholen der Eingabe und Wiederholen der $iBerechnung der einzelnen Schleifen.
Edit 3 - 6 Bytes durch OP gespeichert, Eingabe als0..10 , daher muss nicht durch 10 geteilt werden.}

Überraschend schwer!

Übernimmt die Eingabe als 1 , 5usw., gespeichert in $n. Legt die $iHilfsvariable fest (eine der sehr seltenen Situationen, in denen eine Variable 0in PowerShell initialisiert werden muss ) und startet dann eine Schleife von 10bis 1.

Bei jeder Iteration setzen wir den Anfang unseres Strings mit einer Anzahl von Leerzeichen $i, gefolgt von einem Pseudoternär(... , ...)[] . Innerhalb des Pseudoternärs wählen wir eine Zeichenfolge aus, entweder -mit einer Anzahl von Ziffern (der höheren von $n-10+$_oder 0, multipliziert mit 2) oder der Zeichenfolge -10- die Auswahl basiert darauf, ob wir uns bei der 10. Iteration befinden und unsere Eingabe erfolgte100 . Wir verketten das mit einem Finale -. Diese resultierende Zeichenfolge wird in die Pipeline eingefügt.

Schließlich erhöhen wir uns $i, und das war wirklich schwierig. Wir haben einen Binär-Cast-to-Int-Trick verwendet, um nur $ibis zum Erreichen zu erhöhen$n und ihn anschließend auf dem gleichen Wert zu halten. Dies stellt sicher, dass wir das "Ende" der Reißverschlusseinrückung auf der entsprechenden Ebene erreicht haben.

Sobald die Schleife beendet ist, werden alle resultierenden Zeichenfolgen in der Pipeline akkumuliert und die Ausgabe ist implizit.

Beispiele

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 Bytes

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

Testsuite.

Python, 95 84 Bytes

Ich wusste nicht, dass Lambdas legal sind, danke an Dr. Green Eggs und 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 Bytes

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

Probieren Sie es online!

Ruby, 74 Bytes

Verwendet das implizierte-Null - Format in der Frage angegeben, so 40%ist , f[4]wenn die anonyme Funktion zugewiesen ist f. Wenn ein vollständiger Prozentsatz benötigt wird, +6 Bytes fürn/=10;

Probieren Sie es online!

->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 Bytes.

Nimmt die Zahl bereits durch 10 geteilt. Ich kann wahrscheinlich einige der Parens entfernen, aber dies ist ziemlich geschlossen, um vollständig Golf zu spielen.

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

Haskell, 83 Bytes

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

Javascript es7, 105 Bytes

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

mit anrufen

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 Bytes

n = Eingabe ()
für x im Bereich (0,10):
v = str (x + 1) * (nx) 2,
wenn x n> 89: v = '10 '
print' '* min (x, n) + '-' + v + '-'

Zum ersten Mal Golf spielen. Ich werde weitermachen und versuchen, es auf <100 zu bringen.
Angenommen, die Eingabe ist 1-10.

Edit: Benutzte ein paar Tricks aus @LeakyNuns Antwort (danke), knackte sie dann ein bisschen weiter und bekam ... im Grunde die gleiche Antwort: / Wusste nichts über die `int` Stringkonvertierung, und 2 - boolean ließ mich Entfernen Sie die if-Anweisung, mit der ich die gesamte v-Variable entfernen kann. Sehr cool.

Meine Version:

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

Python 2, 81 Bytes

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

Ideone es!

Python 2.7, 110 99 95 91 Bytes:

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

Ein vollständiges Programm , das Eingang durch eine ganze Zahl im inklusiven Bereich erfolgt [1,10], in dem 10Mittel 100%und 1Mitteln10% . Kann wahrscheinlich ein bisschen mehr golfen werden.

Probieren Sie es online! (Ideone)

PHP 5.3, 92 91 Bytes

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

• für PHP 5.3 mit register_globals=1und short_open_tags=1(und error_reporting=0)
  in cli mit aufrufenphp-cgi -f <filename> n=<number>
• Zahl von 0 bis 10

• im Webbrowser mit aufrufen <scriptpath>?n=<number> : voranstellen<pre>
• Für 4.0.1 <PHP <5.3: Ersetzen ?: durch ?1:(+1)
• für PHP> = 5.4: ersetze das erste $nmit ($n=$_GET[n])(+11)

ungolfed als Funktion (beliebiges 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;
}

Testsuite

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>';

^{Das ist neu für mich: PHP schlägt JavaScript.}
Diese Herangehensweise ist, glaube ich, auf die Minute genau Golf.

Julia, 73 Bytes

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

Erste Julia Antwort! Trinkgelder sind erwünscht.

Probieren Sie es online!

Perl, 122 Bytes

$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}

Common Lisp (Lispworks), 314 Byte

(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"--~%")))))))

nicht vergoldet:

    (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 "--~%")))))))

Verwendung:

    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 Bytes

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

Das Argument sollte als Prozentsatz geteilt durch 10 angegeben werden (das heißt: eine einfache ganze Zahl im Bereich [0,10]).