Распечатать блочно-диагональную матрицу

27

Вот простой кодовый гольф размером с укус (в байтах?): Учитывая непустой список натуральных чисел меньше 10, выведите диагонально-блочную матрицу, где список указывает размер блоков по порядку. Блоки должны состоять из натуральных чисел меньше 10. Так что, если вы задали в качестве входных данных

[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

или

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

или что-то типа того. Элементы в матрице должны быть разделены (одиночными) пробелами, а строки разделены (одиночными) переводами строк. На каждой линии не должно быть пробелов в начале или в конце. Вы можете или не можете печатать завершающий перевод новой строки.

Вы можете написать функцию или программу, используя ввод через STDIN (или ближайшую альтернативу), аргумент командной строки или аргумент функции, в любой удобной строке или формате списка (если только они не были предварительно обработаны). Однако результат должен быть напечатан в STDOUT (или ближайшую альтернативу), а не, скажем, возвращен из функции, скажем.

Вы не должны использовать какие-либо встроенные функции, предназначенные для создания блочно-диагональных матриц.

Это код гольф, поэтому выигрывает самое короткое представление (в байтах).

Leaderboards

Я ожидаю, что основанные на массивах языки (такие как J и APL) будут иметь преимущество, но я не хочу, чтобы это отговаривало людей пытаться делать то, что они могут, на своем языке. Итак, вот фрагмент стека для генерации как регулярной таблицы лидеров, так и обзора победителей по языкам. Так почему бы не попытаться найти место на последнем?

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

# Language Name, N bytes

где Nразмер вашего представления. Если вы улучшите свой счет, вы можете сохранить старые результаты в заголовке, вычеркнув их. Например:

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

Показать фрагмент кода

code-golf array-manipulation Мартин Эндер
источник

Ответы:

20

J 7 байт

Спасибо за FUZxxl за 2-байтовое улучшение.

Языки на основе массива должны учитываться здесь в другом соревновании, поскольку они имеют огромное преимущество. :)

   =/~@#<\

   (=/~@#<\) 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

Еще один 7-байтовый подход:

#]=@##\

Пояснения к старой версии ([:=/~]#<\):

Первый шаг - создание nфрагмента похожих вещей (например, чисел) для каждого элемента списка n. Они должны отличаться от других элементов ». Например, использование натуральных чисел 3 1 1 2становится 0 0 0 1 2 3 3.

Чтобы сэкономить на байтах, мы используем префиксы в штучной упаковке списка:

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

С помощью =/~глагола мы создаем таблицу продуктов Декарта с этими коробочными префиксами, и каждая ячейка будет, 1если две записи равны в 0противном случае.

randomra
источник
2
Я не думаю, что круглые скобки имеют [:=/~]#<\ значение для вашей оценки. Также =/~@#<\ за два лишних байта сбриваются.
FUZxxl
«Однако результат должен быть напечатан в STDOUT (или ближайшей альтернативе), а не, скажем, возвращен из функции ». Вам, вероятно, нужен либо явный ввод (так что это не просто функция), либо явный вывод.
Marinus
@marinus J выводит результат выражения в стандартный вывод, если он не связан с переменной.
FUZxxl
@FUZxxl: да, но (=/~@#<\)это просто функция. Вы должны на самом деле применить это к чему-то, чтобы получить выражение, поэтому вам понадобится явный ввод ( ".1!:1[1), или, если вы хотите передать функцию, эта функция должна фактически напечатать значение, а не просто вернуть его (например, echo@или что-то в этом роде). ).
Марин
=/~&I.­­­­­­­
нгн
11

APL, 10

∘.=⍨∆/⍋∆←⎕

Пример:

      ∘.=⍨∆/⍋∆←⎕
⎕:
      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

Объяснение:

  • ∆←⎕: читать ввод, хранить в ∆.
  • ⍋∆: найти перестановку, которая сортирует ∆(это дает уникальное значение для каждого значения на входе)
  • ∆/: для каждого из этих уникальных значений повторите его Nраз, где Nсоответствующее значение во входных данных
  • ∘.=⍨: создать матрицу, сравнивающую каждое значение в этом списке с другими значениями.
Мэринус
источник
Чтобы проверить это http://tryapl.org, вы можете использовать dfn {∘.=⍨⍵/⍋⍵}, так как сайт фильтрует все варианты использования ⎕(кроме ⎕IOи тому подобное).
FUZxxl
1
@FUZxxl: там написано: «Однако результат должен быть напечатан в STDOUT (или ближайшей альтернативе), а не, скажем, возвращен из функции, скажем .», Поэтому {∘.=⍨⍵/⍋⍵}недействителен. Вам понадобится {⎕←∘.=⍨⍵/⍋⍵}, который не только стоит два символа, но все равно не будет работать на TryAPL. (И вообще, TryAPL слишком ограничен, чтобы быть полезным.)
marinus
Если он должен распечатать результат, вам не нужно в ⎕←любом случае, даже без dfn?
FUZxxl
@FUZxxl: нет, вывод выражения печатается автоматически, если с ним ничего не сделано.
Marinus
Ах я вижу. У меня сложилось впечатление, что это происходит только тогда, когда вы используете переводчика в интерактивном режиме.
FUZxxl
8

R 69 63

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

Прецедент:

(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

Внешняя функция выполняет большую часть работы здесь, тогда это просто случай, когда результат выглядит правильно - спасибо @Vlo за помощь в этом

размолвка
источник
Очень хорошее решение
MickyT
Отличное решение. Никогда не думал об использовании -/+для принуждения к логическому. Сохраните несколько байтов function(x)write(+outer(i<-rep(1:length(x),x),i,"=="),1,sum(x))63
Vlo
6

Python 3, 103 97 82 78 76 байт

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

Использование splat для использования разделяющей пространство природы printс небольшим количеством рекурсии.

Sp3000
источник
6

Руби, 86 90 83 байта

Мой первый в мире гольф!

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

Получает массив с целыми числами, печатает ожидаемый результат:

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

Редактировать:

Спасибо Мартину Бюттнеру за помощь в сокращении некоторых вещей!

rorlork
источник
1
Вы можете сохранить еще несколько символов: ->(l)может быть ->l. mapкороче each. .join(" ")можно сократить до *" ".
Мартин Эндер
6

Matlab, 60 54 байта

Это было бы специальное поле Matlab IF бы мы могли использовать встроенные функции ...

Спасибо @sanchises за исправление ошибки, которую я пропустил.

c=0;a=input('');for A=a;v=c+1:c+A;d(v,v)=1;c=c+A;end;d
flawr
источник
Wow, это было до сих пор, когда я заметил, что этот фрагмент JS на самом деле производит таблицу лидеров !!! Как я никогда этого не замечал ??? Спасибо за указание на это =)
flawr
Я точно знаю? Это действительно здорово!
Алекс А.
1
Я собирался опубликовать почти тот же ответ :-)
Луис Мендо
Точно такой же или немного другой? =) (Ну, кроме имен переменных.)
flawr
Слишком похоже на меня, чтобы опубликовать это :-)
Луис Мендо
6

Matlab, 53 байта

Хотя он всего на один символ короче другого фрагмента Matlab, я подумал, что код достаточно отличается, чтобы дать новый ответ:

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

Основной трюк, конечно, заключается в индексации границ, но это в сочетании с использованием endв качестве переменной делает его более компактным.

Деннис Джаэруддин
источник
1
Черт, я потратил полчаса, пытаясь поиграть в гольф, end+1:end+vчтобы избавиться от «встречной» переменной, и я не думал об этом решении.
Sanchises
Действительно, как упомянул @Geobits, попытка анонимного редактирования blkdiagнарушит требования. Просто для справки, я все равно blkdiag(A,ones(i))
расскажу
4

CJam, 21

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

Попробуйте это на http://cjam.aditsu.net/

Объяснение:

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
aditsu
источник
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)

Отслеживает крайний левый индекс блока как sи делает xзаписи после него 1, где xнаходится текущий размер блока. Эта строка затем печатается xраз. Python 3 необходимо сделать print(*r).

XNOR
источник
Это на один символ короче, чтобы просто выразить rкак [0]*s+[1]*x+[0]*(sum(l)-s-x), но я все еще ищу лучший способ.
xnor
4

Haskell, 118 116 байтов

(#)=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

Использование: f [2,1,1,3]

Выход:

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

Как это работает:

[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
Ними
источник
Вы можете сохранить два байта (h,e:t)<-map(`splitAt`i)[0..length i-1], так nкак не используется вне letпривязки.
Згарб
@Zgarb: хорошая находка. Благодарность!
Ними
3

Pyth, 23 21 байт

GitHub хранилище для Pyth

Ju+G*]GHQYFNJjdmsqdNJ

Ввод представляет собой список целых чисел, например [3, 1, 1, 2]. Попробуйте онлайн: Pyth Compiler / Executor

Использует довольно похожую идею как J-код Рандомера. Первая часть кодаJu+G*]GHQY генерирует nчасти схожих вещей. Для примера ввода [3, 1, 1, 2]результат выглядит следующим образом:

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

Сначала три идентичных элемента, затем один элемент, затем снова один элемент и в конце два идентичных элемента. 

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

Вторая часть кода сравнивает элементы декартового произведения и печатает его. 

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)
Jakube
источник
3

C ++, 294 байта

Используется компилятор - 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";}}

Объяснение -: 

#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

К, 30 байт

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

В основном украл ответ Маринус

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
tmartin
источник
2

Ява, 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;}}

Потребитель, который принимает список целых чисел.

Читаемая версия, с шаблоном кода:

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

Вызвать используя:

List list = Arrays.asList(5, 1, 1, 2, 3, 1);
c.accept(list);
Ypnypn
источник
2

Python 2, 163 114 байт

Гнибблер играл в эту кучу.

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]))
KSFT
источник
3
как насчет print" ".join("01"[i==j]for j in r(l(h))for x in r(h[j]))?
Гнибблер
А ха ! Я думал, что смогу сделать что-то подобное.
KSFT
Кажется, это печатает только одну строку каждого блока.
xnor
@xnor Ты прав; Я починил это.
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)
feersum
источник
Разве это не заканчивается с ошибкой?
xnor
@xnor да, это так!
feersum
1
@feersum Это разрешено? Я не вижу мета-пост по этому вопросу. Что ты думаешь, Мартин? Если это разрешено, Sp3000 может сохранить 6 символов, избавившись от andкороткого замыкания.
xnor
@xnor Ошибка завершает программу или только вызов функции? Если это завершает программу, то нет, я не думаю, что это разрешено. Я высказал свое мнение по этому поводу здесь, на мета . Я также думаю, что если бы feersum придерживался мнения, что это совершенно законно, он сказал бы это в своем ответе, вместо того чтобы надеяться, что никто этого не заметит.
Мартин Эндер
@ MartinBüttner Завершите программу, если я понимаю, о чем вы спрашиваете. Если бы вы должны были сделатьf([1,2,3]);print("Done") , ошибка завершит работу программы после того, как она напечатает матрицу блоков, и она не доберется до печати «Готово».
xnor
2

JavaScript (ES6), 103 107

103 байта как анонимная функция, не считая F=(но вам нужно это проверить)

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

Тест в консоли Firefox / FireBug

F([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
edc65
источник
2

Октава, 49 41 байт

@(a)(c=repelems(b=1:length(a),[b;a]))'==c
alephalpha
источник
1

Пиф, 31 30

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

Довольно наивная программа, принимает входные данные в stdin. Это, вероятно, может быть в гольф больше;)

Спасибо @Jakube за указание на потраченный впустую символ

Попробуй здесь

FryAmTheEggman
источник
1

Perl, 69

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

Использует стандартный ввод:

$ 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
nutki
источник
странно, это не печатает новые строки для меня на ideone . также, согласно этому посту, вы должны кодировать пользовательский шебанг как 4 байта, а не два. Вы можете исправить это, не используя shebag, а вместо этого используя флаги интерпретатора и вызывая код -eиз файла, а не из файла (см. примеры в этом мета-посте). также, я думаю, вам не нужен nфлаг - согласно perldoc, aустанавливается nнеявно.
Мартин Эндер
Программа повторно использует eol из стандартного ввода. Ваша установка ideone работает, когда вы добавляете ее. Что касается количества персонажей, я считаю это во всех своих ответах, и я видел, как другие тоже так делают. Я видел пост, на который вы ссылались ранее, но я не понимаю, что значит «посчитать разницу до perl -nl file.pl». Оригинальные правила Perlgolf будут считать дефис, но не пробел, поэтому 3 символа в этом случае.
Nutki
@ MartinBüttner, это все спорно так или иначе , как подход randomra дает гораздо более короткое решение: -lna //,print join$",map$'==$_|0,@,for@,=map{(++$i)x$_}@F. Кстати, моя версия Perl не устанавливается -nс -a, это должно быть последнее добавление.
nutki
1

R, 117 144 137 133 129 123 байта

Разумно многословно на данный момент. Должен быть в состоянии побриться еще немного. Получил несколько байтов, отформатировавших его правильно, но сохранил некоторые, заменяя матрицу для массива.

Спасибо Алексу за подсказку о замене sep на s и удалении имени функции.

Полностью отбросил массив и использовал серию повторений для построения каждой строки.

Несмотря на то, что Мифф добился успеха, его решение заставило меня осознать, что я могу вообще отказаться от 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}}

И тест

> (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
>
MickyT
источник
Вы можете сохранить 2 байта, используя частичное совпадение параметров функции. В cat(), измените sep=на, s=так как никакие другие распознанные параметры для этой функции не начинаются с "s".
Алекс А.
@ Алекс Спасибо, не понял этого. Все еще на кривой обучения
MickyT
Вы можете сохранить еще 2, удалив f=. Это дает вам функциональный объект. Если вы это сделаете, вам просто нужно оговорить, что он будет назначен, используя что-то вроде этого, f=прежде чем запускать его. Я не осознавал, что это было законно в подобных конкурсах, пока не увидел, как Мартин Бюттнер делает это с Руби.
Алекс А.
1

Пакет - 226 байт

@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!)

Принимает ввод из stdin ( C:\>script.bat 5 1 1 2 3 1) и вывод echo. К сожалению, я не мог получить последнее эхо в одной и той же строке, иначе я мог бы вызвать всю строку внутри, cmd/von/cчтобы избежать необходимости отложенного расширения в длинном пути.

Красиво и аккуратно - ничего, кроме ворчливой работы:

@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!
    )
)
unclemeat
источник
1

Хаскелл, 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

Производит вывод, комбинируя действия ввода-вывода через mapM_и foldr. Функция dдолжна содержать список целых чисел.

Jmac
источник
1

K (нгн / к) , 10 байтов

{x=\:x:&x}

Попробуйте онлайн!

-19 спасибо нгн ... держу мое подчинение ниже хаха

К (нгн / к) , 29 байт

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

Попробуйте онлайн!

редактировать: разрывы для 1-элементного ввода, требуется работа

edit1: теперь исправлено. +4 байта. бу

каракули
источник
1
{x=\:x:&x}­­­
нгн
@ngn, да ладно ...
каракули
эта проблема обсуждалась в комнате apl , я знал решение оттуда :) k и j имеют здесь преимущество, потому что их "where" -s ( &в k или I.в j) работают с векторами int, в то время как apl ⍸работает только с логическими значениями ,
нг
1

APL (Dyalog Extended) , 5 байт

∘.=⍨⍸

Попробуйте онлайн!

APL выигрывает у J и K с расширенным доменом для ⍸ .

Как это работает

∘.=⍨⍸
    ⍸  ⍝ 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 байт

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
bmarks
источник
Могу ли я где-нибудь проверить это онлайн?
Мартин Эндер
@ MartinBüttner: Насколько я знаю, онлайн-компиляторов для Stata не существует, поскольку она является частной. То же самое касается языков, таких как SAS.
Алекс А.
0

Желе , 7 байт

ĖŒṙ⁼þ`G

Попробуйте онлайн!

Тот же подход, что и у 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.
Несвязанная строка
источник