Il tuo compito è creare un programma o una funzione che generi una cerniera con una lunghezza di 10 linee. Ogni linea della cerniera è rappresentata da due trattini --:

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

Il programma / funzione prenderà una percentuale (divisibile per 10) come input e l'output sarà la cerniera "decompressa" (trattini separati) dall'alto della percentuale, rivelando il livello 1 indicizzato, il più basso ripetuto 2 volte, con tutti i livelli precedenti ripetuti 4, 6, 8, ... ecc. volte, mantenendo centrato il fondo della cerniera.

Esempi

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

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

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

L'input (percentuale) può essere formattato come preferisci (50%, 0,5, 50, 5 [zero implicito], ecc.) E sarà sempre compreso tra 0 e 100 e divisibile per 10. La spaziatura nella gli esempi devono essere conservati nell'output.

Python 2 - 184 151 146 byte

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

L'ultimo numero mi ha un po 'incasinato. Potrei essere in grado di rimuovere la seconda istruzione if se la guardo in seguito.

EDIT: da Thx a mbomb007 per la rimozione di 3 byte. Grazie a charredgrass per i suggerimenti di formattazione per aiutare a rimuovere un sacco di byte! MrGreen Grazie a TheBikingViking per l'aiuto con ancora altri due byte!

Python 2, 74 byte

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

execHo salvato due byte identificando un loop, grazie a Dennis.

EDIT: ho adottato un approccio leggermente diverso e salvato altri due byte.

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}

_{Modifica 1 - Giocato a golf 10 byte eliminando la $xvariabile e ripetendo leggermente il modo in cui la stringa è formulata.
Modifica 2: golfati altri 4 byte ripetendo come avviene l'input e ripetendo come $iviene calcolato ciascun loop.
Modifica 3: 6 byte salvati con OP che consente l'input come 0..10, quindi non è necessario dividere per 10.}

Sorprendentemente difficile!

Prende come ingresso 1, 5ecc, memorizzata in $n. Imposta la $ivariabile helper (una delle rare volte in cui è necessario inizializzare una variabile 0in PowerShell), quindi avvia un ciclo da 10a 1.

Ogni iterazione, impostiamo iniziare la nostra stringa con un numero di spazi pari a $i, seguito da uno pseudo-ternario (... , ...)[]. All'interno dello pseudo-ternario, selezioniamo una stringa di o -con un numero di cifre (il più alto di $n-10+$_o 0, moltiplicato per 2) o la stringa -10- la selezione si basa sul fatto che siamo alla decima iterazione e il nostro input era 100. Lo concateniamo con un finale -. La stringa risultante viene posizionata sulla pipeline.

Infine, aumentiamo $ie questo è stato davvero complicato. Abbiamo finito con un trucco binario da cast a int per incrementare solo $ifino a raggiungere $n, e quindi mantenerlo allo stesso valore in seguito. Questo assicura che abbiamo raggiunto la "fine" della rientranza della cerniera al livello appropriato.

Una volta terminato il ciclo, le stringhe risultanti vengono tutte accumulate sulla pipeline e l'output è implicito.

Esempi

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 byte

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

Suite di test.

Pitone, 95 84 byte

Non sapevo che gli lambda fossero legali, grazie @Dr Green Eggs e 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 byte

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

Provalo online!

Rubino, 74 byte

Utilizza il formato implicita zero specificato nella domanda, così 40%è f[4]se la funzione anonima è assegnata f. Se è necessaria una percentuale completa, +6 byte pern/=10;

Provalo 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 byte.

Prende il numero già diviso per 10. Probabilmente posso rimuovere alcune delle parentesi, ma questo è piuttosto chiuso al golf completo.

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

Haskell, 83 byte

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

Javascript es7, 105 byte

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

chiama con

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 byte

n = input ()
per x nell'intervallo (0,10):
v = str (x + 1) * (nx) 2
se x n> 89: v = '10 '
stampa' '* min (x, n) + '-' + v + '-'

Prima volta a giocare a golf. Andiamo avanti, prova a prenderlo <100.
Presuppone che l'input sia 1-10.

Modifica: ho usato alcuni trucchi della risposta di @LeakyNun (grazie), poi l'ho sgretolata un po 'di più e ho ottenuto ... praticamente la stessa risposta: / Non sapevo della conversione di stringa `int`, e 2 - booleano fammi sbarazzarsi dell'istruzione if, che mi consente di eliminare l'intera variabile v. Molto bello.

La mia versione:

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

Python 2, 81 byte

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

Ideone esso!

Python 2.7, 110 99 95 91 byte:

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 programma completo che accetta input da un numero intero nell'intervallo inclusivo [1,10], dove 10mezzi 100%e 1mezzi 10%. Probabilmente si può giocare a golf un po 'di più.

Provalo online! (Ideone)

PHP 5.3, 92 91 byte

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

• per PHP 5.3 con register_globals=1eshort_open_tags=1 (e error_reporting=0)
  chiama in cli conphp-cgi -f <filename> n=<number>
• numero da 0 a 10

• chiamare nel browser web con <scriptpath>?n=<number> : anteponi<pre>
• per 4.0.1 <PHP <5.3: sostituire ?: con ?1:(+1)
• per PHP> = 5.4: sostituire il primo $ncon($n=$_GET[n]) (+11)

non modificato come funzione (qualsiasi 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 di test

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

^{Ora questo è nuovo per me: PHP batte JavaScript.}
Questo approccio è minimizzato, credo.

Julia, 73 byte

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

Prima risposta di Julia! I suggerimenti sono apprezzati.

Provalo online!

Perl, 122 byte

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

ungolded:

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

Uso:

    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 byte

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

L'argomento dovrebbe essere dato come percentuale divisa per 10 (ovvero: un intero semplice, nell'intervallo [0,10]).