Wydrukuj macierz blokowo-diagonalną


27

Oto prosty, bite-sized (bajt wielkości?) Kod golf: podany niepusty lista liczb całkowitych dodatnich mniej niż 10, wydrukować blok-przekątna matrycy, gdzie wykazie określa wielkość bloków, w porządku. Bloki muszą składać się z dodatnich liczb całkowitych mniejszych niż 10. Więc jeśli podano jako dane wejściowe

[5 1 1 2 3 1]

Twój wynik może być na przykład

1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1

lub

1 2 3 4 5 0 0 0 0 0 0 0 0
6 7 8 9 1 0 0 0 0 0 0 0 0
2 3 4 5 6 0 0 0 0 0 0 0 0
7 8 9 1 2 0 0 0 0 0 0 0 0
3 4 5 6 7 0 0 0 0 0 0 0 0
0 0 0 0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 9 0 0 0 0 0 0
0 0 0 0 0 0 0 1 2 0 0 0 0
0 0 0 0 0 0 0 3 4 0 0 0 0
0 0 0 0 0 0 0 0 0 5 6 7 0
0 0 0 0 0 0 0 0 0 8 9 1 0
0 0 0 0 0 0 0 0 0 2 3 4 0
0 0 0 0 0 0 0 0 0 0 0 0 5

czy jakoś tak. Elementy w macierzy muszą być oddzielone (pojedynczymi) spacjami, a wiersze oddzielone (pojedynczymi) znakami nowej linii. Na liniach nie mogą znajdować się spacje wiodące ani końcowe. Możesz wydrukować nowy znak końcowy lub nie.

Możesz napisać funkcję lub program, przyjmując dane wejściowe przez STDIN (lub najbliższą alternatywę), argument wiersza poleceń lub argument funkcji, w dowolnym dogodnym formacie łańcucha lub listy (o ile nie jest on wstępnie przetworzony). Jednak wynik musi być wydrukowany do STDOUT (lub najbliższej alternatywy), w przeciwieństwie do zwracanej z funkcji, powiedzmy.

Nie wolno używać żadnych wbudowanych funkcji zaprojektowanych do tworzenia macierzy blokowych.

To jest kod golfowy, więc wygrywa najkrótsze przesłanie (w bajtach).

Liderów

Oczekuję, że języki oparte na tablicach (takie jak J i APL) będą miały tutaj przewagę, ale nie chcę, aby zniechęcało to ludzi do robienia tego tak dobrze, jak potrafią w wybranym przez siebie języku. Oto fragment kodu, który pozwala wygenerować zarówno zwykłą tabelę wyników, jak i przegląd zwycięzców według języka. Dlaczego więc nie spróbować złapać tego drugiego?

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

# Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Odpowiedzi:


20

J, 7 bajtów

Dzięki za FUZxxl za 2-bajtową poprawę.

Języki oparte na macierzach powinny być liczone tutaj w innym konkursie, ponieważ mają ogromną przewagę. :)

   =/~@#<\

   (=/~@#<\) 3 1 1 2
1 1 1 0 0 0 0
1 1 1 0 0 0 0
1 1 1 0 0 0 0
0 0 0 1 0 0 0
0 0 0 0 1 0 0
0 0 0 0 0 1 1
0 0 0 0 0 1 1

Kolejne 7-bajtowe podejście:

#]=@##\

Objaśnienie do starej wersji ([:=/~]#<\):

Pierwszym krokiem jest wygenerowanie nkawałka podobnych rzeczy (np. Liczb) dla każdego elementu listy n. Powinny one różnić się od pozostałych elementów ”. Np . 3 1 1 2Staje się używanie liczb naturalnych 0 0 0 1 2 3 3.

Aby zaoszczędzić na bajtach, używamy pudełkowych prefiksów listy:

   ]#<\ 3 1 1 2
┌─┬─┬─┬───┬─────┬───────┬───────┐
│3│3│3│3 1│3 1 1│3 1 1 2│3 1 1 2│
└─┴─┴─┴───┴─────┴───────┴───────┘

Za pomocą =/~czasownika tworzymy tabelę produktów Kartezjusza z tych prefiksów w pudełkach, a każda komórka będzie, 1jeśli w przeciwnym razie dwa wpisy będą równe 0.


2
Nie sądzę, żeby nawiasy wokół się [:=/~]#<\ liczyły do ​​twojego wyniku. Również =/~@#<\ za dwa dodatkowe bajty zostały ogolone.
FUZxxl,

„Jednak wynik musi być wydrukowany do STDOUT (lub najbliższej alternatywy), w przeciwieństwie do zwracanej z funkcji, powiedzmy .” Prawdopodobnie potrzebujesz albo jawnego wejścia (więc nie jest to tylko funkcja), albo jawnego wyniku.
marinus

@marinus J wypisuje wynik wyrażenia na standardowe wyjście, jeśli nie jest ono powiązane ze zmienną.
FUZxxl,

@FUZxxl: tak, ale (=/~@#<\)jest tylko funkcją. Trzeba by rzeczywiście stosuje się go do czegoś, aby uzyskać ekspresję, tak że trzeba wyraźnej wejście ( ".1!:1[1), lub jeśli chcesz złożyć funkcję, że funkcja powinna faktycznie wydrukować wartości, a nie tylko go zwrócić (jak echo@lub coś ).
marinus

=/~&I.­­­­­­­
ngn

11

APL, 10

∘.=⍨∆/⍋∆←⎕

Przykład:

      ∘.=⍨∆/⍋∆←⎕
⎕:
      5 1 1 2 3 1 
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1

Wyjaśnienie:

  • ∆←⎕: wczytaj dane wejściowe, zapisz w .
  • ⍋∆: znajdź permutację, która sortuje (daje to unikalną wartość dla każdej wartości na wejściu)
  • ∆/: dla każdej z tych unikalnych wartości powtórz to Nrazy, gdzie Njest odpowiednią wartością na wejściu
  • ∘.=⍨: utwórz macierz porównującą każdą wartość z tej listy z innymi wartościami.

Aby to przetestować http://tryapl.org, możesz użyć dfn {∘.=⍨⍵/⍋⍵}, ponieważ witryna filtruje wszystkie zastosowania (z wyjątkiem ⎕IOi tego typu rzeczy).
FUZxxl,

1
@FUZxxl: mówi „Jednak wynik musi być wydrukowany do STDOUT (lub najbliższej alternatywy), w przeciwieństwie do zwracanej z funkcji, powiedzmy .”, Więc {∘.=⍨⍵/⍋⍵}nie jest poprawny. Potrzebujesz {⎕←∘.=⍨⍵/⍋⍵}, co kosztuje nie tylko dwie postacie, ale nadal nie działa na TryAPL. (I ogólnie, TryAPL jest zbyt ograniczony, aby był użyteczny.)
marinus

Jeśli to musi wydrukować wynik, czy i ⎕←tak nie byłbyś potrzebny , nawet bez dfn?
FUZxxl,

@FUZxxl: nie, dane wyjściowe wyrażenia są drukowane automatycznie, jeśli nic innego z tym nie zrobiono.
marinus

O, rozumiem. Miałem wrażenie, że dzieje się tak tylko wtedy, gdy używasz interpretera interaktywnie.
FUZxxl,

8

R 69 63

function(x)write(+outer(i<-rep(1:length(x),x),i,"=="),1,sum(x))

Przypadek testowy:

(function(x)write(+outer(i<-rep(1:length(x),x),i,"=="),1,sum(x)))(c(5,1,1,3,1))
1 1 1 1 1 0 0 0 0 0 0 
1 1 1 1 1 0 0 0 0 0 0 
1 1 1 1 1 0 0 0 0 0 0 
1 1 1 1 1 0 0 0 0 0 0 
1 1 1 1 1 0 0 0 0 0 0 
0 0 0 0 0 1 0 0 0 0 0 
0 0 0 0 0 0 1 0 0 0 0 
0 0 0 0 0 0 0 1 1 1 0 
0 0 0 0 0 0 0 1 1 1 0 
0 0 0 0 0 0 0 1 1 1 0 
0 0 0 0 0 0 0 0 0 0 1

Funkcja zewnętrzna wykonuje większość pracy tutaj, to jest tylko przypadek, aby uzyskać odpowiedni wygląd wyjścia - Dzięki @Vlo za pomoc w tym


Bardzo fajne rozwiązanie
MickyT,

Świetne rozwiązanie. Nigdy nie myślałem o użyciu -/+do wymuszenia logiki. Zaoszczędź kilka bajtów function(x)write(+outer(i<-rep(1:length(x),x),i,"=="),1,sum(x))63
Vlo,

6

Python 3, 103 97 82 78 76 bajtów

def P(L,n=0):k,*L=L;exec("print(*[0]*n+[1]*k+[0]*sum(L));"*k);L and P(L,n+k)

Korzystanie z ikony, aby skorzystać z rozdzielającej przestrzeń natury print, z odrobiną rekurencji.


6

Rubin, 86 90 83 bajtów

Mój pierwszy golf w historii!

->l{n=l.reduce :+;s=0;l.map{|x|x.times{puts ([0]*s+[1]*x+[0]*(n-x-s))*" "};s+=x}}

Pobiera tablicę z liczbami całkowitymi, drukuje oczekiwany wynik:

$ (->l{n=l.reduce :+;s=0;l.map{|x|x.times{puts ([0]*s+[1]*x+[0]*(n-x-s))*" "};s+=x}}).call([5, 1, 1, 2, 3, 1])
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1

Edytować:

Dzięki Martin Büttner za pomoc w skróceniu niektórych rzeczy!


1
Możesz zapisać więcej znaków: ->(l)może być ->l. mapjest krótszy niż each. .join(" ")można skrócić do *" ".
Martin Ender

6

Matlab, 60 54 bajtów

Byłoby to specjalne pole Matlaba, JEŚLI moglibyśmy użyć wbudowanych funkcji ...

Dzięki @sanchises za naprawienie błędu, który przegapiłem.

c=0;a=input('');for A=a;v=c+1:c+A;d(v,v)=1;c=c+A;end;d

Wow, do tej pory zauważyłem, że ten fragment kodu js faktycznie tworzy tabelę wyników !!! Jak tego nigdy nie zauważyłem ??? Dzięki za zwrócenie na to uwagi =)
flawr

Wiem, prawda? To naprawdę fajne!
Alex A.,

1
Już miałem zamieścić prawie taką samą odpowiedź :-)
Luis Mendo,

Dokładnie to samo czy coś nieco innego? =) (Cóż, oprócz nazw zmiennych.)
flawr

Zbyt podobne, żebym mógł to opublikować :-)
Luis Mendo,

6

Matlab, 53 bajty

Chociaż jest on tylko o jeden znak krótszy od drugiego fragmentu Matlaba, pomyślałem, że kod jest wystarczająco inny, aby uzasadnić nową odpowiedź:

d=[];a=input('');for A=a;v=1:A;d(end+v,end+v)=1;end;d

Główna sztuczka polega oczywiście na indeksowaniu poza granicami, ale jest to połączone z użyciem endjako zmiennej, aby uczynić ją bardziej kompaktową.


1
Cholera - spędziłem pół godziny próbując grać w golfa, end+1:end+vaby pozbyć się zmiennej „przeciwnej”, i nie myślałem o tym rozwiązaniu.
Sanchises

Rzeczywiście, jak wspomniano w @Geobits, próba edycji przez anonimowego w blkdiagnaruszałoby wymagania. Dla porównania umieszczę tutaj jego rdzeń:blkdiag(A,ones(i))
Dennis Jaheruddin

4

CJam, 21 lat

q~{T):Ta*~}%_f{f=S*N}

Wypróbuj na http://cjam.aditsu.net/

Wyjaśnienie:

q~          read and evaluate the input array
{…}%        transform each number using the block
    T):T    increment T (initially 0)
    a*      wrap T in an array and repeat it <number> times
    ~       dump the repeated numbers so they end up in a flat array
_           duplicate the array
f{…}        for each array item and the array
    f=      compare the current item with each item, resulting in an array of 1 and 0
    S*      join with spaces
    N       add a newline

4

Python 3, 79

def f(l,s=0):
 for x in l:r=[0]*sum(l);r[s:s+x]=[1]*x;s+=x;exec("print(*r);"*x)

Śledzi lewy indeks bloku jako si dokonuje xwpisów po nim 1, gdzie xjest bieżący rozmiar bloku. Ten wiersz jest następnie drukowany xrazy. Do tego potrzebny jest Python 3 print(*r).


Jest o jeden charakter krótszy, aby wyrazić rjako [0]*s+[1]*x+[0]*(sum(l)-s-x), ale wciąż szukam lepszego sposobu.
xnor

4

Haskell, 118 116 bajtów

(#)=replicate
f i=putStr$[e#(unwords$sum h#"0"++e#"1"++sum t#"0")|(h,e:t)<-map(`splitAt`i)[0..length i-1]]>>=unlines

Stosowanie: f [2,1,1,3]

Wydajność:

1 1 0 0 0 0 0
1 1 0 0 0 0 0
0 0 1 0 0 0 0
0 0 0 1 0 0 0
0 0 0 0 1 1 1
0 0 0 0 1 1 1
0 0 0 0 1 1 1

Jak to działa:

[0..length i-1]           for each index n of the input list i
(h,e:t)<-map(`splitAt`i)  split i at n and
                            let e be the element at index n
                            let h be the list of elements to the left of e
                            let t be the list of elements to the right of e
                          foreach triple h, e, t make a list of
sum h # "0" ++              sh copies of "0" (sh = the sum of the elements of h) followed by
e # "1" ++                  e copies of "1" followed by
sum t # "0"                 st copies of "0" (st = the sum of the elements of t)
unwords                   join those list elements with spaces inbetween
e #                       make e copies
>>=unlines                join those lists with newlines inbetween
putStr                    print

Możesz zapisać dwa bajty (h,e:t)<-map(`splitAt`i)[0..length i-1], ponieważ nnie jest używany poza letwiązaniem.
Zgarb

@Zgarb: ładne znalezisko. Dzięki!
nimi

3

Pyth 23 21 bajtów

Repozytorium GitHub dla Pyth

Ju+G*]GHQYFNJjdmsqdNJ

Dane wejściowe to lista liczb całkowitych, takich jak [3, 1, 1, 2] . Wypróbuj online: Pyth Compiler / Executor

Używa dość podobnego pomysłu jak kod J randomry. Pierwsza część kodu Ju+G*]GHQYgeneruje nczęści podobnych rzeczy. Dla przykładowego wejścia [3, 1, 1, 2]wynik wygląda następująco:

[
 [], 
 [], 
 [], 
 [[], [], []], 
 [[], [], [], [[], [], []]], 
 [[], [], [], [[], [], []], [[], [], [], [[], [], []]]], 
 [[], [], [], [[], [], []], [[], [], [], [[], [], []]]]
]

Najpierw trzy identyczne elementy, niż jeden element, potem jeszcze jeden element, a na końcu dwa identyczne elementy.

Ju+G*]GHQY
 u      QY  reduce the input Q, start with empty list G=[]
            for each H in input, replace the value of G by:
  +G*]GH       G+[G]*H
J           store the result in J

Druga część kodu to porównanie elementów produktu kartezjańskiego i wydrukowanie go.

FNJjdmsqdNJ
FNJ          for N in J:
     m    J     map each element d of J to
       qdN          the boolean value of d == N
      s             and convert it to an integer (0 = False, 1 = True)
   jd           print the resulting list seperated by d (=space)

3

C ++, 294 bajty

Używany kompilator - GCC 4.9.2

#include<bits/stdc++.h>
using namespace std;
#define F(a,b) for(a=0;a<b;a++)
#define V vector<int>
int n,i,j,s,o;
main(){V v;while(cin>>n)v.push_back(n),s+=n;vector<V> m(s,V(s,0));F(i,v.size()){F(j,v[i])F(n,v[i])m[j+o][n+o]=1;o+=v[i];}F(j,s){F(n,s)cout<<m[j][n]<<((n==s-1)?"":" ");cout<<"\n";}}

Objaśnienie -:

#include<bits/stdc++.h>
using namespace std;
#define F(a,b) for(a=0;a<b;a++)
#define V vector<int>
int n, i, j, s, o;
/*
 n = Used to take inputs, and as an iterator after that
 i, j = Iterators
 s = sum of all the inputs
 o = offset ( used to find the location of the starting cell of the next matrix of 1's )
*/

main()
{
    V v;
    while ( cin >> n )  // Take input
    {
        v.push_back( n ), s += n;
    }

    vector<V> m( s, V( s, 0 ) ); // m is a matrix of size (s*s) with all elements initialized to 0
    F( i, v.size() )
    {
        F( j, v[i] )F( n, v[i] )m[j + o][n + o] = 1; // Assign 1 to the required cells
        o += v[i]; // Add the value of the current element to the offset
    }

    F( j, s )  // Output the matrix
    {
        F( n, s )cout << m[j][n] << ( ( n == s - 1 ) ? "" : " " ); // Prevent any trailing whitespace
        cout << "\n";
    }
}

3

K, 30 bajtów

{"i"$,/x#',:',/'g=\:\:x#'g:<x}

Zasadniczo ukradł odpowiedź marinusa

k){"i"$,/x#',:',/' g=\:\:x#'g:<x}5 1 1 2 3 1
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1

2

Java, 163

a->{int n=a.stream().mapToInt(x->x).sum(),t=0,j,k;for(int i:a){for(j=0;j++<i;System.out.println("\b"))for(k=0;k<n;)System.out.print(k>=t&k++<t+i?"1 ":"0 ");t+=i;}}

Konsument, który akceptuje listę liczb całkowitych.

Wersja do odczytu z kodem na płycie głównej:

java.util.function.Consumer<java.util.List<Integer>> c = a -> {
    int n = a.stream().mapToInt(x -> x).sum(), t = 0, j, k;
    for (int i : a) {
        for (j = 0; j++ < i; System.out.println("\b")) {
            for (k = 0; k < n;) {
                System.out.print(k >= t & k++ < t + i ? "1 " : "0 ");
            }
        }
        t += i;
    }
};

Wywołaj używając:

List list = Arrays.asList(5, 1, 1, 2, 3, 1);
c.accept(list);

2

Python 2, 163 114 bajtów

gnibbler grał w golfa.

h=input()
r=range
l=len(h)
for i in r(l):
 for k in r(h[i]):print" ".join("01"[i==j]for j in r(l)for x in r(h[j]))

3
jak o print" ".join("01"[i==j]for j in r(l(h))for x in r(h[j]))?
gnibbler

Ha ! Myślałem, że mogę coś takiego zrobić.
KSFT

Wydaje się, że drukuje tylko jeden wiersz każdego bloku.
xnor

@xnor Masz rację; Naprawiłem to.
KSFT

2

Python 3, 74

def f(a,p=0):n=a.pop(0);exec("print(*'0'*p+'1'*n+'0'*sum(a));"*n);f(a,p+n)

Czy to nie kończy się z błędem?
xnor

@ xnor tak to robi!
feersum

1
@feersum Czy to dozwolone? Nie widzę żadnego meta posta na ten temat. Jak myślisz, Martin? Jeśli jest to dozwolone, Sp3000 może zaoszczędzić 6 znaków, eliminując andzwarcie.
xnor

@ xnor Czy błąd kończy działanie programu, czy tylko wywołanie funkcji? Jeśli to zakończy program, to nie sądzę, że jest to dozwolone. Wyraziłem tutaj swoją opinię na ten temat na stronie meta . Myślę też, że gdyby w opinii feersum było to całkowicie uzasadnione, stwierdziłby to w swojej odpowiedzi zamiast mieć nadzieję, że nikt tego nie zauważy.
Martin Ender

@ MartinBüttner Zakończ program, jeśli rozumiem, o co pytasz. Jeśli miałbyś to zrobić f([1,2,3]);print("Done"), błąd zakończyłby działanie programu po wydrukowaniu macierzy bloków i nie przejdzie do drukowania „Gotowe”.
xnor

2

JavaScript (ES6), 103 107

103 bajty jako funkcja anonimowa, nie licząc F=(ale potrzebujesz tego do przetestowania)

F=l=>alert(l.map((n,y)=>(l.map((n,x)=>Array(n).fill(x==y|0))+'\n').repeat(n))
.join('').replace(/,/g,' '))

Przetestuj w konsoli Firefox / FireBug

F([5,1,1,2,3,1])

Wydajność

1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1


1

Pyth, 31 30

FbQVbjd++*]0Z*b]b*]0--sQbZ)~Zb

Dość naiwny program pobiera dane wejściowe na standardowe wejście. Prawdopodobnie można to bardziej zagrać w golfa;)

Dzięki @Jakube za wskazanie zmarnowanego char

Wypróbuj tutaj


1

Perl, 69

#!perl -na
$j=s/./0 x$&/ger;print+($j|$i.1x$_)=~s/\B/ /gr x($i.=0 x$_,$_)for@F

Wykorzystuje standardowe wejście:

$ perl a.pl <<<"1 2 3"
1 0 0 0 0 0
0 1 1 0 0 0
0 1 1 0 0 0
0 0 0 1 1 1
0 0 0 1 1 1
0 0 0 1 1 1

co dziwne, nie drukuje to dla mnie nowych linii na ideone . Ponadto, zgodnie z tym postem , powinieneś zakodować niestandardowy shebang jako 4 bajty, a nie dwa. możesz to naprawić, nie używając torebki, ale zamiast tego używając flag na tłumaczu i wywołując kod -ezamiast z pliku (zobacz przykłady w tym meta postie). myślę też, że nie potrzebujesz nflagi - według perldoc austawia się ndomyślnie.
Martin Ender

Program ponownie wykorzystuje eol ze standardowego wejścia. Twoja konfiguracja ideone działa po dodaniu. Jeśli chodzi o liczbę znaków, liczę to w ten sposób we wszystkich moich odpowiedziach i widziałem, że inni też to robią. Widziałem wcześniej link, który podlinkowałeś, ale nie rozumiem, co to znaczy „policz różnicę do perl -nl file.pl”. Oryginalne reguły perlgolfa liczą łącznik, ale nie spację, więc 3 znaki w tym przypadku.
nutki

@ MartinBüttner, to wszystko jest dyskusyjna i tak jak podejście randomra daje znacznie krótszy rozwiązanie: -lna //,print join$",map$'==$_|0,@,for@,=map{(++$i)x$_}@F. BTW moja wersja Perla nie ustawia -nsię -a, musi to być najnowszy dodatek.
nutki

1

R, 117 144 137 133 129 123 123 bajtów

W tej chwili rozsądnie gadatliwy. Powinien być w stanie ogolić jeszcze kilka. Zyskałem pewną liczbę bajtów poprawnie formatując, ale zaoszczędziłem trochę na zamianie macierzy na tablicę.

Podziękowania dla Alexa za wskazówkę dotyczącą zamiany sep na s i usunięcia nazwy funkcji.

Całkowicie porzucił tablicę i użył serii powtórzeń do zbudowania każdej linii.

Mimo że Miff został mocno pobity, jego rozwiązanie uświadomiło mi, że mogę całkowicie upuścić s = ''.

function(i){s=sum(i);i=cumsum(i);b=0;for(n in 1:s){d=i[i>=n][1];cat(c(rep(0,b),rep(1,d-b),rep(0,s-d)),fill=T);if(d==n)b=d}}

I test

> (function(i){s=sum(i);i=cumsum(i);b=0;for(n in 1:s){d=i[i>=n][1];cat(c(rep(0,b),rep(1,d-b),rep(0,s-d)),fill=T,s=' ');if(d==n)b=d}})(c(5,1,1,3,1))
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 1
> 

Możesz zapisać 2 bajty, stosując częściowe dopasowanie parametrów funkcji. Wcat() zmień sep=na, s=ponieważ żadne inne rozpoznane parametry dla tej funkcji nie zaczynają się od „s”.
Alex A.

@Alex Dzięki, nie zdawałem sobie z tego sprawy. Wciąż na krzywej uczenia się
MickyT,

Możesz zapisać kolejne 2, usuwając f=. To daje ci obiekt funkcji. Jeśli to zrobisz, musisz po prostu zastrzec, że zostanie to przypisane przy użyciu czegoś takiego jak f=przed uruchomieniem. Nie zdawałem sobie sprawy, że było to uzasadnione w takich konkursach, dopóki nie zobaczyłem Martina Büttnera robiącego to z Ruby.
Alex A.,

1

Partia - 226 bajtów

@echo off&setLocal enableDelayedExpansion&set c=0&for %%a in (%*)do set/ac+=1&for /l %%b in (1,1,%%a)do (set l=&set d=0&for %%c in (%*)do (set/ad+=1&for /l %%d in (1,1,%%c)do if !d!==!c! (set l=!l!1)else set l=!l!0)
echo !l!)

Pobiera dane wejściowe ze stdin ( C:\>script.bat 5 1 1 2 3 1) i dane wyjściowe echa. Niestety nie mogłem uzyskać tego ostatniego echa na tej samej linii, w przeciwnym razie prawdopodobnie mógłbym wywołać całą linię wewnątrzcmd/von/c aby uniknąć konieczności opóźnionego rozszerzania na dłuższą metę.

Ładnie i schludnie - tylko chrząknięcie:

@echo off
setLocal enableDelayedExpansion
set c=0
for %%a in (%*) do (
    set /a c+=1
    for /l %%b in (1,1,%%a) do (
        set l=
        set d=0
        for %%c in (%*) do (
            set /a d+=1
            for /l %%d in (1,1,%%c) do if !d!==!c! (set l=!l!1) else set l=!l!0
        )
        echo !l!
    )
)

1

Haskell, 124

(%)=replicate
d l=fst$foldr(\x(m,n)->(m>>mapM_(\_->putStrLn$unwords$n%"0"++x%"1"++(sum l-n-x)%"0")[1..x],n+x))(return(),0)l

Daje efekt poprzez połączenie działań IO poprzez mapM_i foldr. Funkcjad powinna otrzymać listę ints.


1

K (ngn / k) , 10 bajtów

{x=\:x:&x}

Wypróbuj online!

-19 dzięki ngn ... trzymanie mojego poddania poniżej haha


K (ngn / k) , 29 bajtów

{,/d#',:'-':+\[d:x,0]>\:!+/x}

Wypróbuj online!

edycja: łamie dla 1-elementowego przypadku wejściowego, wymaga pracy

edit1: teraz naprawiony. +4 bajty. gwizd


1
{x=\:x:&x}­­­
ngn

@ng oh daj spokój ...
bazgroły

to wyzwanie zostało omówione w pokoju apl , stamtąd znałem rozwiązanie :) k i j mają tutaj przewagę, ponieważ ich „gdzie” -s ( &w k lub I.in) działa z wektorami int, podczas gdy apl działa tylko z booleanami .
ngn

1

APL (Dyalog Extended) , 5 bajtów

∘.=⍨⍸

Wypróbuj online!

APL wygrywa z J i K z rozszerzoną domeną dla .

Jak to działa

∘.=⍨⍸
       Where; convert to an array that,
          for each element n at index i, has n copies of i
∘.=⍨    Outer product by element-wise equality on self

0

STATA, 155 bajtów

di _r(a)
forv x=1/wordcount($a){
gl b=word($a,`x')
gl c=_N+1
set ob _N+$b
forv y=$c/_N{
g d`y'=_n>=$c
}
}
forv z=1/_N{
replace d`z'=0 if d`z'>1
}
l,noo noh

Czy mogę gdzieś to przetestować online?
Martin Ender,

@ MartinBüttner: O ile mi wiadomo, nie ma kompilatorów online dla Staty, ponieważ jest ona zastrzeżona. To samo dotyczy języków takich jak SAS.
Alex A.

0

Galaretka , 7 bajtów

ĖŒṙ⁼þ`G

Wypróbuj online!

Takie samo podejście jak odpowiedź J.

      G    Grid format
   ⁼þ      a table of whether or not pairs of elements are equal, from
 Œṙ        the run-length decoded
Ė          enumeration of the input,
     `     compared with itself.
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.