Вызов:

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

Пример:

Input:            [123, 478, -904, 62778, 0, -73, 8491, 3120, 6458, -7738, 373]
Possible outputs: [8491, -904, 62778, 478, -7738, 6458, 373, -73, 3120, 123, 0]
                  [8491, -904, 62778, 478, -7738, 6458, -73, 373, 3120, 123, 0]

Зачем? Вот соответствующие цифры, по которым были отсортированы числа:

Output:
[8491,  -904,  62778,   478,     -7738,   6458,  373,   -73,   3120,      123,     0  ]

Relevant digits they were sorted on:
[[9,8], [9,4], [8,7,6], [8,7,4], [8,7,3], [8,6], [7,3], [7,3], [3,2,1,0], [3,2,1], [0]]

Правила соревнований:

Мы игнорируем дублирующиеся цифры, поэтому 478и -7738будем упорядочивать как 478, -7738, потому что самые большие цифры есть [8,7,4]и [8,7,3], а не [8,7,4]и [8,7,7,3].
Если несколько номеров имеют одинаковые цифры, их порядок может быть любым. Таким образом, 373и -73могут быть отсортированы как оба 373, -73или -73, 373(цифры [7,3]для обоих этих чисел).
Если номер не содержит больше цифр для проверки, он будет помещен в конце соответствующих номеров. Так 123и 3120будет отсортировано 3120, 123, так как самые большие цифры [3,2,1]такие же, но 0идут раньше none.
Можно предположить, что все числа на входе находятся в диапазоне [-999999,999999].
В качестве результата достаточно одного из возможных выходных данных, но вы можете вывести все возможные выходные данные, где подсписки могут быть в любой перестановке, если хотите (хотя я сомневаюсь, что это сохранит байты на любом языке).

Основные правила:

Это код-гольф , поэтому выигрывает самый короткий ответ в байтах.
Не позволяйте языкам кода-гольфа отговаривать вас от публикации ответов на языках, не относящихся к кодексу. Попробуйте придумать как можно более короткий ответ для «любого» языка программирования.
Применяются стандартные правила к вашему ответу с правилами ввода / вывода по умолчанию , поэтому вы можете использовать STDIN / STDOUT, функции / метод с правильными параметрами и типом возврата, полные программы. Ваш звонок.
По умолчанию лазейки запрещены.
Если возможно, добавьте ссылку с тестом для вашего кода (т.е. TIO ).
Кроме того, добавление объяснения для вашего ответа настоятельно рекомендуется.

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

Input:            [123, 478, -904, 62778, 0, -73, 8491, 3120, 6458, -7738, 373]
Possible outputs: [8491, -904, 62778, 478, -7738, 6458, 373, -73, 3120, 123, 0]
                  [8491, -904, 62778, 478, -7738, 6458, -73, 373, 3120, 123, 0]

Input:            [11, -312, 902, 23, 321, 2132, 34202, -34, -382]
Possible outputs: [902, -382, 34202, -34, -312, 321, 2132, 23, 11]
                  [902, -382, 34202, -34, 2132, -312, 321, 23, 11]
                  etc. The sublist [-312, 321, 2132] can be in any permutation

Input:            [9, 44, 2212, 4, 6, 6, 1, 2, 192, 21, 29384, 0]
Possible outputs: [29384, 192, 9, 6, 6, 4, 44, 2212, 21, 2, 1, 0]
                  [29384, 192, 9, 6, 6, 44, 4, 2212, 21, 2, 1, 0]
                  etc. The sublists [4, 44] and [2212, 21] can be in any permutation

Input:            [44, -88, 9, 233, -3, 14, 101, 77, 555, 67]
Output:           [9, -88, 67, 77, 555, 14, 44, 233, -3, 101]

— Кевин Круйссен
источник

6

05AB1E , 5 байтов

ΣêR}R

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

объяснение

Σ  }    # sort input by
 ê      # its sorted unique characters
  R     # reversed (to sort descending)
    R   # reverse the result (to sort descending)

— Emigna
источник

7

R , 97 95 байт

function(x)x[rev(order(sapply(Map(sort,Map(unique,strsplit(paste(x),"")),T),Reduce,f=paste0)))]

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

Эта проблема, кажется, была пессимизирована для R. Объяснение оригинальной версии (начните с 1. и продолжайте):

f <- function(x) {
  x[                                                  # 8. Input vector in
    rev(                                              # 7. Reversed
        order(                                        # 6. Lexicographical order
              sapply(                                 # 5. Paste....
                     Map(sort,                        # 4. Sort each using...
                              Map(unique,             # 3. Deduplicate each
                                  strsplit(           # 2. Split each string into characters
                                           paste(x),  # 1. Coerce each number to string
                                           "")),      
                         T),                          # 4. ...descending sort.
                     paste,collapse="")               # 5. ...back into strings
              )
        )
    ]
}

— НГМ
источник

6

Perl 6 , 36 34 33 31 байт

-1 байт благодаря Джо Кингу
-2 байт благодаря Филу Н

*.sort:{sort 1,|set -<<m:g/\d/}

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

объяснение

       {                      }  # Map each number, e.g. -373
                       m:g/\d/  # Extract digits: (3, 7, 3)
                    -<<  # Negate each digit: (-3, -7, -3)
                set  # Convert to set to remove duplicates
               |  # Pass as list of pairs: (-3 => True, -7 => True)
             1,  # Prepend 1 for "none": (1, -3 => True, -7 => True)
        sort  # Sort (compares 1 and pair by string value): (-7 => True, -3 => True, 1)
*.sort:  # Sort lexicographically

— nwellnhof
источник

1

Ницца! -2 байта для замены m:g/\d./на .abs.comb: tio.run/…

— Phil H

6

Python 2 , 60 55 54 байта

-1 байт благодаря Джонасу Аусявичюсу .

def f(l):l.sort(cmp,lambda n:sorted(set(`n`))[::-1],1)

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

Ungolfed

def f(l):
  l.sort(        # Sort the list in place
    cmp = cmp,   # ... compare with the builtin function cmp
    key = k,     # ... on the function k
    reverse = 1  # ... in reverse
  )              # As the arguments are used in the right order, no names are necessary.

k = lambda n:sorted( # sort  
  set(`n`)           # ... the set of digits
  )[::-1]            # reverse the result
                     # As '-' is smaller than the digits,
                     # it will be sorted to the back and ignored for sorting

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

— овс
источник

5

Noneможно заменить cmpна sortфункцию

— Йонас Аусявичюс

Я думаю, что [:: - 1] можно обменять на двойное отрицание.

— DonQuiKong

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

— овс

@JonasAusevicius Большое спасибо.

— овс

5

Python 2 , 58 60 байт

lambda a:sorted(a,key=lambda x:sorted(set(`x`))[::-1])[::-1]

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

— Йонас Аусявичюс
источник

5

Брахилог , 9 байт

{ȧdṫo₁}ᵒ¹

Примечание: из-за того, как упорядочение работает в брахилоге, оно не работает с числом правильно. Это исправлено путем приведения числа к строке ( ṫ) стоимостью 1 байт.

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

— Kroppeb
источник

2

Что вы подразумеваете под « Из-за того, как порядок в брахилоге работает, он не работает так, как задумано ».? Я перепробовал все четыре тестовых примера, и это дает правильные результаты (если я случайно не посмотрел что-то).

— Кевин Круйссен

@KevinCruijssen ṫ(в строку) решает проблему. Упорядочивание цифр по убыванию числа работает следующим образом. Порядок от наименьшего к большему, затем обратный. Проблема заключается в том, что число 3120упорядоченный от наименьшего до наибольшего это 0123который равен , 123который отменил это 321и не3210

— Kroppeb

2

Ах, хорошо, так что ваш текущий код работает из-за добавления toString ( ṫ). Как упомянул @Arnauld, я думал, что ваш комментарий означает, что ваш текущий код не работает. Возможно, было бы лучше упомянуть это как: « Это могло бы быть 8 байтов, удаляя ṫ(toString), но, к сожалению, это не работает должным образом из-за того, как упорядочение работает в Brachylog. »

— Кевин Круйссен

Глядя на то, что я написал, кажется, что мой мозг отвлекся на середину. Починил это.

— Кроппеб

5

Pyth, 7 6 байтов

-1 байт от @Sok

_o_{S`

Pyth, который использует только печатный ASCII, находится здесь в невыгодном положении. Оптимально закодированные это были бы 6*log(95)/log(256) = 4.927байты, побеждая 05AB1E.

Разъяснение:

 o              Sort the implicit input by lambda N:
  _               reversed
   {               uniquified
    S               sorted
     '               string representation [of N]
_               then reverse the result.

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

— lirtosiast
источник

2

Завершающий конец Nможно опустить, чтобы сохранить 1 байт - все функции лямбда-типа определяют наличие основной лямбда-переменной, если в конце отсутствуют какие-либо аргументы. Примеры включают в себя mвывод d, fвывод T, uвывод G...

— Сок

4

Желе , 8 байт

ADṢUQµÞU

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

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

ADṢUQµÞU  Main link (monad). Input: integer list
     µÞU  Sort by (reversed):
AD        Absolute value converted to decimal digits
  ṢUQ     Sort, reverse, take unique values

— фонтанчик для питья
источник

2

Я только что реализовал это, а затем нашел ваш пост. Я пошел с обычными Ṛреверсами, а не с переворачиванием U. Заметьте, однако, что вам не нужна Dсортировка т.к. Ṣ, реализована с помощью iterable(z, make_digits=True)вызова внутри. Так что было AṢQṚµÞṚна 7.

— Джонатан Аллан

3

MathGolf , 7 6 байтов

áÉ░▀zx

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

объяснение

Посмотрев на решение Emigna 05AB1E, я обнаружил, что мне не нужен абсолютный оператор (и мой предыдущий ответ был фактически неверным из-за этого оператора). Теперь основное отличие состоит в том, что я преобразую в строку и получаю уникальные символы вместо использования 1-байтового оператора в 05AB1E.

áÉ      Sort by the value generated from mapping each element using the next 3 instructions
  ░     Convert to string
   ▀    Get unique characters
    z   Sort reversed (last instruction of block)
     x  Reverse list (needed because I don't have a sort-reversed by mapping)

— maxb
источник

3

Japt , 12 байт

ñ_a ì â ñnÃw

Все тесты

Объяснение:

ñ_        Ãw    :Sort Descending by:
  a             : Get the absolute value
    ì           : Get the digits
      â         : Remove duplicates
        ñn      : Sort the digits in descending order

— Камил Дракари
источник

3

Haskell , 54 52 байта

import Data.List
f=r.sortOn(r.sort.nub.show);r=reverse

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

— Мартин Лютке
источник

Определение r=reverseсохраняет два байта. Мы также разрешаем анонимные функции, поэтому f=их не нужно считать.

— Лайкони

Я перенес импорт и f = в заголовок TIO. Это нормально?

— Мартин Лютке

Тот же счетчик байтов, но, возможно, представляет интерес f=r$r id.nub.show;r=(reverse.).sortOn.

— Лайкони

1

Импорт действительно должен быть посчитан.

— Лайкони

2

Возможно, вы захотите взглянуть на наше Руководство по правилам игры в гольф на Хаскелле .

— Лайкони

3

Stax , 6 7 байт

èó≥ü≤♥¥

Запустите и отладьте его

— рекурсивный
источник

Это, кажется, дает неправильные результаты. Например, в тестовом случае вашего TIO он выводит -904 8491 478 62778 6458 -7738 -73 373 123 3120 0вместо предполагаемого 8491 -904 62778 478 -7738 6458 373 -73 3120 123 0или 8491 -904 62778 478 -7738 6458 -73 373 3120 123 0. Этот тестовый пример также используется в примере и для объяснения правил, поэтому я хотел бы взглянуть на это, чтобы лучше понять его. Кажется, вы сортируете только одну большую цифру один раз, без каких-либо других правил?

— Кевин Круйссен

@KevinCruijssen: Да, мои извинения. Я неправильно прочитал формулировку проблемы. Я настроил программу для удовлетворения заявленных требований. Эта программа принимает входные целые числа в виде строк в кавычках. Обычно это приемлемо, но в противном случае мне может понадобиться добавить еще один байт.

— рекурсивный

Хорошо выглядит сейчас, +1 от меня. И да, ввод в виде строк вполне подойдет.

— Кевин Круйссен

3

APL (Dyalog Extended) , 19 байт

{⍵[⍒∪¨(∨'¯'~⍨⍕)¨⍵]}

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

Исправлено по стоимости +2 байта благодаря OP.

— Zachary
источник

Я думаю, что вы пропускаете «uniquify» где-то? Если я попробую пример тестового примера в вашем TIO, например, ¯7738помещается раньше 478, но это должно быть после него: цифры [8,7,4]идут перед цифрами [8,7,3].

— Кевин Круйссен

Спасибо, @KevinCruijssen

— Zacharý

3

C (gcc) , 114 111 109 байтов

a;v(n){n=n<0?-n:n;for(a=0;n;n/=10)a|=1<<n%10;n=a;}c(int*a,int*b){a=v(*a)<v(*b);}f(a,n)int*a;{qsort(a,n,4,c);}

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

Объяснение:

f () использует qsort () для сортировки предоставленного массива на месте. Использование функции сравнения c () для сравнения чисел, которая оценивает числа с помощью v (). v () вычисляет большее число, если в параметре присутствуют большие цифры.

[Правка 1] Улучшено на 3 байта. 2 байтовых кредита Кевину. Благодарность

[Правка 2] Улучшено еще 2 байта. Кредиты гастропнеру. Благодарность

— GPS
источник

1

Вы можете играть n>0в гольф, nя думаю, в вашем цикле вашего метода v.

— Кевин Круйссен

Список аргументов f () int*a,nможно сократить до int*a.

— Гастропнер

1

Предлагаю for(a=0;n=abs(n);вместоn=n<0?-n:n;for(a=0;n;

— floorcat

2

J , 17 байт

{~[:\:~.@\:~@":@|

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

Объяснение:

                @|    - find the absolute value and
             @":      - convert to string and
         @\:~         - sort down and
       ~.             - keep only the unique symbols
    \:                - grade down the entire list of strings   
  [:                  - function composition
{~                    - use the graded-down list to index into the input

— Гален Иванов
источник

2

JavaScript (SpiderMonkey) , 68 байт

Спасибо за @Arnauld за напоминание, что SpiderMonkey использует стабильную сортировку, поэтому -4 байта для удаления ||-1 .

A=>A.sort((x,y,F=n=>[...new Set(""+n)].sort().reverse())=>F(x)<F(y))

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

JavaScript (Node.js) , 72 байта

A=>A.sort((x,y,F=n=>[...new Set(""+n)].sort().reverse())=>F(x)<F(y)||-1)

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

— Сиеру Асакото
источник

Или 68 байт с помощью SpiderMonkey.

— Арнаулд

1

@ Арнаулд, снова стабильная сортировка; P

— Шиеру Асакото

На самом деле, я думаю, что V8 использует как минимум 2 разных алгоритма сортировки. Кажется, что это стабильно, если размер массива меньше или равен

10

$10$ ,

— Арнаулд

1

@Arnauld V8 использует быструю сортировку до Chrome 70. Алгоритм быстрой сортировки выполняет сортировку вставкой, когда размер массива достаточно мал. А последняя версия Chrome была изменена на стабильную сортировку для соответствия поведению других браузеров (IE / Firefox / Safari).

— тш

2

Java (JDK) , 98 байт

l->l.sort((a,b)->{int r=0,i=58;for(;r==0&i-->48;)r=(b.indexOf(i)>>9)-(a.indexOf(i)>>9);return r;})

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

объяснение

l->                           // Consumer<List<String>>
 l.sort(                      //  Use the incorporated sort method which uses a...
  (a,b)->{                    //   Comparator of Strings
   int r=0,                   //    define r as the result, initiated to 0
       i=58;                  //           i as the codepoint to test for.
   for(;r==0&i-->48;)         //    for each digit codepoint from '9' to '0',
                              //     and while no difference was found.
    r=                        //     set r as the difference between
     (b.indexOf(i)>>9)-       //      was the digit found in b? then 0 else -1 using the bit-shift operator
     (a.indexOf(i)>>9);       //      and was the digit found in a? then 0 else -1.
   return r;                  //    return the comparison result.
  }
 )

Заметка:

Мне нужен способ отображения чисел в любой 0/1или0/-1 .

indexOf имеет приятное свойство, которое он последовательно возвращает -1 для символов, которые не найдены. -1вправо на любое число всегда -1. Любое положительное число, смещенное вправо на достаточно большое число, всегда будет производить0 .

Итак, мы здесь:

input        input.indexOf('9')      input.indexOf('9')>>9
"999"        0                       0
"111119"     5                       0
"123456"     -1                      -1

— Оливье Грегуар
источник

1

Ах да, это то, что я имею в виду. ; p Хороший гольф >>9вместо использования из- >>32за ограниченного диапазона чисел.

— Кевин Круйссен

1

Рубин , 55 байт

->a{a.sort_by{|x|x.abs.digits.sort.reverse|[]}.reverse}

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

— Кирилл Л.
источник

1

Perl 5 `-nl` , 68 байт

$a{eval"9876543210=~y/$_//dcr"}=$_}{say$a{$_}for reverse sort keys%a

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

— Xcali
источник

1

Юлия 1,0 , 50 байт

x->sort(x,by=y->sort(unique([digits(-abs(y));1])))

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

— Кирилл Л.
источник

1

APL (NARS), 366 символов, 732 байта

_gb←⍬

∇a _s w;t
t←_gb[a]⋄_gb[a]←_gb[w]⋄_gb[w]←t
∇

∇(_f _q)w;l;r;ls;i
(l r)←w⋄→0×⍳l≥r⋄l _s⌊2÷⍨l+r⋄ls←i←l⋄→3
  →3×⍳∼0<_gb[i]_f _gb[l]⋄ls+←1⋄ls _s i
  →2×⍳r≥i+←1
l _s ls⋄_f _q l(ls-1)⋄_f _q(ls+1)r
∇

∇r←(a qsort)w
r←¯1⋄→0×⍳1≠⍴⍴w⋄_gb←w⋄a _q 1(↑⍴w)⋄r←_gb
∇

f←{∪t[⍒t←⍎¨⍕∣⍵]}

∇r←a c b;x;y;i;m
x←f a⋄y←f b⋄r←i←0⋄m←(↑⍴x)⌊(↑⍴y)⋄→3
→0×⍳x[i]<y[i]⋄→3×⍳∼x[i]>y[i]⋄r←1⋄→0
→2×⍳m≥i+←1⋄r←(↑⍴x)>(↑⍴y)
∇

Для оператора qsort это один трейлинг в APL алгоритма. Я думаю, что в нем используются данные как C с указателями ... Тест

 c qsort 123, 478, ¯904, 62778, 0, ¯73, 8491, 3120, 6458, ¯7738, 373 
8491 ¯904 62778 478 ¯7738 6458 ¯73 373 3120 123 0 
 c qsort 11, ¯312, 902, 23, 321, 2132, 34202, ¯34, ¯382 
902 ¯382 34202 ¯34 321 ¯312 2132 23 11 
 c qsort 9, 44, 2212, 4, 6, 6, 1, 2, 192, 21, 29384, 0 
29384 192 9 6 6 4 44 2212 21 2 1 0 
 c qsort 44, ¯88, 9, 233, ¯3, 14, 101, 77, 555, 67 
9 ¯88 67 77 555 14 44 233 ¯3 101

— RosLuP
источник

1

Powershell, 44 байта

$args|sort{$_-split'(.)'-ne'-'|sort -u -d}-d

Тестовый скрипт:

$f = {

$args|sort{$_-split'(.)'-ne'-'|sort -u -d}-d

}

@(
    ,( (123, 478, -904, 62778, 0, -73, 8491, 3120, 6458, -7738, 373),
       (8491, -904, 62778, 478, -7738, 6458, 373, -73, 3120, 123, 0),
       (8491, -904, 62778, 478, -7738, 6458, -73, 373, 3120, 123, 0) )

    ,( (11, -312, 902, 23, 321, 2132, 34202, -34, -382),
       (902, -382, 34202, -34, -312, 321, 2132, 23, 11),
       (902, -382, 34202, -34, 2132, -312, 321, 23, 11) )

    ,( (9, 44, 2212, 4, 6, 6, 1, 2, 192, 21, 29384, 0),
       (29384, 192, 9, 6, 6, 4, 44, 2212, 21, 2, 1, 0),
       (29384, 192, 9, 6, 6, 44, 4, 2212, 21, 2, 1, 0),
       (29384, 192, 9, 6, 6, 44, 4, 21, 2212, 2, 1, 0) )

    ,( (44, -88, 9, 233, -3, 14, 101, 77, 555, 67),
       ,(9, -88, 67, 77, 555, 14, 44, 233, -3, 101) )
) | % {
    $a, $expected = $_
    $result = &$f @a
    $true-in($expected|%{"$result"-eq"$_"})
    "$result"
}

Выход:

True
8491 -904 62778 478 -7738 6458 -73 373 3120 123 0
True
902 -382 34202 -34 2132 -312 321 23 11
True
29384 192 9 6 6 44 4 21 2212 2 1 0
True
9 -88 67 77 555 14 44 233 -3 101

— Mazzy
источник

1

PHP 87 86 84 байта

while(--$argc)$a[_.strrev(count_chars($n=$argv[++$i],3))]=$n;krsort($a);print_r($a);

Запустить с -nrили попробуйте онлайн .

Заменить ++$iна $argc(+1 байт), чтобы подавить уведомление (и сделать-n устаревшим).

сломать

while(--$argc)  # loop through command line arguments
    $a[                             # key=
        _.                              # 3. prepend non-numeric char for non-numeric sort
        strrev(                         # 2. reverse =^= sort descending
        count_chars($n=$argv[++$i],3)   # 1. get characters used in argument
        )
    ]=$n;                           # value=argument
krsort($a);     # sort by key descending
print_r($a);    # print

- «меньше» цифр, поэтому не влияет на сортировку.

— Titus
источник

1

Common Lisp, 88 байт

(sort(read)'string> :key(lambda(x)(sort(remove-duplicates(format()"~d"(abs x)))'char>)))

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

Старый добрый многословный Common Lisp!

Объяснение:

(sort                   ; sort
 (read)                 ; what to sort: a list of numbers, read on input stream 
 'string>               ; comparison predicate (remember: this is a typed language!)
 :key (lambda (x)       ; how to get an element to sort; get a number
       (sort (remove-duplicates  ; then sort the unique digits (characters) 
               (format() "~d" (abs x))) ; from its string representation
             'char>)))  ; with the appropriate comparison operator for characters

— Renzo
источник

1

C # (интерактивный компилятор Visual C #) , 75 74 байта

-1 спасибо @ только для ASCII

x=>x.OrderByDescending(y=>String.Concat((y+"").Distinct().OrderBy(z=>-z)))

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

В C # строки считаются «перечисляемыми» символами. Я использую это в своих интересах, сначала преобразовав каждое число в строку. Затем LINQ используется для сортировки уникальных символов (цифр) в обратном порядке. Я преобразовываю каждый отсортированный массив символов обратно в строку и использую его в качестве ключа сортировки, чтобы упорядочить весь список.

— Dana
источник

Похоже, ты сможешь избежать неприятностей с добавлением -, похоже, порядок их не имеет значения?

— Только для ASCII

Без -тестового примера № 2, ... 321 2132 ...который кажется неправильным?

— Dana

нет, прочитайте пример более внимательно

— только ASCII

ОК - я думаю, что вы правы. Спасибо за совет!

— Dana

Сортировать по наибольшим цифрам

Вызов:

Правила соревнований:

Основные правила:

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

05AB1E , 5 байтов

R , 97 95 байт

Perl 6 , 36 34 33 31 байт

объяснение

Python 2 , 60 55 54 байта

Ungolfed

Python 2 , 58 60 байт

Брахилог , 9 байт

Pyth, 7 6 байтов

Желе , 8 байт

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

MathGolf , 7 6 байтов

объяснение

Japt , 12 байт

Haskell , 54 52 байта

Stax , 6 7 байт

APL (Dyalog Extended) , 19 байт

C (gcc) , 114 111 109 байтов

J , 17 байт

Объяснение:

JavaScript (SpiderMonkey) , 68 байт

JavaScript (Node.js) , 72 байта

Java (JDK) , 98 байт

объяснение

Рубин , 55 байт

Perl 5 -nl , 68 байт

Юлия 1,0 , 50 байт

APL (NARS), 366 символов, 732 байта

Powershell, 44 байта

PHP 87 86 84 байта

Common Lisp, 88 байт

C # (интерактивный компилятор Visual C #) , 75 74 байта

Perl 5 `-nl` , 68 байт