당신이 이것을 좋아한다면, 참여를 고려하십시오 :

• 공식 Dyalog APL 2016 년 게임

• 월간 Dyalog APL 2017 코드 골프 챌린지

문자 그대로 숫자, 문자열 또는 문자 데이터를 쓰지 않고 같은 언어로 12 개의 스 니펫 / 표현식을 같은 언어로 각각 0에서 10, 42의 숫자로 만듭니다.

CJam의 U, X, Y, Z 및 A 상수 및 Processing의 BLEND, CHORD, CENTER, BREAK 및 LINES와 같은 PI()및 내장 데이터 ALPHABET()는 훌륭합니다.

모든 스 니펫은 독자적으로 설 수 있어야합니다. 즉, 상호 의존적이지 않을 수 있습니다. 그러나 단일 스 니펫 내에서 이름을 포함하는 문자열이 아닌 이름으로 직접 참조하는 한 변수를 할당하고 자유롭게 사용할 수 있습니다.

모든 스 니펫은 제출시 제출자의 컴퓨터에서 유효해야하지만 (SE에서보고 한대로) 디렉토리의 파일 수, 정확한 날짜 또는 시간 또는 사용자의 특정 입력과 같은 비정상적인 로컬 조건에 의존하지 않을 수 있습니다. .

유효한 스 니펫의 예

3 : INT(LOG10(YEAR(TODAY()))) 예측 가능한 미래에도 계속 유지되기 때문에
4 : CUBICROOT(LEN(CHARACTERSET())) 256 자 문자 세트가 매우 일반적 이기 때문에
8 : SQRT(SYSTEMTYPE())64 비트 시스템이 매우 일반적이기 때문에

잘못된 스 니펫의 예

5 : LEN(USERNAME()) 대부분의 사람들은“Admin”을 로그인으로 사용하지 않기 때문에 :-)
9 : LOG10(SYSTEMMEMORY())정확히 1GB의 메모리를 가진 시스템에서만 작동 하기 때문에
42 : CODE("*")문자열 / 문자 리터럴을 포함하기 때문에

각 스 니펫의 결과는 스 니펫과 동일한 언어를 사용하여 추가 계산에 사용할 수있는 실제 숫자 (값, int, float 등)를 가져와야합니다 (예 : 해당 숫자를 나타내는 텍스트 문자열이 아님).

문자 기반 언어 만 허용됩니다.

점수는 결합 된 12 개 스 니펫의 총 바이트 수입니다. 스 니펫을 구분하는 줄 바꿈은 포함되지 않습니다.

위의 규칙은 일부 언어가 튜링이 완료된 경우에도 참여하지 못하게 할 수 있습니다.

자주하는 질문

Q 프로그램이 입력을 받아 들일 수 있습니까?
A 예. 그러나 입력을 요청하고 관련 번호를 입력 할 수는 없습니다.

Q 물리 숫자 (비 데이터) 숫자가 허용됩니까? 예, 예 .
LOG10()

Q 루비의 기호는 리터럴로 간주됩니까? 예.

Q 각 스 니펫 사이에 줄 바꿈이 점수에 포함됩니까? 호

Q : TI-BASIC "문자 기반"이 유효합니까? 예.

Q 거짓과 참은 숫자 리터럴로 간주됩니까?
A 아니오, 허용됩니다.

Q 유일한 방법이고 함수의 출력에 영향을 미치지 않는 경우 숫자 리터럴을 사용하여 함수를 호출 할 수 있습니까?
A : 언어로 코드를 작성하는 일반적인 방법 인 경우 가능합니다.

Q 제 언어는 각 프로그램 / 표현의 시작에 [무언가] 있다고 가정합니다. 포함시켜야합니까, 아니면 프로그램 / 표현 중간에 배치 된 경우 내 스 니펫이 작동해야합니까?
A 프로그램 / 표현 중간에 작업해야합니다.

Q 정규식 리터럴은 어떻습니까?
A는 단지 정규 표현식에 할 언어를 제외하고 금지.

Q 지정된 숫자를 모두 인쇄 할 수있는 코드가 허용됩니까?
A 아닙니다. 서로 분리되고 상호 독립적이어야합니다.

Q 상용구 int main() {}...또는 이와 동등한 것으로 가정 할 수 있습니까? 예.

Q 어떤 출력 데이터 유형이 허용됩니까? 모든 수치 데이터 형, INT 같은 플로트 등

Q 각 스 니펫의 결과를 인쇄해야합니까?
A : 나중에 사용할 수 있도록 결과를 만드는 것으로 충분합니다.

Q 사전 설정 변수가 허용됩니까?
A 예, 모든 스 니펫에 대해 재설정 (변경된 경우)됩니다.

Q π와 e 는 숫자 리터럴로 간주됩니까?
A 아니요, 사용할 수 있습니다.

Q 42의 다른 셀에서 4와 2를 반환 할 수 있습니까?
A 아니요, 하나의 숫자로 연결해야합니다.

Q 바이트 또는 문자? 바이트,하지만 당신은 원하는 코드 페이지를 선택할 수 있습니다.

Q 월 J 등의 상수 함수와 변수 설정된 9:사실의 9한 꽈배기의이 9사용될?
A 예, 어휘가 유한 한 경우 (J의 경우 19, 실제로는 Pretzel의 경우 10)

Hexagony , 13 바이트

1
2
삼
4
5
6
7
8
9
10
42

온라인으로 사용해보십시오!

Hexagony에 0관통 9되어 기능 (10)에 의해 현재 메모리를 곱하고 다음 함수 이름으로 표시되는 번호를 추가한다. 따라서 첫 번째 스 니펫은 메모리가로 시작될 때 비어 0있습니다.

예를 들어, 현재 메모리가 65인 경우 기능 3을 실행 하면 현재 메모리가 653됩니다.

(공감 자에게 : 원하는 모든 것을 공감하십시오. 준비되었습니다.)

Funciton , 1222 바이트

숫자 리터럴 외에도 Funciton에서 값을 생성 할 수있는 두 가지 방법이 있습니다 : stdin 및 lambda 표현. Stdin은 단일 상자이지만 전체 람다 식에는 더 많은 구문이 필요하므로 stdin을 사용하겠습니다. 그러나 stdin은 무엇이든 가능하지만 어떤 입력이 제공되는지에 관계없이 다음 작업이 모두 작동합니다.

여기에 사용 된 모든 라이브러리 함수는 챌린지를 게시하기 전에 존재했습니다.

0 (UTF-16의 40 바이트)

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

이것은 원시 구문을 덜 사용합니다. 값은 그 자체보다 작지 않으므로 결과는 0입니다.

1 (UTF-16의 52 바이트)

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

⌑단일 요소를 포함하는 지연 시퀀스를 반환하고 요소 수를 ɕ계산합니다. (게으른 시퀀스는이 코드 조각이 실제로 stdin을 전혀 평가하지 않을 정도로 게으 릅니다!)

2 (UTF-16의 70 바이트)

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

= 2¹. ʂ시퀀스의 모든 서브 시퀀스를 생성하므로 n 개의 요소 시퀀스 를 2ⁿ와 1로 변환합니다.

3 (UTF-16의 88 바이트)

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

= 2 + 1. ♯값을 1 씩 증가시킵니다.

4 (UTF-16의 88 바이트)

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

= 2².

5 (UTF-16의 106 바이트)

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

= 4 + 1.

6 (UTF-16의 106 바이트)

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

= 3 계승.

7 (UTF-16의 110 바이트)

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

= A (2, 2) (애커 만 함수).

8 (UTF-16의 118 바이트)

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

= 2 << 2 (왼쪽 시프트).

9 (UTF-16의 128 바이트)

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

= 3 × 3.

10 (UTF-16의 146 바이트)

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

= 5 + 5.

42 (UTF-16의 170 바이트)

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

= 6 × (6 + 1).

자바 스크립트, 144 141 140 138 132 125 123 바이트

의 도움으로 @ edc65 , @Sjoerd 작업 Postmus , @DocMax , @usandfriends , @Charlie 윈 과 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>

Mouse-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+

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

-1 바이트를위한 @ MartinBüttner에게 감사합니다!

온라인으로 사용해보십시오!

Brainfuck, 70 바이트

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

각 줄은 개별적으로 실행해야합니다.

처음 10 개는 설명이 필요합니다. 각 플러스를 통해 셀 값을 증가시킵니다.

42는 훨씬 더 복잡합니다. 그것은 대부분의 brainfuck 인터프리터가 8 비트 셀을 사용한다는 사실에 의존합니다. 즉, 모든 연산이 모듈로 256을 수행한다는 것을 의미 --합니다. 셀 # 0을 254로 설정합니다. 그런 다음 셀 # 0이 0이 될 때까지 실행되는 루프에 들어갑니다. 각 반복 셀 # 1에 1을 더하고 셀 # 0에 6을 더합니다. 이 루프는 43 번 실행되므로 셀 # 1은 43입니다. 마지막으로 셀 # 1에서 1을 빼서 42로 만듭니다.

http://esolangs.org/wiki/Brainfuck_constants 에서 가장 효율적인 42 가지를 얻었습니다 .

어둠 , 339303 바이트

이곳은 어둠이 실제로 빛나는 곳 입니다. 알 겠어요? : ~)!

인쇄하지 않은 경우 ( \s첫 줄에서 공백이 다른 것으로 표시되지 않기 때문에 대체 됨 ) :

\s

█ 

██ 

███ 

████ 

█████ 

██████ 

███████ 

████████ 

█████████ 

██████████ 

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

인쇄시 :

■ 

█■ 

██■ 

███■ 

████■ 

█████■ 

██████■ 

███████■ 

████████■ 

█████████■ 

██████████■ 

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

이 경우 프로그램은 빛 (공백)에서 종료되므로 각 라인을 개별적으로 실행해야합니다. 그러나 동일한 프로그램에서 한 줄 또는 여러 줄로 이것을 작성할 수 있습니다.

Regular dark (█)는 레지스터를 1 씩 증가시키고 ■ 명령어 (일부 미니 어둠)는 레지스터의 내용을 출력합니다.

Perl 5, 86 75 71 66 바이트

모든 ^F문자는 리터럴 제어 문자 (ASCII에서는 0x06)이므로 단일 바이트입니다.

$[          # 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

11 바이트를 절약 한 msh210 과 9 바이트를위한 Dom Hastings 에 감사드립니다 !

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) 또는 사람은 ( l), 기본 크기는 1 × 1입니다. :벡터를 만들어 s합산하므로 K:s1에서 4까지의 벡터를 만들어 합산하여 10을 얻습니다. Yqn 번째 소수 함수이므로 KYq4 번째 소수 인 7입니다.

프롤로그, 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로 변환 된 다른 방식으로 결합합니다 .

편집 : 0-2에 float를 사용하여 14 바이트를 절약했습니다.

PHP, 157 (145) 91 바이트

Code Golf에 처음으로 글을 올렸을 때, 나는 그것을 한 번 보여줄 것이라고 생각했다. 나는 결국 더 나아질 것이다.

편집 : 세미콜론이 필요하지 않다는 것을 깨달았습니다.

EDIT2 : 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

파이썬 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에게 많은 감사합니다!

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}.Lengthand true.GetHashCode()and typeof(int).Name.Lengthand and uint.MinValue등과 같은 매우 다양한 아이디어를 가지고 있었지만 new int()모두 이겼습니다.

PowerShell, 147 바이트

이들은 +암묵적으로 물건을 정수로 캐스팅 하는 데 사용 합니다. 이후 숫자는 올바른 값을 갖는 PowerShell의 .Net Framework Unerpinnings의 Enum을 사용합니다.

+$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 - -bnotPowerShell에 있습니다.

• x^yPerl 답변 또는 x**yPython 또는 JavaScript ES7에 사용 된 지수 는 다음과 같습니다.[Math]::Pow($x,$y)

• 상수 전자 와 파이가 있는 문자 무거운 [Math]::E및[Math]::PI

DC , 35 바이트

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

스 니펫을 테스트하려면 a f를 추가 하여 스택을 인쇄하고 해당 문자열을 dc다음으로 전달하십시오 .

$ echo 'EdE++f' | dc
42

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에서 시작합니다.

수학 상수 π는 1 바이트 이지만 e2 바이트입니다.

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

수학 ++, 총 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)

자바 (브라우저 봉투) 155 136 130 바이트

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

덕분에 :
@ Ismael Miguel : 155- > 136-> 130 바이트

진심으로, 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))

프로그램의 16 진 덤프 :

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

6 바이트의 퀴 토피아 덕분입니다!

dc, 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[@]}"

Mathematica, 101 바이트

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

나는 이것들 중 일부가 차선책이라고 확신한다. 그 둥근 괄호는 정말 비싸다.

일관성을 위해, 처음 두도 수 E-E와 E/E물론,하지만 난 그것을 얻기 위해 매우 멋진의 생각 0과 1정의되지 않은 변수를 계산에서.

Japt , 34 33 30 바이트

@ThomasKwa 덕분에 1 바이트 절약

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
°    ++
´    --

놀라운 , 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

> <> , 86 바이트

• 0 : ln;
• 1: lln;
• 2 : llln;
• 삼: 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;

리터럴을 얻기 위해 스택 크기에 의존합니다.

MS 엑셀 수식 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 : 워크 시트의 나머지 부분이 비어 있다고 가정하면 빈 셀에 대한 참조를 0으로 다시 사용할 수 있습니다. 모호한 유형.

DUP , 68 바이트

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

Try it here.

이 작업을 수행하는 방법이 많이 있지만이 스택에 대한 반환 스택을 남용하고 있습니다.

설명

이를 완전히 파악하려면 람다에 대한 DUP의 동작을 이해해야합니다. 람다 자체를 스택으로 푸시하는 대신 람다가 감지되면 실제로 현재 IP를 스택으로 푸시합니다. 람다가 포함 된 첫 3 개의 스 니펫을 설명 할 수 있습니다.

다음 스 니펫은 리턴 스택을 사용합니다. 경우 !실행되고, IP는 현재 리턴 스택에 푸시되고, 스택의 최상위가 람다 실행을 시작하는 새로운 IP로 설정된다. )반환 스택에서 데이터 스택으로 숫자를 표시합니다.

나머지 스 니펫을 설명하기에 충분합니다. 그래도 얻을 수 없다면 Step버튼이 매우 편리 하다는 것을 명심하십시오 !

05AB1E, 40 38 24 바이트

¾
X
Y
XÌ
Y·
T;
T;>
T;Ì
TÍ
T<
T
žwT+

• counter_variable 푸시
• 푸시 1
• 푸시 2
• 1 + 2 푸시
• 푸시 2 * 2
• 푸시 10/2
• 푸시 (10/2) +1
• 푸시 (10/2) +2
• 푸시 10-2
• 푸시 10-1
• 푸시 10
• 32, 10을 누르고 추가

D1ffe7e45e , 112

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

각 줄은 다른 스 니펫입니다.

프로그램의 숫자는 명령으로 만 사용되므로 숫자 리터럴로 계산되지 않습니다.

마지막은 확실히 더 골프를 칠 수 있습니다.

편집 : 통역사가 작동하고 모든 발췌 문장이 작동합니다. 직접 테스트하고 싶다면 0f0f스 니펫 끝에 추가 하여 프로그램을 종료하십시오.

Pyth, 35 34 33 바이트

@Mimarik에 의해 -1 바이트

일부 프로그램에는 여러 가지 가능성이 있습니다.

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

이 모든 것에는 기본 이중 ( y), +1 ( h) 및 -1 ( t) 명령 또는 l(문자열 길이)가 포함됩니다. Z 변수는 0으로 초기화됩니다.

5의 b경우 개행 문자로 초기화됩니다. 백틱은 "\n"따옴표를 포함하고 해당 문자열의 길이는 4입니다.

여기에서 사용해보십시오 !