Минимально отсортировать список в матрицу

18

Учитывая несортированный список уникальных строго положительных целых чисел, минимально сортируйте его в 2D матрицу. Гарантируется, что входной список будет составной длины, что означает, что выходная матрица не обязательно квадратная, но имеет размер n x mс n,m > 1.

«Минимально сортировать» здесь означает следующее:

  • Сортировать список по возрастанию.
  • Максимально сожмите выходную матрицу - минимизируйте сумму размеров матрицы (например, для 20входных элементов в качестве входных данных требуется матрица a 5x4или 4x5output, а не a 2x10).
  • Уплотните отсортированные числа как можно дальше к верхнему левому углу матрицы, начиная с первого элемента в отсортированном списке.
  • Это можно рассматривать как сортировку списка, затем разрезание его вдоль антидиагоналей матрицы, начиная с верхнего левого.

Примеры:

Для ввода- 1..20вывода используется матрица 5x4 или 4x5 следующим образом:

 1  2  4  7 11
 3  5  8 12 15
 6  9 13 16 18
10 14 17 19 20

 1  2  4  7
 3  5  8 11
 6  9 12 15
10 13 16 18
14 17 19 20

Для ввода- [3, 5, 12, 9, 6, 11]вывода используется 2x3 или 3x2 следующим образом

3  5  9
6 11 12

 3  5
 6  9
11 12

Для ввода [14, 20, 200, 33, 12, 1, 7, 99, 58], выход 3x3 следующим образом

 1   7  14
12  20  58
33  99 200

Для ввода 1..10вывод должен быть 2x5 или 5x2 следующим образом

1 2 4 6  8
3 5 7 9 10

1  2
3  4
5  6
7  8
9 10

Для ввода- [5, 9, 33, 65, 12, 7, 80, 42, 48, 30, 11, 57, 69, 92, 91]вывода используется 5x3 или 3x5 следующим образом

 5  7 11 33 57
 9 12 42 65 80
30 48 69 91 92

 5  7 11
 9 12 33
30 42 57
48 65 80
69 91 92

правила

  • Можно предположить, что ввод соответствует целочисленному типу вашего языка.
  • Вход и выход могут быть заданы любым удобным способом .
  • Либо полная программа или функция приемлемы. Если функция, вы можете вернуть вывод, а не распечатать его.
  • Стандартные лазейки запрещены.
  • Это код-гольф, поэтому применяются все обычные правила игры в гольф, и выигрывает самый короткий код (в байтах).
code-golf  array-manipulation  sorting  matrix 
— AdmBorkBork
источник
1
Ого, слово, которое я не видел со времен линейной алгебры; легко упускается из виду. Мои извенения.
— Волшебная Урна Осьминога
@LuisMendo Добавлен 15тестовый пример элемента.
— AdmBorkBork

Ответы:

10

Желе , 24 22 20 байт

pS€ỤỤs
LÆDżṚ$SÞḢç/ịṢ

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

Сохранено 2 байта благодаря @ Джонатану Аллану .

объяснение

pS€ỤỤs  Helper link. Input: integer a (LHS), integer b (RHS)
p       Cartesian product between [1, 2, ..., a] and [1, 2, ..., b]
 S€     Sum each pair
   Ụ    Grade up
    Ụ   Grade up again (Obtains the rank)
     s  Split into slices of length b

LÆDżṚ$SÞḢç/ịṢ  Main link. Input: list A
L              Length
 ÆD            Divisors
     $         Monadic pair
    Ṛ            Reverse
   ż             Interleave
                 Now contains all pairs [a, b] where a*b = len(A)
      SÞ       Sort by sum
        Ḣ      Head (Select the pair with smallest sum)
         ç/    Call helper link
            Ṣ  Sort A
           ị   Index into sorted(A)
— миль
источник
L%J¬TżṚ$-> LÆDżṚ$Я должен спасти двоих, я думаю
— Джонатан Аллан
Первая ссылка может стать pSÞỤs.
— Деннис
4

Python 2 , 160 158 153 151 байт

-2 байта благодаря Эрику Аутгольферу
-2 байта благодаря мистеру Xcoder

s=sorted(input())
l=len(s)
x=int(l**.5)
while l%x:x+=1
n=1
o=eval(`l/x*[[]]`)
while s:
 for i in range(l/x)[max(0,n-x):n]:o[i]+=s.pop(0),
 n+=1
print o

Попробуйте онлайн! или попробуйте все тестовые случаи

— прут
источник
Я полагаю, вы можете использовать max(0,n-x)для -2 байта.
— г-н Xcoder
4

R 110 95 байт

function(x){n=sum(x|1)
X=matrix(x,max(which(!n%%1:n^.5)))
X[order(col(X)+row(X))]=sort(x)
t(X)}

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

Как это устроено

f <- function(x) {
  n <- sum(x|1)                           # length
  p <- max(which(!n%%1:n^.5))             # height of matrix
  X <- matrix(x, p)                       # initialize matrix
  X[order(col(X) + row(X))] <- sort(x)    # filling the matrix using position distance to the top left corner
  t(X)                                    # probably required by OP
}

Джузеппе сохранил колоссальные 15 (!) Байтов с помощью следующих трюков

  • замена length(x)на sum(x|1)(-1 байт)
  • floor()в :любом случае не требуется, так как округляет (-7)
  • ^.5короче sqrt()(-3)
  • используя col(X) + row(X)вместо outer(приятно!)
  • не мог избавиться, t(X)хотя - разочаровывает;)

Оригинальное решение

function(x){
n=length(x)
p=max(which(!n%%1:floor(sqrt(n))))
X=outer(1:p,1:(n/p),`+`)
X[order(X)]=sort(x)
t(X)}

Это будет выглядеть более причудливо с outerзаменой на row(X)+col(X), но для этого потребуется Xсначала инициализировать выходную матрицу .

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

— Майкл М
источник
2
Очень хорошо! Вы можете получить до 95 байтов
— Джузеппе
1
Возможно, мне удастся использовать что-то из моего решения для связанной задачи, чтобы помочь и здесь.
— Джузеппе
Это действительно тесно связано. Очень хороший подход!
— Майкл М,
3

JavaScript (ES6), 172 байта

l=>(n=l.sort((a,b)=>b-a).length,w=l.findIndex((_,i)=>!(i*i<n|n%i)),a=l=>[...Array(l)],r=a(n/w).map(_=>a(w)),a(w+n/w).map((_,x)=>r.map((s,y)=>x-y in s&&(s[x-y]=l.pop()))),r)

объяснение

l=>(                                // Take a list l as input
 l.sort((a,b)=>b-a),                // Sort it
 n=l.length,                        // Get the length n
 w=l.findIndex((_,i)=>!(i*i<n|n%i)),// Find the first integer w where w >= √n and n % w = 0
 a=l=>[...Array(l)],                // Helper function a
 r=a(n/w).map(_=>a(w)),             // Create the grid r of size w, n/w
 a(w+n/w).map((_,x)=>               // For every x from 0 to w + n/w:
  r.map((s,y)=>                     //  For every row s in r:
   x-y in s&&(                      //   If the index x-y is in s:
    s[x-y]=l.pop()))),              //    Set s[x-y] to the next element of l
 r)                                 // Return r

Тестовые случаи

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

— Герман Л
источник
3

Perl 5 , 132 байта

sub d{$,=0|sqrt(@_=sort{$a-$b}@_);--$,while@_%$,;map{$r++,$c--for@_/$,..$c;$a[$r++][$c--]=$_;$c=++$i,$r=0if$r<0||$c<0||$r>=$,}@_;@a}

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

Подпрограмма возвращает двумерный массив. Ссылка TIO включает код нижнего колонтитула для отображения результатов теста.

— Xcali
источник
3

Октава , 151 байт

function f(v)n=floor(sqrt(l=nnz(v)));while i=mod(l,n);++n;end;A=nan(m=l/n,n);for k=[1:m 2*m:m:l];do A(k)=sort(v)(++i);until~mod(k+=m-1,m)|k>l;end;A'end

Использование трех различных типов конструкций цикла.

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

раскатали:

function f(v)
    n = floor(sqrt(l=nnz(v)));

    while i = mod(l,n);
        ++n;
    end;

    A = nan(m=l/n, n);

    for k = [1:m 2*m:m:l];
        do
            A(k) = sort(v)(++i);
        until ~mod(k+=m-1, m) | k>l;
    end;

    A'
end
— Steadybox
источник
Хороший ответ! Почему 'в nnz(v') необходимости?
— Луис Мендо
1
@ LuisMendo Спасибо! Оказывается, 'это не требуется, если я оберну выражение диапазона, например 1:20, в квадратные скобки ( [1:20]) на месте вызова (чтобы сделать его фактическим вектором). Очевидно, что в Octave оператор двоеточия создает не вектор , а константу диапазона, которая занимает гораздо меньше места в памяти. По какой-то причине nnz()не работает с этим типом, но транспонирование константы диапазона дает вектор, поэтому он работает с апострофом. Вызов функции с фактическим вектором устраняет необходимость в '.
— Steadybox
1
Спасибо за объяснение. Я не знал, что у выражения выражения диапазона было такое особое отношение в Октаве. В любом случае, тот факт, что он не создает вектор для эффективности памяти, должен быть понятен программисту. То есть, тот факт , что nnz(1:20)не работает, вероятно, ошибка ( max(1:20), и sum(1:20)т.д. являются действительными).
— Луис Мендо
1
Мы должны сообщить об этом . Это может повлиять на другие функции, чем nnz. Ты хочешь сделать это сам или мне?
— Луис Мендо
1
Об этом сообщает . Это также повлияло на MATL; сейчас решено . Спасибо, что заметили это!
— Луис Мендо
0

Шелуха , 15 байт

ḟȯΛ≤Σ∂MCP¹→←½ḊL

Это работает грубой силой, поэтому более длительные тестовые случаи могут истечь. Попробуйте онлайн!

объяснение

ḟȯΛ≤Σ∂MCP¹→←½ḊL  Implicit input, a list of integers x.
              L  Length of x (call it n).
             Ḋ   List of divisors.
            ½    Split at the middle.
          →←     Take last element of first part.
                 This is a divisor d that minimizes d + n/d.
        P¹       List of permutations of x.
      MC         Cut each into slices of length d.
ḟ                Find the first of these matrices that satisfies this:
     ∂            Take anti-diagonals,
    Σ             flatten them,
 ȯΛ≤              check that the result is sorted (each adjacent pair is non-decreasing).
— Zgarb
источник
0

JavaScript (ES6), 233 байта

f=s=>{l=s.length;i=Math.sqrt(l)|0;for(;l%++i;);p=(x)=>(x/i|0+x%i)*l+x%i;m=[...Array(l).keys()].sort((x,y)=>p(x)-p(y));return s.sort((a,b)=>a-b).map((x,i)=>m.indexOf(i)).reduce((a,b,d,g)=>!(d%i)?a.concat([g.slice(d,d+i)]):a,[])}

объяснение

f=s=>{                         // Take array `s` of numbers as input
  l=s.length                   // short-hand for length
  i=Math.sqrt(l)|0             // = Math.floor(Math.sqrt(l))
  for(;l%++i;);                // i = width           
  j=l/i                        // j = height

  p=(x)=>(x/i|0+x%i)*l+x%i     // helper to calculate (sort-of) ~manhattan
                                 // distance (horizontal distance weighted
                                 // slightly stronger), from top-left corner
                                 // to the number x, if numbers 0,...,l are
                                 // arranged left-to-right, top-to-bottom
                                 // in an l=i*j grid

  m=[...Array(l).keys()]         // range array
  .sort((x,y)=>p(x)-p(y)),       // manhatten-sorted, sort-of...

  return s.sort((a,b)=>a-b)      // sort input array by numbers,
    .map((x,i,w)=>w[m.indexOf(i)])    // then apply inverse permutation of the
                                 // range-grid manhatten-sort mapping.
    .reduce(                     // slice result into rows
      (a,b,d,g)=>!(d%i)?a.concat([g.slice(d,d+i)]):a
      ,[]
     )
}
— trollkotze
источник
0

Java 10, 199 188 186 байт

a->{int j=a.length,m=0,n,i=0,k=0;for(n=m+=Math.sqrt(j);m*n<j;n=j/++m);var R=new int[m][n];for(java.util.Arrays.sort(a);i<m+n;i++)for(j=0;j<=i;j++)if(i-j<n&j<m)R[j][i-j]=a[k++];return R;}

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

На основании моего ответа здесь .

Объяснение:

a->{                        // Method with int-array parameter and int-matrix return-type
  int j=a.length,           //  Length of the input-array
      m=0,n,                //  Amount of rows and columns
      i=0,k=0;              //  Index integers
   for(n=m+=Math.sqrt(j);   //  Set both `m` and `n` to floor(√ `j`)
       m*n<j;               //  Loop as long as `m` multiplied by `n` is not `j`
       n=j/++m);            //   Increase `m` by 1 first with `++m`
                            //   and then set `n` to `j` integer-divided by this new `m`
   var R=new int[m][n];     //  Result-matrix of size `m` by `n`
   for(java.util.Arrays.sort(a);
                            //  Sort the input-array
       i<m+n;)              //  Loop as long as `i` is smaller than `m+n`
     for(j=0;j<=i;j++)      //   Inner loop `j` in range [0,`i`]
       if(i-j<n&j<m)        //    If `i-j` is smaller than `n`, and `j` smaller than `m`
                            //    (So basically check if they are still within bounds)
         R[j][i-j]=a[k++];  //     Add the number of the input array at index `k`,
                            //     to the matrix in the current cell at `[j,i-j]`
  return R;}                //  Return the result-matrix
— Кевин Круйссен
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.