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

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
источник
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 ⍸работает только с логическими значениями ,
— нг
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.
— Алекс А.
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.