Jeśli Ci się spodoba, rozważ udział w:

• Dziennik Dyalog APL 2016 Rok gier

• Miesięcznik Dyalog APL 2017 Code Golf Challenge

Wykonaj 12 urywków / wyrażeń w tym samym języku, które dają odpowiednio cyfry od 0 do 10 i 42, ale bez pisania literowych danych liczbowych, łańcuchowych lub znaków.

Wbudowane dane, takie jak PI()i ALPHABET(), są w porządku, podobnie jak np. Stałe U, X, Y, Z i A w CJam oraz BLEND, AKORD, CENTRALNY, PRZERWA i LINIE.

Każdy fragment musi być w stanie samodzielnie działać, tzn. Nie może być od siebie zależny. Jednak wewnątrz jednego fragmentu możesz przypisać zmienną i używać jej dowolnie, o ile odwołujesz się do niej bezpośrednio po nazwie, a nie poprzez ciąg znaków zawierający jej nazwę.

Wszystkie fragmenty muszą być poprawne na komputerze osoby przesyłającej w momencie przesyłania (zgodnie z raportem SE), ale nie mogą opierać się na nietypowych lokalnych warunkach, takich jak liczba plików w katalogu, dokładna data lub godzina lub określone dane wprowadzone przez użytkownika .

Przykłady prawidłowych fragmentów

3: INT(LOG10(YEAR(TODAY()))) ponieważ pozostaje prawdą w dającej się przewidzieć przyszłości
4: CUBICROOT(LEN(CHARACTERSET())) ponieważ zestaw znaków 256 liter jest bardzo powszechny
8: SQRT(SYSTEMTYPE()) ponieważ systemy 64-bitowe są bardzo powszechne

Przykłady nieprawidłowych fragmentów

5: LEN(USERNAME()) ponieważ większość ludzi nie używa „Admin” jako loginu :-)
9: LOG10(SYSTEMMEMORY()) ponieważ działa tylko w systemach z dokładnie 1 GB pamięci
42: CODE("*") ponieważ zawiera literał ciąg / znak

Wynik każdego fragmentu musi skutkować faktyczną liczbą (wartość, liczba całkowita, liczba zmiennoprzecinkowa itp.), Której można użyć do dalszych obliczeń w tym samym języku co fragment kodu, tj. Nie może to być ciąg tekstowy reprezentujący tę liczbę.

Dozwolone są tylko języki oparte na znakach.

Wynik to łączna liczba bajtów wszystkich 12 urywków łącznie. Nowe linie oddzielające fragmenty nie są liczone.

Pamiętaj, że powyższe zasady mogą uniemożliwić udział niektórych języków, nawet jeśli są one ukończone.

FAQ

P Czy programy mogą akceptować jakiekolwiek dane wejściowe? Tak, ale nie może po prostu poprosić o wejście i wpisać odpowiedni numer.

P Czy dozwolone są cyfry fizyczne (bez danych)? Tak, np .
LOG10()

P Czy symbole w Rubim liczą się jako literały? Tak.

P Czy wynik zawiera znaki nowej linii między każdym fragmentem? No.

P Czy TI-BASIC „oparty na znakach” jest wystarczający, aby był ważny? Tak.

P Czy fałsz i prawda są liczone jako literały liczbowe?
O Nie, są do zaakceptowania.

P Czy możemy użyć literału liczbowego do wywołania funkcji, jeśli jest to jedyny sposób, a liczba nie wpływa na wynik funkcji? Tak, jeśli to jest normalny sposób pisać kod w języku polskim.

P Mój język zakłada, że ​​na początku każdego programu / wyrażenia jest [coś]. Czy muszę to uwzględnić, czy moje fragmenty powinny po prostu działać, jeśli zostaną umieszczone w środku programu / wyrażenia?
A Powinny po prostu działać w środku programu / wyrażenia.

P: Co z literałami regularnymi? Zabronione, z wyjątkiem języków zrobić tylko regexes.

P Czy akceptowalny jest jeden fragment kodu, który mógłby wydrukować wszystkie podane liczby?
O Nie, muszą być one odrębne i wzajemnie niezależne.

P Czy mogę założyć płytę kotłową podobną int main() {}...lub równoważną? Tak.

P Jakie typy danych wyjściowych są dozwolone?
A Dowolny typ danych liczbowych, taki jak int, float itp.

P Czy muszę wydrukować wynik każdego fragmentu?
O Nie, udostępnienie wyniku do późniejszego wykorzystania wystarczy.

P Czy dozwolone są wstępnie ustawione zmienne?
A Tak i zostaną zresetowane (jeśli zostaną zmienione) dla każdego fragmentu.

P Czy π i e są uważane za literały liczbowe?
A Nie, możesz ich użyć.

P Czy mogę zwrócić 4 i 2 w różnych komórkach dla 42?
O Nie, muszą być połączone jako jeden numer.

Q Bajty lub postacie? Bytes, ale można wybrać dowolną stronę kodową.

P Czy można stosować funkcje stałe i wstępnie ustawione zmienne, takie jak J 9:, faktycznie 9i Pretzel 9?
A Tak, jeśli słownictwo jest skończone (19 dla J, 10 dla Faktycznie i Precla).

Sześciokąt , 13 bajtów

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

Wypróbuj online!

W Hexagony, 0przez 9to funkcje, które mnożą bieżącą pamięć przez 10, a następnie dodają liczbę reprezentowaną przez nazwę funkcji. Dlatego pierwszy fragment jest pusty, ponieważ wspomnienia zaczynają się jako 0.

Na przykład, jeśli bieżąca pamięć jest 65, wykonanie funkcji 3spowoduje utworzenie bieżącej pamięci 653.

(Do downvoters: oddaj głos, ile chcesz; jestem gotowy.)

Funciton , 1222 bajty

Oprócz literałów numerycznych, istnieją dwa sposoby na uzyskanie wartości (dowolnej wartości) w Funciton: wyrażenia stdin i lambda. Stdin jest pojedynczym polem, podczas gdy pełne wyrażenie lambda wymaga większej składni, więc wybieram stdin. Jednakże, chociaż standardowe wejście może być czymkolwiek, wszystkie poniższe czynności działają niezależnie od tego, jaki wkład zostanie podany.

Wszystkie użyte tutaj funkcje biblioteczne istniały przed opublikowaniem wyzwania.

0 (40 bajtów w UTF-16)

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

Używa surowej składni dla mniej niż. Wartość nigdy nie jest mniejsza niż sama, dlatego wynikiem jest 0.

1 (52 bajty w UTF-16)

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

⌑zwraca leniwą sekwencję zawierającą pojedynczy element i ɕzlicza liczbę elementów. (Leniwa sekwencja jest na tyle leniwa, że ​​ten fragment w ogóle nie ocenia standardowego wejścia!)

2 (70 bajtów w UTF-16)

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

= 2¹. ʂgeneruje wszystkie podsekwencje sekwencji, a tym samym zamienia sekwencję n elementów w jeden z 2ⁿ.

3 (88 bajtów w UTF-16)

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

= 2 + 1. ♯zwiększa wartość o 1.

4 (88 bajtów w UTF-16)

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

= 2².

5 (106 bajtów w UTF-16)

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

= 4 + 1.

6 (106 bajtów w UTF-16)

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

= 3 silnia.

7 (110 bajtów w UTF-16)

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

= A (2, 2) (funkcja Ackermanna).

8 (118 bajtów w UTF-16)

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

= 2 << 2 (shift-left).

9 (128 bajtów w UTF-16)

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

= 3 × 3.

10 (146 bajtów w UTF-16)

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

= 5 + 5.

42 (170 bajtów w UTF-16)

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

= 6 × (6 + 1).

JavaScript, 144 141 140 138 132 125 123 bajtów

Z pomocą @ edc65 , @Sjoerd Job Postmus , @DocMax , @usandfriends , @Charlie Wynn i @ 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>

Mysz-2002 , 27 26 17 14 bajtów

Pierwsze fragmenty wypychają 0-10, a następnie ZR+wypychają i są .251725 17 + 42 =1

A
B
C
D
E
F
G
H
I
J
K
ZR+

CJam, 27 24 bajtów

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

Dzięki @ MartinBüttner za -1 bajtów!

Wypróbuj online!

Brainfuck, 70 bajtów

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

Każda linia musi być uruchamiana indywidualnie.

Pierwsze 10 jest oczywiste: zwiększamy wartość komórki za pomocą każdego plusa.

42 jest o wiele bardziej złożony. Opiera się na fakcie, że najbardziej szalony interpreter używa komórek 8-bitowych, co oznacza, że ​​wszystkie operacje na nim są wykonywane modulo 256. --Ustawia komórkę od 0 do 254. Następnie wchodzimy do pętli, która biegnie, aż komórka # 0 wynosi 0. Każda iteracja dodaje 1 do komórki nr 1 i dodaje 6 do komórki nr 0. Ta pętla działa 43 razy, więc komórka nr 1 ma 43. Na koniec odejmujemy 1 od komórki nr 1, aby uzyskać 42.

Mam najbardziej wydajną 42, jaką kiedykolwiek znaleziono, ze strony http://esolangs.org/wiki/Brainfuck_constants

Ciemność , 339 303 bajtów

Tutaj naprawdę świeci Ciemność . Zdobyć? : ~)!

Bez drukowania (zastąpiono spacją \sw pierwszym wierszu, ponieważ nie będzie inaczej):

\s

█ 

██ 

███ 

████ 

█████ 

██████ 

███████ 

████████ 

█████████ 

██████████ 

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

Z nadrukiem:

■ 

█■ 

██■ 

███■ 

████■ 

█████■ 

██████■ 

███████■ 

████████■ 

█████████■ 

██████████■ 

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

W takim przypadku każda linia musi być uruchamiana osobno, ponieważ program kończy się w świetle (spacja). Można jednak napisać to w jednym lub kilku wierszach tego samego programu.

Regularna ciemność (█) zwiększa rejestr o 1, a instrukcja ■ (pewien rodzaj mini ciemności) wyświetla zawartość rejestru.

Perl 5, 86 75 71 66 bajtów

Wszystkie ^Fs to dosłowne znaki kontrolne (0x06 w ASCII), a zatem pojedynczy bajt.

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

Dzięki msh210 za zapisanie 11 bajtów i Dom Hastings za 9 bajtów!

MATL, 30 bajtów

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

H, Ii Ksą predefiniowanymi stałymi dla 2, 3 i 4 (jak pi). Oi lsą funkcjami, które zwracają macierz zer ( O) lub jedynek ( l), domyślny rozmiar to 1x1. :tworzy wektor i ssumuje go, więc K:stworzy wektor od 1 do 4 i sumuje go, aby uzyskać 10. Yqjest n-tą funkcją pierwszą, podobnie KYqjak 4-ta liczba pierwsza, 7.

Prolog, 113 99 bajtów

Fragmenty:

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

Łączy stałe matematyczne e i pi na różne sposoby konwertowane na int.

Edycja: Zapisano 14 bajtów, używając liczb zmiennoprzecinkowych dla 0-2.

PHP, 157 145 91 bajtów

Po raz pierwszy pisząc na Code Golf, pomyślałem, że dam temu szansę. W końcu poprawię się: P Jeśli zobaczysz jakieś oczywiste (dla ciebie) miejsca, w których mógłbym ocalić postacie, daj mi znać.

EDYCJA: Zdałem sobie sprawę, że nie potrzebowałem średników, ponieważ są to tylko fragmenty.

EDIT2: Podziękowania dla Blackhole za wiele sugestii!

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

Python 2, 191 159 158 157 156 149 146 bajtów

Moje pierwsze zgłoszenie, mam nadzieję, że wszystko mi się udało! Biorąc pod uwagę czas spędzony na tym, wydaje mi się, że dla niektórych z nich jest lepszy.

# 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

Wielkie dzięki dla FryAmTheEggman!

C #, bez użycia, 234 bajty

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

To jest o wiele bardziej nudne, niż początkowo myślałem. Miałem dość zróżnicowane pomysły, jak new[]{true}.Lengthi true.GetHashCode()i typeof(int).Name.Lengthi uint.MinValueitd., Ale new int()pokonać je wszystkie.

PowerShell, 147 bajtów

Służą one +do niejawnego rzutowania rzeczy na liczby całkowite. Późniejsze numery używają Enums z .NET Framework unerpinnings programu PowerShell, które mają właściwe wartości.

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

• -~-~-~użyte w JavaScript, C # i PHP byłyby - -bnot - -bnot - -bnotw PowerShell.

• x^yx**ybyłoby potęgowanie używane w odpowiedziach Perla lub w Pythonie lub JavaScript ES7[Math]::Pow($x,$y)

• stałe e i Pi są znakami ciężkimi [Math]::Ei[Math]::PI

DC , 35 bajtów

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

Aby przetestować fragmenty, dodaj a, faby wydrukować stos i przekazać ten ciąg do dc:

$ echo 'EdE++f' | dc
42

TI-BASIC, 41 bajtów

0 ~ 10:

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

42:

int(π²/ecosh(π

W TI-BASIC wszystkie niezainicjowane zmienne jednoliterowe zaczynają się od 0, a Xmax(prawa granica okna ekranu wykresu) zaczyna się od 10.

Stała matematyczna πto jeden bajt , ale edwa bajty.

Python 2, 306 275 274 bajtów

Wykorzystałem fakt, że dla dowolnego x (liczba całkowita, a nie 0) wyrażenie x/xwynosi 1 i bawiłem się kilkoma bitowymi operacjami.

Skorygowałem fragmenty tak, aby nadal spełniały wymagania (dzięki @nimi to zaoszczędziło mi 24 bajty), ale trzeba je ręcznie przetestować. Oto kod i liczba pojedynczych bajtów:

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

Matematyka ++, łącznie 92 bajty

0 (1 bajty): a

1 (2 bajty):!a

2 (3 bajty):_$e

3 (4 bajty): _$pi

4 (7 bajtów): _$e+_$e

5 (8 bajtów): _($e+$e)

6 (9 bajtów): _$pi+_$pi

7 (8 bajtów): _($e*$e)

8 (9 bajtów): _($e*$pi)

9 (10 bajtów): _($pi*$pi)

10 (12 bajtów): _$e*_($e+$e)

42 (19 bajtów): _($pi+$pi)*_($e*$e)

JavaScript (środowisko przeglądarki), 155 136 130 bajtów

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

Dzięki:
@Ismael Miguel : 155 -> 136 -> 130 bajtów

Poważnie, 39 33 bajtów

W nawiasach podano objaśnienia:

 (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))

Szesnastkowe zrzuty programów:

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

Dzięki kwintopii na 6 bajtów!

dc, 42 bajty

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

Wyniki

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

Nie ma wielu sposobów na generowanie nowych liczb za pomocą DC. Używam O: baza wyjściowa, początkowo 10; K: precyzja, początkowo 0; zgłębokość stosu, początkowo 0; Zznaczące cyfry operandu. Łączymy je ze zwykłymi operatorami arytmetycznymi.

Program testowy

#!/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 bajtów

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

Jestem pewien, że niektóre z nich są nieoptymalne. Te zaokrąglone wsporniki są naprawdę drogie.

Dla spójności, pierwsze dwa może być również E-Ei E/Eoczywiście, ale myślałem, że to całkiem ładne dostać 0i 1od obliczeń z niezdefiniowanych zmiennych.

Japt , 34 33 30 bajtów

1 bajt zapisany dzięki @ThomasKwa

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

Oto, co oznaczają poszczególne znaki:

T    0
A    10
B    11
C    12
D    13
E    14
F    15
G    16
H    32
I    64
q    sqrt on numbers
°    ++
´    --

Cudowny , 98 bajtów

Nie jest to szczególnie ekscytujące, opiera się na ?nurządzeniach, które zamieniają dowolny marmur w losową wartość w zakresie 0..n (włącznie) efektem ubocznym jest to, że ?0zamienia każdy marmur w 0 bez względu na wejście. Myślę, że użycie literałów jest dozwolone, ponieważ wartość nie wpływa na wynik i nie ma innego sposobu na wywołanie funkcji raz w 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 bajtów

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

Opiera się na wielkości stosu, aby uzyskać jego literały.

Formuły MS Excel, 163 151 150 143 bajtów

Nie do końca język programowania, ale proszę bardzo ...

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()jest używany w większości przypadków, ponieważ jest to krótszy (jestem tego świadom) sposób na wprowadzenie wartości liczbowej bez użycia literału liczbowego lub łańcuchowego. Nkonwertuje różne rzeczy (w tym logiczne) na liczby i Tkonwertuje różne rzeczy na tekst. TYPEzwraca 2 dla argumentu tekstowego i 4 dla argumentu boolowskiego. TRUNCodrzuca część ułamkową (tj. zaokrągla liczby dodatnie w dół), EVENzaokrągla w górę do następnej liczby parzystej i ODDzaokrągla w górę do następnej liczby nieparzystej. CODE(-PI())to kod ASCII pierwszego znaku konwersji na tekst -π, tj. 45 (dla „-”).

EDYCJA: Usunięto znaki równości z liczby bajtów (-12!) - jak wskazał Nᴮᶻ w komentarzach, nie należy ich uwzględniać.

EDYCJA 2: Zakładając, że reszta arkusza jest pusta, możliwe jest użycie odwołania do pustej komórki jako zera (ponownie, sugerowane przez Nᴮᶻ) pod warunkiem, że uwzględnimy znak minus (lub użyjemy go w innym wyrażeniu liczbowym), aby rozwiązać niejednoznaczność typu.

DUP , 68 bajtów

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

Try it here.

Istnieje wiele sposobów, aby to zrobić, ale nadużywam stosu zwrotu dla tego.

Wyjaśnienie

Aby to w pełni zrozumieć, musisz zrozumieć zachowanie DUP dotyczące lambd. Zamiast wypychać samą lambdę do stosu, w rzeczywistości wykrywa ona lambda na stosie, kiedy to wykryje. To może wyjaśnić pierwsze 3 fragmenty, które dotyczą lambd.

Następne fragmenty używają stosu zwrotnego. Po !wykonaniu bieżący adres IP jest wypychany do stosu zwrotnego, a górna część stosu jest ustawiana jako nowy adres IP w celu rozpoczęcia wykonywania lambda. )wyskakuje liczba ze stosu zwrotnego na stos danych.

To wystarczy, aby wyjaśnić resztę fragmentów. Jeśli nadal go nie masz, pamiętaj, że Stepprzycisk jest całkiem przydatny!

05AB1E, 40 38 24 bajtów

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

• Wciśnij counter_variable
• Naciśnij 1
• Naciśnij 2
• Naciśnij 1 + 2
• Naciśnij 2 * 2
• Naciśnij 10/2
• Naciśnij (10/2) +1
• Naciśnij (10/2) +2
• Naciśnij 10-2
• Naciśnij 10-1
• Naciśnij 10
• Naciśnij 32, 10, dodaj

D1ffe7e45e , 112

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

Każda linia to inny fragment kodu.

Liczby w programie nie liczą się jako literały liczbowe, ponieważ są używane tylko jako polecenia.

Ostatnią można zdecydowanie pograć w golfa.

EDYCJA: Mam tłumacza działającego i wszystkie fragmenty działają. Jeśli chcesz sam sprawdzić, dodaj 0f0ffragment kodu, aby program się zakończył.

Pyth, 35 34 33 bajtów

-1 bajt @Mimarik

Istnieje kilka możliwości dla niektórych programów.

0, 1 bajt

Z

1, 2 bajty

hZ
!Z

2, 3 bajty

hhZ
eCG
eCd
lyd
lyb
lyN

3, 3 bajty

l`d

4, 3 bajty

l`b
eCN

5, 4 bajty

hl`b
telG

6, 3 bajty

elG

7, 4 bajty

tttT
helG

8, 3 bajtów

ttT

9, 2 bajty

tT

10, 1 bajt

T

42, 4 bajty

yhyT

Wszystkie one obejmują albo podstawowe polecenia double ( y), +1 ( h) i -1 ( t), albo l(długość łańcucha). Zmienna Z jest inicjowana do zera.

Dla 5 bjest inicjowany znakiem nowej linii. Backtick daje "\n"(łącznie z cudzysłowami, a długość tego ciągu wynosi 4.

Wypróbuj je tutaj !