Никакие строки (или числа) не прикреплены

71

Если вам это нравится, рассмотрите возможность участия в:


Создайте 12 фрагментов / выражений на одном языке, которые приводят к числам от 0 до 10 и 42 соответственно, но без записи каких-либо буквенных числовых, строковых или символьных данных.

Встраиваемые данные, такие как PI()и ALPHABET(), хороши, как, например, константы CJam U, X, Y, Z и A, а также обработка BLEND, CHORD, CENTER, BREAK и LINES.

Каждый фрагмент должен быть в состоянии стоять самостоятельно, то есть они не могут быть взаимозависимыми. Однако внутри одного фрагмента вы можете назначить переменную и использовать ее свободно, если вы обращаетесь к ней напрямую по имени, а не через строку, содержащую ее имя.

Все фрагменты должны быть действительны на компьютере отправителя на момент отправки (согласно сообщениям SE), но могут не зависеть от необычных локальных условий, таких как количество файлов в каталоге, точная дата или время или конкретный ввод от пользователя ,

Примеры допустимых фрагментов

3: INT(LOG10(YEAR(TODAY()))) потому что это остается верным в обозримом будущем
4: CUBICROOT(LEN(CHARACTERSET())) потому что набор символов из 256 букв очень распространен
8: SQRT(SYSTEMTYPE()) потому что 64-битные системы очень распространены

Примеры неверных фрагментов

5: LEN(USERNAME()) потому что большинство людей не используют «Admin» для входа в систему :-)
9: LOG10(SYSTEMMEMORY()) потому что он работает только в системах с ровно 1 ГБ памяти
42: CODE("*") потому что он содержит строковый / символьный литерал

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

Разрешены только языки символов.

Оценка - это общее количество байтов всех 12 объединенных фрагментов. Новые строки, разделяющие фрагменты, не учитываются.

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

Вопросы-Ответы

В Могут ли программы принять любой ввод?
О Да, но вы можете не просто запросить ввод и ввести соответствующий номер.

Q Разрешены ли физические цифры (не данные)? Да, например .
LOG10()

Q Символы в Ruby считаются литералами?
А да.

Q Включает ли оценка новые строки между каждым фрагментом? No.

Q Достаточно ли TI-BASIC «на основе символов», чтобы быть действительным?
А да.

Q Ложь и истина считаются числовыми литералами? Нет, они являются приемлемыми.

В Можем ли мы использовать числовой литерал для вызова функции, если это единственный способ, и число не влияет на вывод функции?
О Да, если это нормальный способ написания кода на вашем языке.

Q Мой язык предполагает, что в начале каждой программы / выражения есть [что-то]. Должен ли я включить его, или мои фрагменты должны просто работать, если они помещены в середину программы / выражения? Они просто должны работать в середине программы / выражения.

Q Как насчет литералов регулярных выражений? Запрещено, для языков , которые только делают регулярные выражения , за исключением.

В Является ли приемлемым один фрагмент кода, который может печатать все указанные числа?
О Нет, они должны быть отдельными и взаимно независимыми.

Q Могу ли я предположить, что шаблон int main() {}...или аналог?
А да.

Q Какие выходные типы данных разрешены?
A Любой числовой тип данных, например, int, float и т. Д.

Q Нужно ли печатать результат каждого фрагмента?
A Нет, достаточно сделать результат доступным для последующего использования.

В Допустимы ли предварительно установленные переменные? Да, и они становятся сброса (если он был изменен) для каждого фрагмента.

Q π и e считаются числовыми литералами? Нет, вы можете использовать их.

Q Могу ли я вернуть 4 и 2 в разные ячейки для 42?
О Нет, они должны быть связаны как один номер.

Q байтов или символов? Bytes, но вы можете выбрать любой желаемый кодовую.

Q Могут ли использоваться постоянные функции и заданные переменные, такие как J 9:, Actually 9и Pretzel 9?
A Да, если словарный запас конечен (19 для J, 10 для Actual и Pretzel).

Адам
источник
Если 0-9 - это не числовые литералы, а заранее заполненные переменные, будет ли это честной игрой?
Cyoce
@Cyoce То есть 10 = {1, 0}, а не 2 × 5?
Адам
нет, просто существует другой синтаксис для литералов, который не является основанием-10, поэтому 0-9 не являются литералами. Они содержат значение 0-9, но считаются переменными
Cyoce
@Cyoce Тогда все в порядке. Что это за язык?
Адам
крендель (язык, на котором я работаю).
Cyoce

Ответы:

15

Гексагония , 13 байт

1
2
3
4
5
6
7
8
9
10
42

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

В Hexagony 0сквозными 9являются функции, которые умножают текущую память на 10, а затем добавляют число, представленное именем функции. Следовательно, первый фрагмент пуст, поскольку воспоминания начинаются как 0.

Например, если текущая память есть 65, выполнение функции 3создаст текущую память 653.

(Для downvoters: downvote все, что вы хотите; я готов.)

Дрянная Монахиня
источник
Подлый, но получает мой upvote и галочку.
Адам
49

Функцион , 1222 байта

Помимо числовых литералов, есть два способа, которыми я могу создать значение (любое значение вообще) в Funciton: выражения stdin и lambda. Stdin - это одно поле, в то время как для полного лямбда-выражения требуется больше синтаксиса, поэтому я собираюсь использовать stdin. Однако, несмотря на то, что stdin может быть чем угодно, все следующие операции работают независимо от того, какой ввод предоставляется.

Все используемые здесь библиотечные функции существовали до публикации заявки.

0 (40 байт в UTF-16)

╔╗┌┐
║╟┤└┼┬┐
╚╝└─┘└┘

Это использует сырой синтаксис для менее чем. Значение никогда не бывает меньше самого себя, поэтому результат равен 0.

1 (52 байта в UTF-16)

╔╗┌─╖┌─╖
║╟┤⌑╟┤ɕ╟
╚╝╘═╝╘═╝

возвращает ленивую последовательность, содержащую один элемент, и ɕподсчитывает количество элементов. (Ленивая последовательность достаточно ленива, чтобы этот фрагмент на самом деле вообще не оценивал стандартный ввод!)

2 (70 байт в UTF-16)

╔╗┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟
╚╝╘═╝╘═╝╘═╝

= 2¹. ʂгенерирует все подпоследовательности последовательности и, таким образом, превращает последовательность из n элементов в последовательность с 2ⁿ.

3 (88 байт в UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟┤♯╟
╚╝╘═╝╘═╝╘═╝╘═╝

= 2 + 1. увеличивает значение на 1.

4 (88 байт в UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ʂ╟┤ɕ╟
╚╝╘═╝╘═╝╘═╝╘═╝

= 2².

5 (106 байтов в UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ʂ╟┤ɕ╟┤♯╟
╚╝╘═╝╘═╝╘═╝╘═╝╘═╝

= 4 + 1.

6 (106 байт в UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟┤♯╟┤!╟
╚╝╘═╝╘═╝╘═╝╘═╝╘═╝

= 3 факториала.

7 (110 байт в UTF-16)

┌───┐┌─╖┌─╖┌─╖╔╗
│┌─╖├┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤A╟┘╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= A (2, 2) (функция Аккермана).

8 (118 байт в UTF-16)

┌────┐┌─╖┌─╖┌─╖╔╗
│┌──╖├┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤<<╟┘╘═╝╘═╝╘═╝╚╝
 ╘╤═╝

= 2 << 2 (сдвиг влево).

9 (128 байт в UTF-16)

┌───┐┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖├┤♯╟┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤×╟┘╘═╝╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= 3 × 3.

10 (146 байт в UTF-16)

┌───┐┌─╖┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖├┤♯╟┤ɕ╟┤ʂ╟┤ʂ╟┤⌑╟╢║
└┤+╟┘╘═╝╘═╝╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= 5 + 5.

42 (170 байт в UTF-16)

┌──────┐┌─╖┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖┌─╖├┤!╟┤♯╟┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤♯╟┤×╟┘╘═╝╘═╝╘═╝╘═╝╘═╝╚╝
 ╘═╝╘╤╝

= 6 × (6 + 1).

Timwi
источник
6
+1 для функции Аккермана .
intrepidcoder
4
Хотелось бы, чтобы я голосовал несколько раз ...
ev3commander
26

JavaScript, 144 141 140 138 132 125 123 байта

С помощью @ edc65 , @Sjoerd Job Postmus , @DocMax , @usandfriends , @Charlie Wynn и @ Mwr247 !

result.textContent = [

+[]                          ,// 0  (3 bytes)
-~[]                         ,// 1  (4 bytes)
-~-~[]                       ,// 2  (6 bytes)
-~-~-~[]                     ,// 3  (8 bytes)
-~Math.PI                    ,// 4  (9 bytes)
-~-~Math.PI                  ,// 5  (11 bytes)
-~-~-~Math.PI                ,// 6  (13 bytes)
Date.length                  ,// 7  (11 bytes)
(a=-~-~[])<<a                ,// 8  (13 bytes) = (2 << 2)
(a=~Math.E)*a                ,// 9  (13 bytes) = (-3 * -3)
(a=-~-~[])<<a|a              ,// 10 (15 bytes) = ((2 << 2) | 2)
(a=Date.length)*--a           // 42 (19 bytes) = (7 * 6)

];
<pre id="result"></pre>

user81655
источник
Попробуйте 4: - ~ Math.PI
edc65
@ edc65 Спасибо! Я думал, что смогу кое-что сделать с ПИ. :)
user81655
Для 5, 6 вы также можете использовать -~-~Math.PIи -~-~-~Math.PIсохранить другой байт (дважды).
Sjoerd Job Postmus
1
Сохрани один на 42 с (escape+NaN).length. PS Сегодня я узнал, что JavaScript действительно странный ...
Mwr247
1
Я хотел сказать, что NaNэто число, но буквально не число: P
ETHproductions
17

Мышь-2002 , 27 26 17 14 байт

Первые фрагменты нажимают 0-10, а ZR+толкает 25тогда 17и 25 17 + 42 =есть 1.

A
B
C
D
E
F
G
H
I
J
K
ZR+
кошка
источник
Там
3
@cat Я не могу говорить за спрашивающего, но я думаю, что это означает изолированность друг от друга - не нужно определять функцию в одной, а затем использовать ее в другой. Тем не менее, каждый фрагмент не обязательно должен быть целой программой, он может принимать шаблонный int main() {}...эквивалент, который заставит его работать.
TessellatingHeckler
15

CJam, 27 24 байта

U    e# 0
X    e# 1
Y    e# 2
Z    e# 3
Z)   e# 3 + 1
YZ+  e# 2 + 3
ZZ+  e# 3 + 3
AZ-  e# 10 - 3
YZ#  e# 2³
A(   e# 10 - 1
A    e# 10
EZ*  e# 14 × 3

Спасибо @ MartinBüttner за -1 байт!

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

Деннис
источник
12

Brainfuck, 70 байт

+
++
+++
++++
+++++
++++++
+++++++
++++++++
+++++++++
++++++++++
--[>+<++++++]>-

Каждая строка должна быть запущена индивидуально.

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

42 намного сложнее. Он основан на том факте, что большинство интерпретаторов «мозгового пота» используют 8-битные ячейки, а это означает, что все операции над ним выполняются по модулю 256. --Устанавливает ячейку от 0 до 254. Затем мы вводим цикл, который выполняется до тех пор, пока ячейка # 0 не станет 0. Каждая итерация добавляет 1 к ячейке # 1 и добавляет 6 к ячейке # 0. Этот цикл выполняется 43 раза, поэтому ячейка № 1 равна 43. Наконец, мы вычитаем 1 из ячейки № 1, чтобы сделать ее 42.

Я получил самые эффективные 42 из когда-либо найденных на http://esolangs.org/wiki/Brainfuck_constants

p1xel
источник
1
@someonewithpc 4 и 2 отличается от 42: OP говорит, что результат каждого фрагмента должен приводить к фактическому числу, которое можно использовать для дальнейших вычислений с использованием того же языка, что и фрагмент, т.е. не к текстовой строке, представляющей это число . Вы можете делать расчеты на 42 напрямую, но это не то же самое для 4 и 2 в отдельных ячейках.
p1xel
О хорошо Я пропустил это ..
Someonewithpc
12

Тьма , 339 303 байта

Вот где действительно светит тьма . Возьми? : ~)!

Без печати (замените пробел \sв первой строке, так как иначе не будет отображаться):

\s

█ 

██ 

███ 

████ 

█████ 

██████ 

███████ 

████████ 

█████████ 

██████████ 

██████████████████████████████████████████ 

С печатью:

■ 

█■ 

██■ 

███■ 

████■ 

█████■ 

██████■ 

███████■ 

████████■ 

█████████■ 

██████████■ 

██████████████████████████████████████████■ 

В этом случае каждая строка должна запускаться индивидуально, так как программа заканчивается на свету (пробел). Однако это можно записать в одну или несколько строк в одной и той же программе.

Обычная темнота (█) увеличивает регистр на 1, а инструкция ■ (своего рода мини-тьма) выводит содержимое регистра.

sweerpotato
источник
Я не думаю, что это требует полных программ, просто фрагменты.
Эрик Outgolfer
12

Perl 5, 86 75 71 66 байт

Все ^Fs являются буквенными управляющими символами (0x06 в ASCII) и, следовательно, одним байтом.

$[          # array start index, defaults to 0                                  2
!$[         # !0 is 1                                                           3
$^F         # max sys file descriptor number, 2 on all sane systems             2
++$^F       # 2 + 1                                                             4
~-$]        # 5 - 1                                                             4
int$]       # $] is Perl version, int truncates                                 5
length$~    # 1 + 5                                                             8
~~exp$^F    # floor(e^2)                                                        7
$^F<<$^F    # 2 bitshift-right 2                                                6
-!$[+ord$/  # -1 + 10                                                          10
ord$/       # input record separator, newline by default, ord gets ASCII val    5
ord($"^$/)  # 32 + 10                                                          10

Спасибо msh210 за сохранение 11 байтов и Dom Hastings за 9 байтов!

Дверная ручка
источник
3
Perl странный. zoitz.com/comics/perl_small.png
ldam
понижен, потому что "max дескриптор файла sys, 2 на всех вменяемых системах = 3", но у меня есть 65+
cat
(я просто шучу, я проголосовал, конечно)
кошка
1
Вы когда-нибудь читали комментарии к посту SE и думали: «Ого, какой придурок это написал»? Это я прямо сейчас, у себя.
кот
!$[+ord$/ # -1 + 10Я не понимаю. В строке 2 вы говорите, что !$[дает вам 1, а не -1, поэтому этот фрагмент дает 11.
Тимви
10

MATL, 30 байт

O
l
H
I
K
Kl+
HI*
KYq
HK*
IH^
K:s
IH^:sI-

H, IИ Kпредопределенные константы для 2, 3 и 4 (например pi). Oи lявляются функциями, которые возвращают матрицу нулей ( O) или ones ( l), размер по умолчанию - 1x1. :делает вектор и sсуммирует его, поэтому K:sделает вектор от 1 до 4 и суммирует его, чтобы получить 10. Yqявляется n-й простой функцией, KYqравно как и 4-е простое число, 7.

Дэвид
источник
Эта Yqфункция (и ее реализация) была вашим хорошим предложением :-)
Луис Мендо
IK+будет работать так же хорошо для 7, но это слишком скучно: P
Дэвид
10

Пролог, 113 99 байт

Отрывки:

e-e              % 0.0
e/e              % 1.0
e/e+e/e          % 2.0
ceil(e)          % 3
ceil(pi)         % 4
ceil(e*e-e)      % 5
ceil(e+e)        % 6
floor(e*e)       % 7
ceil(e*e)        % 8
ceil(pi*e)       % 9
ceil(pi*pi)      % 10
ceil(e^e*e)      % 42

Объединяет математические константы e и pi различными способами, преобразованными в int.

Редактировать: Сохранено 14 байтов с использованием поплавков для 0-2.

Emigna
источник
1
что-то не так с е / е = 1?
Уровень Река St
@steveverrill: он станет поплавком (1.0). Я интерпретировал описание вызова так, что числа должны быть целыми числами. Большинство из них, если не все, могут быть сокращены в противном случае.
Emigna
1
@steveverrill Поплавки в порядке. Нам просто нужно правильное значение .
Адам
9

PHP, 157 145 91 байт

Первый раз, когда я писал на Code Golf, решил, что я попробую. Я поправлюсь в конце концов: P Если вы видите какие-либо очевидные (для вас) места, где я могу сохранять персонажей, дайте мне знать.

РЕДАКТИРОВАТЬ: понял, что мне не нужны точки с запятой, так как это всего лишь фрагменты.

РЕДАКТИРОВАТЬ 2: Спасибо Blackhole за много предложений!

LC_ALL
DNS_A
~~M_E
~~M_PI
LOCK_NB 
LC_TIME
LOG_INFO
INI_ALL
IMG_WBMP
SQL_DATE
SQL_TIME
LOG_INFO*INI_ALL
ORP
источник
5
PHP имеет много расширений, и поэтому множество предопределенных констант намного лучше, чем математические для этой задачи;). LC_ALLдля 0 (-1 байт), DNS_Aдля 1 (-3 байта), LOCK_NBдля 4 (-3 байта), LC_TIMEдля 5 (-7 байт), LOG_INFOдля 6 (-8 байт), INI_ALLдля 7 (-5 байт),…
Blackhole
5
IMG_WBMPДля 8 (-4 байта), SQL_DATEдля 9 (-9 байтов), SQL_TIMEдля 10 (-3 байта) и LOG_INFO*INI_ALLдля 42 (-11 байтов). Следовательно, в общей сложности 51 байтов сохранено! Эти константы действительны по крайней мере в PHP 5.6.1 для Windows.
Blackhole
@ Blackhole не LC_ALLзависит от локали?
кот
@cat Это действительно константа, используемая setlocale()для изменения всех категорий локалей. Но значение самой константы, конечно, не зависит от локали :).
Blackhole
@ Черная дыра ах, понятно!
кот
9

Python 2, 191 159 158 157 156 149 146 байт

Моя первая подача, надеюсь, я все правильно понял! Исходя из того, сколько времени я потратил на это, я думаю, что для некоторых из них наверняка найдется лучший.

# 0 | Bytes : 5
int()

# 1 | Bytes : 5
+True

# 2 | Bytes : 6
-~True

# 3 | Bytes : 8
-~-~True

# 4 | Bytes : 10
-~-~-~True

# 5 | Bytes : 12
-~-~-~-~True

# 6 | Bytes : 14
-~-~-~-~-~True

# 7 | Bytes : 16
-~-~-~-~-~-~True

# 8 | Bytes : 15
a=True;a<<a+a+a

# 9 | Bytes : 19
a=True;(a<<a+a+a)+a

# 10 | Bytes : 20
int(`+True`+`int()`)

# 42 | Bytes : 16
~-len(`license`)
# Especially proud of this one !

Total byte count: 146

Большое спасибо FryAmTheEggman!

Иоахим Яблон
источник
Добро пожаловать в PPCG :) Я не уверен на 100% в этом вызове, но я думаю, что использование Trueидиомы для 1 должно быть приемлемым, поскольку я не знаю, когда они не эквивалентны фрагментам.
FryAmTheEggman
О, ты прав! Не использовать его для самой 1, потому что, True is not 1но для всех вычислений, основанных на 1, это помогает! Редактирование сейчас.
Иоахим Яблон
1
Используйте #8 len(`id(id)`). Тогда 8, 9 и 10 будут короче. Также, возможно, добавьте гиперссылку, чтобы попробовать онлайн .
mbomb007
Вы можете получить 9 с len(`{()}`)на 11 байтов, и это дает вам от 7 до 10 короче.
xnor
9

C #, без использования, 234 байта

new int()                       // 0
-~new int()                     // 1
-~-~new int()                   // 2
-~-~-~new int()                 // 3
-~-~-~-~new int()               // 4
-~-~-~-~-~new int()             // 5
-~-~-~-~-~-~new int()           // 6
-~-~-~-~-~-~-~new int()         // 7
-~-~-~-~-~-~-~-~new int()       // 8
(int)System.ConsoleKey.Tab      // 9
(int)System.TypeCode.UInt32     // 10
(int)System.ConsoleKey.Print    // 42

Это гораздо скучнее, чем я думал вначале. У меня были довольно разнообразные идеи, такие как new[]{true}.Lengthи true.GetHashCode()и typeof(int).Name.Lengthи и uint.MinValueт. Д., Но я new int()победил их всех.

Timwi
источник
Позволят ли правила сделать что-то подобное var a = new int();и затем использовать aв каждом фрагменте?
ldam
@LoganDam: мне интереснее, если каждое выражение должно стоять само по себе. Вот почему я не использовал никаких usingобъявлений.
Тимви
Воу, что это за 9/10/42:
oo
@ ev3commander: это просто кратчайшие значения перечисления, определенные в mscorlib, которые имеют необходимое целочисленное значение. Для ConsoleKey.Tab значение 9 не удивительно (9 также является ASCII символа табуляции). Другие, вероятно, произвольны.
Тимви
Короче на 8:int a=-~-~new int();a<<a
LegionMammal978
9

PowerShell, 147 байт

Они используют +для неявного приведения вещей к целым числам. В более поздних числах используются перечисления .Net Framework из PowerShell, которые имеют правильные значения.

+$a                          #0, 3 bytes (unset vars are $null, +$null == 0)
+$?                          #1, 3 bytes (bool previous result, default $true, +$true == 1)
$?+$?                        #2, 5 bytes (same as #1, twice)
$?+$?+$?                     #3, 8 bytes (beats [Int][Math]::E)
$?+$?-shl$?                  #4, 11 bytes (-shl is shift-left)
$?+$?+$?+$?+$?               #5, 14 bytes
$?+$?+$?-shl$?               #6, 14 bytes (enum value, + casts to integer)
+[TypeCode]::Int16           #7, 18 bytes
$?+$?-shl$?+$?               #8, 14 bytes
+[consolekey]::tab           #9, 18 bytes
+[TypeCode]::UInt32          #10, 19 bytes
+[consolekey]::Print         #42, 20 bytes

#Total:                      147 bytes

  • -~-~-~используемые в JavaScript, C # и PHP ответы будут - -bnot - -bnot - -bnotв PowerShell.

  • x^yвозведение в степень, используемое в ответах Perl, или x**yв Python или JavaScript ES7, будет[Math]::Pow($x,$y)

  • константы е и пи тяжелые [Math]::Eи[Math]::PI

TessellatingHeckler
источник
x^yэто XOR в JavaScript. JavaScript (ES7) имеет **для показателей. Источник
mbomb007
@ mbomb007 Ах, спасибо - я обновил свою заметку по этому вопросу.
TessellatingHeckler
@ mbomb007 Я все еще думаю, что это немного глупо
SuperJedi224
@ SuperJedi224 Почему? Вот как это делает Python. И XOR является важным оператором.
mbomb007
8

DC , 35 байт

K
KZ
IZ
Iv
EI-
FI-
IZd*
IIZ/
Ivd+
IIv-
IIZ-
IKZ-
I
EdE++

Чтобы проверить фрагменты, добавьте a, fчтобы напечатать стек и передать эту строку dc:

$ echo 'EdE++f' | dc
42
йети
источник
Я считаю, что Eи Fздесь есть цифры (даже когда они больше, чем входной радиус). Доказательством этого является то, что они объединяются в виде цифр; например F0-> 150. Вы можете увидеть то же поведение с десятичными цифрами после изменения основ ввода и вывода.
Тоби Спейт
Есть много других ответов, использующих подобные вещи ... почему я должен быть единственным, где это не нормально?
йети
Вы не должны - если есть другие решения, использующие цифры, то они также не являются правильными ответами.
Тоби Спейт
1
Мне все равно больше! Codegolf даже принимает заданную программу графического Мандельброта в качестве решения задачи , чтобы написать программу ASCII Art Мандельброта ... codegolf нужен большой сброс и при перезапуске я могу и не заботиться о правилах снова ...: -й
йети
7

TI-BASIC, 41 байт

0 ~ 10:

X
cosh(X
int(e
int(π
-int(-π
int(√(π³
int(π+π
int(e²
int(eπ
int(π²
Xmax

42:

int(π²/ecosh(π

В TI-BASIC все неинициализированные однобуквенные переменные начинаются с 0, а Xmax(правая граница окна экрана графика) начинается с 10.

Математическая константа πсоставляет один байт , но eсоставляет два байта.

lirtosiast
источник
Π не считается числовыми данными?
VSZ
@vsz возможно, но это не число буквально. Оператор даже говорит так.
SuperJedi224
@NBZ очень хорошая мысль. Виноват.
GamrCorps
6

Python 2, 306 275 274 байта

Я использовал тот факт, что для любого x (целое число, а не 0) выражение x/xравно 1 и играл с некоторыми побитовыми операциями.

Я настроил фрагменты так, чтобы они все еще соответствовали требованиям (спасибо @nimi, это сэкономило мне 24 байта), но вы должны вручную протестировать их. Вот код и количество отдельных байтов:

zero.py Bytes: 7
len({})
--------------------------
one.py  Bytes: 12
r=id(id)
r/r
--------------------------
two.py  Bytes: 17
r=id(id)
-(~r/r)
--------------------------
three.py    Bytes: 20
r=id(id)
-(~r/r)|r/r
--------------------------
four.py Bytes: 20
r=~id(id)/id(id)
r*r
--------------------------
five.py Bytes: 26
r=~id(id)/id(id)
(r*r)|r/r
--------------------------
six.py  Bytes: 25
r=~id(id)/id(id)
(r*r)|-r
--------------------------
seven.py    Bytes: 27
r=~id(id)/id(id)
-~(r*r|-r)
--------------------------
eight.py    Bytes: 24
r=-(~id(id)/id(id))
r<<r
--------------------------
nine.py Bytes: 29
r=-(~id(id)/id(id))
r-~(r<<r)
--------------------------
ten.py  Bytes: 31
r=~id(id)/id(id)
-r*((r*r)|r/r)
--------------------------
answer.py   Bytes: 37
r=-(~id(id)/id(id))
(r<<r*r)|(r<<r)|r
--------------------------
Total byte count: 274
ბიმო
источник
Вы можете сохранить байты сi=id(id);r=~i/i
Cyoce
6

Математика ++, всего 92 байта

0 (1 байт): a

1 (2 байта):!a

2 (3 байта):_$e

3 (4 байта): _$pi

4 (7 байт): _$e+_$e

5 (8 байт): _($e+$e)

6 (9 байт): _$pi+_$pi

7 (8 байт): _($e*$e)

8 (9 байт): _($e*$pi)

9 (10 байт): _($pi*$pi)

10 (12 байт): _$e*_($e+$e)

42 (19 байт): _($pi+$pi)*_($e*$e)

SuperJedi224
источник
5

Javascript (Env браузера), 155 136 130 байт

+[]
-~[]
-~-~[]
-~-~-~[]
-~-~-~-~[]
-~-~-~-~-~[]
-~-~-~[]<<-~[]
-~-~-~-~-~-~-~[]
-~[]<<-~-~-~[]
~(~[]+[]+-[])
-~[]+[]+-[]
-~(top+top.s).length // Requires browser environment

Спасибо:
@Ismael Miguel : 155 -> 136 -> 130 байтов

usandfriends
источник
1
Вы можете использовать -~[]+[]+-[]для производства 10. Он вернет строку, но все равно будет использоваться как число. Кроме того, вы можете использовать -~(top+top.s).lengthдля расчета 42(-8 байт) и отказаться от зависимости от Google Chrome. Чтобы сохранить больше 3 байтов, используйте (P=Math.PI)*P>>+[]для вычисления 9.
Исмаэль Мигель
1
Извините, забыл несколько байтов, которые можно побрить. Вы можете использовать ~(~[]+[]+-[])для генерации 9. Это должно сократить еще несколько байтов.
Исмаэль Мигель
Любопытно, +[12]дает 12и +[1, 2]дает NaN. Я ненавижу JS
кошка
2
@cat Это из-за странной системы приведения в JavaScript. Массивы приводятся к строкам наподобие [1,2,3]=>, "1,2,3"а строки - к числам наподобие "12"=>, 12но если в строке есть нечисловые символы, возвращается приведение NaN. +[1,2]бросает в строку затем число, но строка содержит запятую, так "1,2"становится NaN.
user81655
@ user81655 это. является. Ужасный.
кот
5

Серьезно, 39 33 байта

Материал в скобках это объяснения:

 (single space, pushes size of stack, which is 0 at program start)
 u (space pushes 0, u adds 1 (1))
 ⌐ (space pushes 0, ⌐ adds 2 (2))
 u⌐ (space pushes 0, u adds 1 (1), ⌐ adds 2 (3))
 ⌐⌐ (space pushes 0, ⌐⌐ adds 2 twice (4))
 ⌐P (space pushes 0, ⌐ adds 2 (2), P pushes the 2nd prime (5))
Hl▓ (H pushes "Hello, World!", l pushes length (13), ▓ pushes pi(13) (6))
QlP (Q pushes "QlP", l pushes length (3), P pushes the 3rd prime (7))
Ql╙ (Q pushes "QlP", l pushes length (3), ╙ pushes 2**3 (8))
úl▓ (ú pushes the lowercase English alphabet, l pushes length (26), ▓ pushes pi(26) (9))
 u╤ (space pushes 0, u adds 1 (1), ╤ pushes 10**1 (10))
HlPD (H pushes "Hello, World!", l pushes length (13), P pushes the 13th prime (43), D subtracts 1 (42))

Hexdumps программ:

20
2075
20a9
2075a9
20a9a9
20a950
486cb2
516c50
516cd3
a36cb2
2075d1
486c5044

Спасибо Quintopia за 6 байтов!

Мего
источник
1
Я полагаю, серьезно использует кодовую страницу из 256 символов, которая включает псевдо графические символы?
Адам
2
@NBZ CP437
Mego
Вы можете сохранить байт на 6 с Hl▓
quintopia
Та же самая идея с ú сохраняет байт 9
quintopia
HlPDсохраняет 2 байта на 42, и QlPсохраняет байт на 7, и Qlªсохраняет байт на 9, и Ql╙сохраняет байт на 8. Я думаю, что все серьезно снижается до 33 байтов, связывая Pyth.
Quintopia
5

постоянный ток, 42 байта

K
zz
OZ
zzz+
OZd*
OdZ/
zzzz*
Ozz+-
OdZ-
Oz-
O
Od+dz++

Результаты

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

Существует не так много способов генерировать новые числа с помощью DC. Я использую O: выходная база, изначально 10; K: точность, изначально 0; zглубина стека, изначально 0; Zзначащие цифры операнда. Мы объединяем их с обычными арифметическими операторами.

Тестовая программа

#!/bin/bash

progs=(                                         \
    "K"                                         \
    "zz"                                        \
    "OZ"                                        \
    "zzz+"                                      \
    "OZd*"                                      \
    "OdZ/"                                      \
    "zzzz*"                                     \
    "Ozz+-"                                     \
    "OdZ-"                                      \
    "Oz-"                                       \
    "O"                                         \
    "Od+dz++"                                   \
)

a=0
results=()
for i in "${progs[@]}"
do
    results+=($(dc -e "${i}p"))
    (( a+=${#i} ))
done

echo "#dc, $a bytes"
echo
printf '    %s\n' "${progs[@]}"
echo
echo '##Results'
echo
printf '    %s\n' "${results[@]}"
Тоби Спейт
источник
4

Mathematica, 101 байт

a-a
a/a
⌊E⌋
⌈E⌉
⌈π⌉
⌊E+E⌋
⌈E+E⌉
⌊E*E⌋
⌈E*E⌉
⌈E*π⌉
⌈π*π⌉
⌊π*π^π/E⌋

Я уверен, что некоторые из них неоптимальны. Эти круглые скобки действительно дороги.

Для согласованности первые два также могут быть E-Eи, E/Eконечно, но я подумал, что это довольно изящно получить 0и 1вычислить с неопределенными переменными.

Мартин Эндер
источник
@NBZ Извините, забыл о 0. Если впоследствии aполучит значение 0, это не проблема, если оно не используется при a/aоценке.
Мартин Эндер
@NBZ Счетчик байтов - это просто счетчик байтов UTF-8.
Мартин Эндер
4

Japt , 34 33 30 байт

1 байт сохранен благодаря @ThomasKwa

T
°T
C-A
D-A
E-A
F-A
G-A
°G-A
Iq
´A
A
H+A

Вот что означает каждый из этих символов:

T    0
A    10
B    11
C    12
D    13
E    14
F    15
G    16
H    32
I    64
q    sqrt on numbers
°    ++
´    --
ETHproductions
источник
Принимает ли Japt шестнадцатеричные числа по умолчанию? Если так, то от A до F будут числовыми литералами ...
Adám
@NBZ A-I- это переменные, которые по умолчанию присваиваются различным номерам, как показано выше. A-Fназначены на 10-15. Это делает эти переменные недействительными?
ETHproductions
Нет, мне просто интересно, допустим, допустим, допустим, 12AB3. Теперь я знаю, что это не так. Здесь нет литералов, двигайтесь вперед. :-)
Adám
4

Marbelous , 98 байт

Не очень интересно, он опирается на ?nустройства, которые превращают любой мрамор в случайное значение в диапазоне 0..n (включительно), побочным эффектом которого является то, что ?0любой мрамор превращается в 0 независимо от входных данных. Я думаю, что использование литералов разрешено, потому что значение не влияет на результат, и нет другого способа вызвать функцию один раз в Marbelous.

0:

00  # A hexadicemal literal: value 0
?0  # Turn any marble into a random value from the range 0..0 (inclusive)

1:

00
?0
+1  # increment by one

...

9:

00
?0
+9

10:

00
?0
+A  # increment by 10

42:

00
?0
+L  # increment by 21
+L
overactor
источник
Похоже, 0 ... L - числовые литералы.
Адам
2
@NBZ Это не так, вы не можете использовать их независимо друг от друга. От +0 до + Z подобны встроенным функциям. Это скучно, но актуально.
переиздание
4

> <> , 86 байт

  • 0: ln;
  • 1: lln;
  • 2: llln;
  • 3: lll+n;
  • 4: lll:+n;
  • 5: llll+n;
  • 6: llll++n;илиllll:+n;
  • 7: lllll+n;
  • 8: lllll:+n;
  • 9: lllll++n;илиllllll+n;
  • 10: llll+:+n;илиlll:l+*n;
  • 42: llll*ll+*n;

Полагается на размер стека, чтобы получить его литералы.

Аарон
источник
Вы, вероятно, можете удалить nкаждый из них, потому что функции в языках на основе стека могут оставлять выходные данные в стеке на -11 байт.
Redstarcoder
@redstarcoder тогда я мог бы даже удалить в ;общей сложности 22 байта и рассмотреть конец функции, достигнутой в конце строки, но это немного неоднозначно, так ><>как не имеет готовых функций.
Аарон
Технически, если вы хотите использовать функции ><>, ваши функции должны принимать возвращаемую позицию (x & y) в стеке в дополнение к их параметрам, убедитесь, что они не мешают выполнению вычислений (это [удобно в этом контексте), затем перейдите в позицию возврата после завершения выполнения. Я сделал POC некоторое время назад, проверьте это, если вам интересно
Аарон
Я на самом деле видел ваш пост раньше, и хорошая работа! Я сделал мета-пост о неоднозначности функций . Я говорю, что это обычно разрешено с ;. Причина, по которой я говорю оставить, ;состоит в том, что иначе нет способа обозначить, когда функция заканчивается без .. Кажется, что большинство людей считают это справедливым, но я мог бы попытаться написать конкретный мета-пост здесь, если вы обеспокоены.
Redstarcoder
1
@redstarcoder спасибо за информацию! Я чувствую, что суффикс ><>фрагментов кода .будет лучшим способом придерживаться определения функции, как описано в наиболее одобренном ответе мета-поста, однако я согласен, ;что это хорошая альтернатива, которая требует меньше объяснений.
Аарон
4

Формулы MS Excel, 163 151 150 143 байта

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

0:  -Z9                         (03 bytes)
1:  N(TRUE)                     (07 bytes)
2:  TYPE(T(Z9))                 (11 bytes)
3:  TRUNC(PI())                 (11 bytes)
4:  TYPE(TRUE)                  (10 bytes)
5:  ODD(PI())                   (09 bytes)
6:  FACT(PI())                  (10 bytes)
7:  ODD(PI()+PI())              (14 bytes)
8:  EVEN(PI()+PI())             (15 bytes)
9:  TRUNC(PI()*PI())            (16 bytes)
10: EVEN(PI()*PI())             (15 bytes)
42: EVEN(CODE(-PI())-PI())      (22 bytes)

PI()используется в большинстве случаев, так как это более короткий (насколько мне известно) способ ввода числового значения без использования числового или строкового литерала. Nпреобразует различные вещи (включая логические) в числа и Tпреобразует различные вещи в текст. TYPEвозвращает 2 для текстового аргумента и 4 для логического аргумента. TRUNCотбрасывает дробную часть (т.е. округляет положительные числа вниз), EVENокругляет до следующего четного числа и ODDокругляет до следующего нечетного числа. CODE(-PI())это код ASCII первого символа преобразования в текст -π, т.е. 45 (для «-»).

РЕДАКТИРОВАТЬ: Удалены знаки равенства из числа байтов (-12!) - как указано Nᴮᶻ в комментариях, они не должны быть включены.

РЕДАКТИРОВАТЬ 2: Предполагая, что остальная часть листа пуста, можно использовать ссылку на пустую ячейку как ноль (опять же, предложенный Nᴮᶻ), при условии, что мы добавляем знак минус (или используем его в другом числовом выражении) для разрешения типа двусмысленность.

dnep
источник
0=Z9
адам
Удалил =с, спасибо. Что касается вашего предложения, я специально избегал ссылок на ячейки, чтобы гарантировать, что формулы не зависят от содержимого таблицы - если Z9содержит текст, =Z9больше не будет возвращать ноль. Я решил не предполагать ничего о столе.
июня
во всяком случае, вы заставили меня снова обворовывать это, и я понял, что могу хотя бы сэкономить 1 байт, используя для 0 ту же логику, что и для 1 ...
dnep
Но в некоторых языках все переменные установлены на 0, если они не установлены на что-то другое. В этом контексте я видел бы Excel как язык с (теоретически бесконечными) ячейками памяти A1: ZZZ ..: 999 ... и без различия между кодом программы и данными (то есть может быть самоизменяющимся). Поскольку каждый фрагмент не зависит от других, я предполагаю, что он находится в А1, а на остальной части листа он пустой. (Для программ у меня было бы одно целое утверждение в каждой ячейке А1, А2 и т. Д.)
Адам
Я понимаю вашу точку зрения ... но есть еще одна проблема со ссылками Z9на ячейки: на пустом листе есть пустое значение, которое преобразуется 0во многих случаях, но может быть преобразовано в ""(пустую строку), если используется в некоторых выражениях - очень похоже на неинициализированный вариант VBA - поэтому он не является строго эквивалентным 0. Например, = 0&"a" оценивается, "0a"но = Z9&"a"оценивается "a". Это может быть решено, однако, путем добавления унарного -к ссылке (таким образом, заставляя его быть числовым - опять же, как в VBA). Так что -Z9 можно использовать как ноль. Я только что обновил ответ. Еще раз спасибо.
dnep
4

DUP , 68 байт

[
 [
  [
[)]!
[ )]!
[  )]!
[)~_]!
[ )~_]!
[  )~_]!
[   )~_]!
[)$+]!
[ )$+~_$+]!

Try it here.

Есть много способов сделать это, но я злоупотребляю стеком возврата для этого.

объяснение

Чтобы полностью понять это, вам нужно понять поведение DUP в отношении лямбд. Вместо того, чтобы помещать лямбду в стек, она фактически выталкивает текущий IP в стек при обнаружении лямбды. Это может объяснить первые 3 фрагмента, которые включают лямбды.

Следующие фрагменты используют возвращаемый стек. Когда !выполняется, текущий IP передается в стек возврата, а вершина стека устанавливается в качестве нового IP для запуска лямбда-выполнения. )выталкивает число из стека возврата в стек данных.

Этого достаточно, чтобы объяснить остальные фрагменты. Если вы все еще не получаете его, имейте в виду, что Stepкнопка довольно удобна!

Mama Fun Roll
источник
4

05AB1E, 40 38 24 байта

¾
X
Y
XÌ
Y·
T;
T;>
T;Ì
TÍ
T<
T
žwT+
  • Push counter_variable
  • Нажмите 1
  • Нажмите 2
  • Нажмите 1 + 2
  • Нажмите 2 * 2
  • Push 10/2
  • Push (10/2) +1
  • Нажмите (10/2) +2
  • Пуш 10-2
  • Пуш 10-1
  • Нажмите 10
  • Push 32, 10, добавить
акролит
источник
1
более стек чистой , чем Yx, Xможет быть использован вместо ºздесь (это значение по умолчанию 1, ºзначит len(stack)>1, так оно не по умолчанию ни к чему). Кроме того, ваш счет будет 24, а не 35 (CP-1252, переводы строк не учитываются, если они являются отдельными фрагментами).
Эрик Outgolfer
Я знаю, что в то время, когда вы это опубликовали, это было невозможно, но ₆tтеперь можно 6 (нажать 36, квадратный корень), чтобы сохранить байт ( попробуйте онлайн ).
Кевин Круйссен
3

D1ffe7e45e , 112

0
02
020
0202
02020
020202
0202020
02020202
020202020
0202020202
02020202020
202020202020202020202020202020202020202020

Каждая строка - это отдельный фрагмент.

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

Финал определенно может быть больше в гольфе.

РЕДАКТИРОВАТЬ: у меня работает переводчик и все фрагменты работают. Если вы хотите проверить себя, добавьте 0f0fв конец фрагмента, чтобы программа завершилась.

ASCIIThenANSI
источник
6
Эти наверняка выглядят буквально для меня. Кроме того, не размещайте код, который вы не тестировали.
Mego
2
Можете ли вы объяснить, как они работают?
Адам
@NBZ D1ffe7e45e работает на основе разницы между двумя шестнадцатеричными числами. Эта разница затем интерпретируется в команду. Например, разница между 0 и 2 равна 2, что интерпретируется как команда приращения (как +в Brainf ** k). Я подумал, что, поскольку они используются в качестве команд, а не числовых литералов, он все равно считается. Я удалю ответ, если это не так.
ASCIIThenANSI
@Mego У меня работает интерпретатор, и мой код работает. Посмотрите выше комментарий, почему я думаю, что они не буквальные.
ASCIIThenANSI
1
Я не думаю, что все это буквально. Тем не менее, я не думаю, что вы должны печатать числа, так как результат каждого фрагмента должен приводить к фактическому числу, которое можно использовать для дальнейших вычислений .
Деннис
3

Pyth, 35 34 33 байта

-1 байт @Mimarik

Есть несколько возможностей для некоторых программ.

0, 1 байт

Z

1, 2 байта

hZ
!Z

2,3 байта

hhZ
eCG
eCd
lyd
lyb
lyN

3, 3 байта

l`d

4, 3 байта

l`b
eCN

5, 4 байта

hl`b
telG

6, 3 байта

elG

7, 4 байта

tttT
helG

8, 3 байта

ttT

9,2 байта

tT

10, 1 байт

T

42, 4 байта

yhyT

Все они включают в себя либо базовые команды double ( y), +1 ( h) и -1 ( t), либо l(длина строки). Переменная Z инициализируется нулем.

Для 5 bинициализируется символом новой строки. Backtick дает "\n"(включая кавычки, и длина этой строки 4.

Попробуйте их здесь !

lirtosiast
источник
Пользователь Mimarik предложил сохранить байт на 42 с yhyT. (Я отклонил редактирование согласно meta.codegolf.stackexchange.com/questions/1615/… )
Мартин Эндер