Twoim zadaniem jest stworzenie programu lub funkcji, która generuje zamek błyskawiczny o długości 10 linii. Każda linia zamka jest reprezentowana przez dwa myślniki-- :

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

Program / funkcja przyjmie wartość procentową (podzielną przez 10) jako dane wejściowe, a wynikiem będzie suwak „rozpakowany” (kreski oddzielone) od góry o wartość procentową, odsłaniając 1-indeksowany, najniższy poziom powtarzany 2 razy, z wszystkie poprzednie poziomy powtórzone 4, 6, 8, ... itd. razy, jednocześnie utrzymując środek suwaka pośrodku.

Przykłady

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

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

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

Dane wejściowe (procentowe) można sformatować w dowolny sposób (50%, 0,5, 50, 5 [implikowane zero] itp.), I zawsze będą w zakresie od 0 do 100 i podzielne przez 10. Odstęp w przykłady muszą być zachowane w twoich wynikach.

Python 2 - 184 151 146 bajtów

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

Ostatni numer trochę mi pomieszał. Mogę być w stanie usunąć drugą instrukcję if, jeśli popatrzę na nią później.

EDYCJA: Dzięki do mbomb007 za usunięcie 3 bajtów. Dzięki charredgrass za wskazówki dotyczące formatowania, które pomogą usunąć wiele bajtów! :-D Dziękujemy TheBikingViking za pomoc w jeszcze dwóch bajtach!

Python 2, 74 bajty

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

Zaoszczędzono dwa bajty dzięki execuaktywnieniu pętli dzięki Dennisowi.

EDYCJA: Podjąłem nieco inne podejście i zaoszczędziłem jeszcze dwa bajty.

PowerShell v2 +, 130 120 116 110 bajtów

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

_{Edycja 1 - Grał w golfa 10 bajtów, eliminując $xzmienną i nieco przerabiając sposób formułowania łańcucha.
Edycja 2 - Grał w golfa o kolejne 4 bajty, powtarzając sposób wprowadzania danych i powtarzając sposób $iobliczania każdej pętli.
Edycja 3 - Zapisano 6 bajtów przez OP, umożliwiając wprowadzanie jako 0..10, więc nie trzeba dzielić przez 10.}

Zaskakująco trudne!

Zajmuje wejście jak 1, 5itd przechowywane w $n. Ustawia $izmienną pomocniczą (jeden z bardzo rzadkich przypadków, w których zmienna musi zostać zainicjowana0 w PowerShell), a następnie uruchamia pętlę od 10do1 .

W każdej iteracji rozpoczynamy ciąg od liczby równych spacji $i, po których następuje pseudo-trójka (... , ...)[]. Wewnątrz pseudo-trójki wybieramy ciąg -z liczbą cyfr (wyższą $n-10+$_lub 0pomnożoną przez 2) lub ciąg -10- wybór zależy od tego, czy jesteśmy na 10 iteracji, a nasze dane wejściowe były 100. Łączymy to z finałem -. Ten wynikowy ciąg jest umieszczany na rurociągu.

Wreszcie zwiększamy $i, a to było naprawdę trudne. Skończyliśmy z użyciem sztuczki rzutowania na binarne, aby zwiększać tylko $i, aż osiągnie $n, a następnie utrzymywać tę samą wartość później. To gwarantuje, że osiągnęliśmy „koniec” wgłębienia zamka na odpowiednim poziomie.

Po zakończeniu pętli wszystkie wynikające łańcuchy są gromadzone w potoku, a dane wyjściowe są niejawne.

Przykłady

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 bajtów

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

Zestaw testowy.

Pyton, 95 84 bajtów

Nie wiedziałem, że lambda są legalne, dzięki @Dr Green Eggs i 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 bajtów

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

Wypróbuj online!

Rubinowy, 74 bajty

Używa dorozumiany zero wzoru podanego w pytaniu, tak 40%jest f[4], jeśli funkcja anonimowa jest przypisany f. Jeśli potrzebny jest pełny procent, +6 bajtów nan/=10;

Wypróbuj 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 bajtów.

Pobiera już podzieloną liczbę przez 10. Prawdopodobnie mogę usunąć niektóre pareny, ale jest to dość zamknięte dla w pełni golfa.

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

Haskell, 83 bajty

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

JavaScript es7, 105 bajtów

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

Zadzwoń z

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 bajtów

n = input ()
dla xw zakresie (0,10):
v = str (x + 1) * (nx) 2,
jeśli x n> 89: v = '10 '
print' '* min (x, n) + „-” + v + ”-„

Gra w golfa po raz pierwszy. Idź dalej, spróbuj uzyskać <100.
Zakłada, że ​​dane wejściowe to 1-10.

Edycja: Użyłem kilku sztuczek z odpowiedzi @LeakyNun (dzięki), następnie poderwałem ją nieco dalej i uzyskałem ... w zasadzie tę samą odpowiedź: / Nie wiedziałem o konwersji łańcucha `int`, i 2 - boolean pozwolił mi pozbyłem się instrukcji if, która pozwoliła mi pozbyć się całej zmiennej v. Bardzo fajny.

Moja wersja:

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

Python 2, 81 bajtów

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

Ideone to!

Python 2.7, 110 99 95 91 bajtów:

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

Pełny program, który pobiera dane przez liczbę całkowitą z zakresu obejmującego [1,10], w którym 10środki 100%i 1środki 10%. Prawdopodobnie można go nieco pograć w golfa.

Wypróbuj online! (Ideone)

PHP 5.3, 92 91 bajtów

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

• dla PHP 5.3 z register_globals=1i short_open_tags=1(i error_reporting=0)
  wywołanie w cli zphp-cgi -f <filename> n=<number>
• liczba od 0 do 10

• zadzwonić za pomocą przeglądarki internetowej <scriptpath>?n=<number> : prepend<pre>
• dla 4.0.1 <PHP <5.3: zamień ?: z ?1:(+ 1)
• PHP> = 5.4: wymienić pierwsze $nz($n=$_GET[n]) (+11)

niegolfowany jako funkcja (dowolne 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;
}

pakiet testowy

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

^{To dla mnie nowość: PHP pokonuje JavaScript.}
Myślę, że to podejście jest do gry w golfa.

Julia, 73 bajty

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

Pierwsza odpowiedź Julii! Wskazówki są mile widziane.

Wypróbuj online!

Perl, 122 bajty

$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 bajtów

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

nie złożony:

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

Stosowanie:

    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 bajtów

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

Argument należy podać jako procent podzielony przez 10 (to znaczy: zwykłą liczbę całkowitą w zakresie [0,10]).