이것은 재미 있었다! 그러나 세 자리 숫자만으로도 재미는 너무 빨리지나 갔다. 이 도전은 비슷하지만, 우리는 재미를 계속할 것입니다.

도전

가능한 한 Golden Ratio φ의 자릿수를 인쇄 하십시오. 황금 비율은 φ = (φ + 1) / φ를 만족하는 숫자로 정의되며 처음 100 자리 숫자는 다음과 같이 지정됩니다.

1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911375 ...

이 도전은 φ 계산에 관한 것이 아닙니다 ! 두 번 수행하는 방법을 사용하지 않고 가능한 한 많은 자릿수를 인쇄하는 것입니다. 따라서 가능한 한 많은 창의적인 방법으로 숫자를 얻으십시오!

제한 사항

그 자체로 φ의 숫자를 인쇄하는 것은 약간 간단하므로 다음 규칙이 있습니다.

1. 당신은 번호를 구성해야 순서를 왼쪽에서 오른쪽으로 , 하나 그것을 조각으로 조각을 인쇄 또는 왼쪽에서 오른쪽으로 문자열을 구성하고 마지막에 인쇄하여 - 당신은 심지어 가입 후 자리 문자의 배열을 생성 할 수 및 순서대로 인쇄하는 한 인쇄하십시오. 다음 규칙에서 "print"및 "output"은 해당 프로세스 중 하나를 참조 할 수 있습니다 (예 : 문자열을 작성하고 있고 문자열에 이미 인쇄 된 1.6것으로 계산 된 문자열이 포함 1.6된 경우).
2. 코드의 경우 숫자 당 15 문자 의 예산을 얻습니다 . 기간은 해당 예산에 포함되지 않지만 인쇄되어야합니다. 제한은 총 코드 크기에만 적용됩니다. 평균을 더 많이 사용하지 않는 한 모든 숫자에 15자를 초과 할 수 있습니다. 실제로, 당신은 문자로 "부채"를 쌓고 나중에 "지불"할 수 있습니다. 예를 들어 60 자를 인쇄 1.618할 수 있습니다 .
3. 표준 라이브러리 포함 / 가져 오기는 코드 크기에 포함되지 않습니다. 그러나 이러한 속기 별칭을 무료로 제공 할 수는 없습니다!
4. 현재 생성중인 숫자 나 이미 인쇄 한 숫자를 사용해서는 안됩니다. 예를 들어 1소스 코드의 첫 번째 자리이기 때문에 소스 코드의 아무 곳에도 표시되지 않을 수 있습니다. 상기 출력 코드 8의 1.618숫자 중 임의의 것 또는 모두를 사용할 수 [0234579]있지만 없음 [168]. 이를 위해 단일 숫자 와 동일한 모든 리터럴이 해당 숫자로 처리 됩니다 . 그래서 언어를 대표 할 수있는 경우 9로 '\t'당신은 당신이 사용하지 수있는 어디서든 사용 할 수 없습니다 9대신합니다.
5. 한 번에 여러 자리 숫자를 생성해서는 안됩니다. 한 번에 한 자리 숫자를 생성하는 청크로 코드를 명확하게 분할 할 수 있어야합니다.

6. 내장 함수, 수학 / 부울 / 비트 단위 / 문자열 연산자, 이전 숫자를 생성 한 코드에서 사용한 변수 또는 상수를 참조하면 안됩니다 . 정수에서 문자열로의 변환, 문자열 연결 및 인쇄 기능은 모든 자릿수에 필요할 수 있습니다. 이되는 중요하지 않습니다 이름 이 참조하는 모든 내장 : 당신 때문에 별명 A의 내장 PI모두 p와 q사용할 수 의미하지 않는다 p번과 q번. 마찬가지로, 당신이 하는 이 문자열과 같은 두 가지 내장 기능을 참조하는 경우에 두 번 이름을 사용할 수 length와 배열 length.

   _{프로그래밍 언어에 함수가없는 경우 bash 스크립팅의 경우 그와 동등한 것이 무엇인지에 대한 최선의 판단을 사용하십시오. 다른 프로그램을 호출하면 함수에 부과 된 규칙을 따라야합니다.}

7. 제출물은 단일 언어로 작성해야합니다. 따라서 해당 언어의 내장 기능에 액세스하기 위해 다른 언어의 통역사를 실행하지 않습니다.

시사점

위의 규칙은 다음 사항을 모두 암시하지만 샌드 박스에서 이미 발생한 질문을 피하기 위해 여기에 추가합니다.

• '\b'사이에 일부 백 스페이스 (일반적으로 )를 인쇄하여 출력의 일부를 덮어 쓸 수 없습니다 .
• 여러 자릿수를 생성 / 출력하는 루프는 금지되어 있습니다. (단 한 자리를 계산하는 루프는 괜찮습니다.)
• 난독 처리 된 버전을 사용 (1 + √5)/2하거나 피보나치 수를 두 자리 이상으로 나누는 것은 금지되어 있습니다.
• 10 자리를 미리 계산하고 10 개의 변수에 저장 한 다음 변수를 참조 하면 숫자를 생성 하지 않으므로 변수를 채우는 코드는 숫자 6을 위반하므로 규칙 6을 위반합니다.
• 실제로 이전 (또는 중간 결과)을 재사용 할 수 없습니다. 두 자리수가 생성 되는 코드를 공유한다는 의미이기 때문입니다 .
• 그렇지 않으면, 숫자를 생성하기 위해 어떤 수단을 사용해도됩니다 (순수하게 수학 할 필요는 없음). (그리고 당신은해야합니다!)
• 표준 라이브러리를 사용하여 여러 곳에서 올바른 자리를 뽑을 수 있다면 실제로 아무것도 계산할 필요가 없습니다.
• 당신은 할 수 있습니다 하나의 숫자를 생성하는 동안 그래서, 연산자를 여러 번 사용하는 2+2+2첫 번째를 생성하는 공정한 게임이다 6(이 짧은 같지도 않지만).
• 리터럴은 내장 상수가 아니기 때문에 원하는만큼 리터럴을 사용할 수 있습니다 . 따라서 인쇄 할 필요가없는 한 코드에서 원하는 5만큼 을 인쇄 할 수 있습니다 5.
• 출력하는 숫자를 사용하기 때문에 출력을 하드 코딩 할 수 없습니다.

간단히 말해서 : 숫자를 두 번 생성하는 방법을 사용하지 말고 현재 출력하거나 이미 인쇄 한 숫자를 사용하지 마십시오.

만약 당신이 무한한 점수를 얻을 수있는 허점을 발견한다면, 그것을 이용하여 도전을 망치지 말고, 허점을 수정하지 않고 허점을 고칠 수 있는지 알려주십시오.

채점

가장 높은 자릿수를 올바르게 인쇄하는 프로그램이 이깁니다. 동점 인 경우 짧은 코드는 동점을 끊습니다.

코드의 어느 부분이 어떤 숫자를 생성하는지 식별하는 주석이없는 주석 처리 된 버전을 추가하십시오.

추신 : 누군가 100 위의 숫자를 초과하면 여기에 더 있습니다.

PHP, 100 자리

아마 여기서 규칙을 약간 구부릴 수도 있지만 PHP에는 수십 가지 상수가 있습니다.

<?php
echo TRUE . '.' . PM_STR . DNS_A . MSG_EOR . LC_ALL . T_FMT . LOCK_UN . SQL_DATE
. E_NOTICE . IMG_WBMP . INI_ALL . E_PARSE . SOCKET_EBADF . LOG_USER .
IMAGETYPE_JPC . IMG_PNG . GLOB_MARK . LOCK_NB . LOG_NDELAY . D_FMT . PHP_ZTS .
GLOB_ERR . AM_STR . SQL_DOUBLE . SOL_TCP . FILE_APPEND . LOG_ERR . SORT_ASC .
SOCK_RAW . LOG_INFO . LC_TIME . SQL_FLOAT . SORT_DESC . INFO_MODULES . E_ERROR .
IMG_GIF . SQL_REAL . LOG_DEBUG . DNS_NS . CODESET . CAL_FRENCH . CURLE_OK .
LDAP_OPT_RESTART . LOCK_SH . XML_PI_NODE . SQLITE_INTERRUPT . MYSQLI_ASYNC .
CURLM_OK . SNMP_NULL . SQLITE_NOMEM . LC_MESSAGES . IMG_JPG . SO_KEEPALIVE .
SOCKET_ENXIO . LOCK_EX . D_T_FMT . ENT_QUOTES . LOG_NOTICE . SOCK_RDM .
INPUT_ENV . CURLAUTH_NTLM . INPUT_SESSION . AF_INET . IMG_JPEG . SQL_CONCURRENCY
. SEEK_SET . SOCKET_EIO . LC_CTYPE . PHP_URL_QUERY . LOG_KERN . INI_SYSTEM .
IMAGETYPE_BMP . SEEK_END . JSON_HEX_QUOT . LOG_PID . LIBXML_DTDATTR .
XML_DOCUMENT_NODE . PHP_DEBUG . LOG_CRIT . ENT_IGNORE . LC_NUMERIC .
DOM_NOT_SUPPORTED_ERR . PHP_URL_FRAGMENT . FILE_TEXT . IMAGETYPE_TIFF_II .
LOG_CONS . LOG_EMERG . UPLOAD_ERR_CANT_WRITE . MSG_PEEK . SQLITE_OK . FNM_PERIOD
. AF_UNIX . CURLPROTO_FTPS . STREAM_NOTIFY_FAILURE . MYSQL_BOTH .
CURLE_FTP_ACCESS_DENIED . MSG_OOB . FTP_TEXT . LC_MONETARY .
CURLE_COULDNT_CONNECT . SQLITE_BUSY . "\n";

이것은 아마도 휴대용 코드는 아니지만 내 시스템에서는 제대로 작동합니다. 이를 생성 한 코드는 다음과 같습니다.

<?php
$phi = "6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911375";
echo "<?php\necho TRUE . '.' . ";
$consts = get_defined_constants();
foreach($consts as $k=>$v) if (preg_match('/\d|TRUE|PHP_EOL/',$k)) unset($consts[$k]);
for ($p=0;$p<strlen($phi);$p++) {
  $d = ord($phi[$p]) - 48;
  $min = 999;
  foreach($consts as $k=>$v) {
    if (strlen("$v")==1 && $v==$d && strlen($k)<$min) {
      $min = strlen($k);
      $maxk = $k;
    }
  }
  if ($min==999) break;
  echo "$maxk . ";
  unset($consts[$maxk]);
}
echo "\"\\n\";\n";

펄-37 자리

use Math::Trig;
use POSIX;

print
  !0,'.',chop$=||$=,A==A,2**3,$|,++$^F,75/5/5,pi*pi%\_,4+4,a^Y,w&'?',~"\xcb",$^=~y/_//c,
  ord"\b",unpack(h,"\t").@{[c,c,c,c]},$#{[b..j]},"$^W"|'$',$^H>>log$^H,cos()- -cos,$[,
  $-=sqrt%SIG,$%=$],$+[*$=~/($)/],split('',$~).map(glob,"{,,,}{,}"),index(\L,L),
  exp(exp)<<exp,ceil(sinh acosh$^C).keys{stat$0},rindex(\R,R),($s=ssssss)=~s/s//g,
  $?=acos(--$z),$^T=pack(u,$^T.$^T.TTTT),B~~B,C<=C,length$^V,

현재 392 바이트 (자리 당 10.6).

산출:

1.618033988749894848204586834365638117

자체 부과 제한

문제를 사소하게 만드는 언어 기능의 사용을 제한하기 위해 몇 가지 추가 제한 사항을 추가했습니다. 예를 들어, 배열 역 참조 @{...}및 배열 최종 색인 $#{...}은 한 번만 사용됩니다. 사용 된 각각의 어레이는 상이한 방식으로 생성된다 (비교 [c,c,c,c], [b..j], split('',$~), map(glob,"{,,,}{,}")). 또한 챌린지 설명에서 명시 적으로 허용되지만 심볼 또는 베어 워드는 두 번 이상 사용되지 않습니다. 나는 암시 적 int 변환의 수를 제한하기 때문에 perl (또는 int 전용 특수 변수가있는 언어 (다른 언어가 있습니까?))에 대해 좋은 생각이라고 생각합니다.

조각

!0                       # returns 1
'.'
chop$=||$=               # $= is 60, chop the 0, returns 6
A==A                     # returns 1 (because 0==0)
2**3                     # returns 8
$|                       # auto flush, returns 0
++$^F                    # max system filehandle pre-incremented, returns 3
75/5/5                   # returns 3
pi*pi%\_                 # pi² mod a large value, returns 9
4+4                      # returns 8
a^Y                      # bitwise 'a' xor 'Y', returns 8
w&'?'                    # bitwise 'w' and '?', returns 7
~"\xcb"                  # bitwise inversion of char 203, returns 4
$^=~y/_//c               # count non-underscores in $^, returns 9

ord"\b"                  # returns 8
unpack(h,"\t")           # unpack "\t" as a hex nibble, returns 9
@{[c,c,c,c]}             # anonymous array, returns 4 in scalar context
$#{[b..j]}               # final index of the range b..j, returns 8
"$^W"|'$'                # bitwise '0' or '$', returns 4
$^H>>log$^H              # $^H is 256, log$^H is ~5, returns 8
cos()- -cos              # cos(undef) is 1, subtract -1, returns 2
$[                       # array start index, returns 0

$-=sqrt%SIG              # set $- to sqrt(23), returns 4
$%=$]                    # set $% to the version number, returns 5
$+[*$=~/($)/]            # match end on *$ (aka *main::$), returns 8
split('',$~)             # split "STDOUT" into chars, returns 6 in scalar context
map(glob,"{,,,}{,}")     # an array of 8 empty strings, returns 8 in scalar context
index(\L,L)              # finds 'L' in 'SCALAR(...)', returns 3

exp(exp)<<exp            # 2.718281828 << 1, returns 4
ceil(sinh acosh$^C)      # ceil(2.30129...), returns 3
keys{stat$0}             # stat$0 is an array with 13 entries, which has 6 keys when
                         # interpreted as a hash, returns 6 in scalar context
rindex(\R,R)             # finds 'R' in 'SCALAR(...)' in reverse, returns 5
($s=ssssss)=~s/s//g      # replace the every 's' in 'ssssss' with nothing, returns 6

$?=acos(--$z)            # set $? to 3.14159... implicit int conversion, returns 3
$^T=pack(u,$^T.$^T.TTTT) # set $^T to "8,30P,...", returns 8
B~~B                     # returns 1 (because B represents the same thing as B)
C<=C                     # returns 1 (because 0<=0)
length$^V                # string length of $^V, returns 7

Python 2.7, 19 자리, 231 개 관련 문자

from math import ceil, pi, trunc, gamma, sin

print ''.join(map(str,
[33-32,
chr(46),
~-7,
8>>3,
trunc(gamma(4.3)),
'x'.find('x'),
22/7,
range(4).pop(),
len('am I phi?'),
52%44,
2*4,
5|2,
ord('/'),
'\b',
5+2+2,
2<<2,
eval("5+2+2"),
ceil(pi),
'\b',
'\b',
str(sin(5))[5],
5&52]))

54 자리, 808 자의 루비 2.1

#!ruby -rdate -rdigest -ropenssl -rprime -rset -rsocket
print 2/2,?.,9-3,3&5,2*4,2^2,7%4,55>>4,5+4,2<<2,-~7,5|2,2**2,(2r+2+5).to_i,(2.2+5).ceil,(55r/5-2).floor,(2.2*2).to_i,(2r*2*2).ceil,(2.2**2).floor,2.to_bn<<2,__LINE__,$<.to_i,IO::LOCK_NB,Errno::EIO::Errno,File::APPEND,'aaaaaa'.size,?a.encoding.name.sub(/\D+/,''),%w[a a a].size,%w[a b c d].to_set.size,%w[a a a].count,Socket::AF_NS,Date.jd(Date::ITALY).wday,*Digest::MD5.digest(?j).scan(/\d/),Set[?a,?b,?c].count,SignalException.new('FPE').signo,Float::ROUNDS,begin
exit false
rescue Object
$!.status
end,Process::RLIMIT_NPROC,:aaaaaaa.size,Prime.first,?/.next,{a:p,b:p,c:p}.size,STDIN.lineno,?a.crypt('at')[/\d/],{a: :a}.find_index([:a,:a]),/b/=~'aaaaaaaaab',[?a,?b].index(?b),:aaaaaaab=~/b/,?\t.ord,'aaaaaaaab'=~/b/,open(?/).pos,'aaaaab'.index(?b),?\a.bytes{|b|break b},'aaaaaaa'.rindex(?a),%w[a a].map.size

이 프로그램은에서 작동합니다 ruby 2.1.0p0 (2013-12-25 revision 44422) [x86_64-openbsd]. OpenBSD 5.5 이외의 시스템은 몇 자리 숫자마다 다른 값을 가질 수 있습니다.

해석

이 과제의 제한 사항, 특히 제한 6은 Ruby에게는 정확하지 않습니다. 그래서 나는 내 자신의 해석을 추가합니다.

1. 괄호, 점 및 이중 콜론은 연산자가 아닙니다. 괄호는 작업 순서 만 변경합니다. 점은 $<.fileno에서와 같이 메소드를 호출 하고 이중 콜론은에서와 같이 상수를 가져옵니다 IO::LOCK_NB. 메소드 또는 상수의 이름은 조작의 일부입니다. 때문에 () . ::운영하지 않습니다, 나는 그들에게 제한 6 적용되지 않습니다. 더 많은 숫자를 생성하기 위해 재사용 할 수 있습니다.
2. 다른 구현 방법은 다른 방법입니다. 예를 들어, Array#count와 Enumerable#count같은 두 방법 모두 동일한 행동 제한 6의 함수되지 않지만 Array#count우선 Enumerable#count다른 구현. 내가 사용하는 경우 Array#count하나의 숫자를 생성하기 위해, 내가 사용할 수 있습니다 Enumerable#count다른 숫자를 생성 할 수 있습니다.
3. Class # new는 한 가지 방법입니다. Ruby에서 Mutex.new, Random.new등 Time.new은 같은 방법을 참조하십시오 Class#new. SignalException.new한 자리를 생성 하는 데 사용 합니다. 제한 6으로 인해 다시는 사용할 수 없습니다 Class#new.
4. 클래스 또는 모듈의 상수는 여전히 상수입니다. 루비에서 클래스 이름은 좋아 Float하고 IO상수이다! IO::LOCK_NB한 자리를 생성 하는 데 사용 합니다. 제한 6으로 인해 다시는 사용할 수 없습니다 IO. 이 해석은 패키지 이름이 상수가 아닌 다른 언어가 아닌 Ruby에만 바인딩됩니다.
5. 리터럴은 상수가 아닙니다. 2는 수학 상수이지만 (변수와 무관) Ruby에서는 상수가 아닙니다. 리터럴에 제한 6을 적용하지 않으며 리터럴 2를 여러 자리에 재사용 할 수 있습니다.
6. 리터럴은 연산자가 아닙니다. 에서처럼 리터럴 배열, 해시, 정규 표현식 또는 문자열을 형성하는 괄호 또는 따옴표에는 제한 6을 적용하지 않습니다 [] {} // ''. 나는 항상 더 많은 숫자를 생성하기 위해 그러한 리터럴을 사용할 수 있습니다.
7. 값이 같은 두 상수는 같습니다. File::APPEND와 IPSocket::LOCK_UN같은 수의 두 이름은 8. 제한 (6) "가되는 중요하지 않습니다라고 이름 당신이 어떤 내장을 참조하십시오." 때문에 File::APPEND와는 IPSocket::LOCK_UN이름 만 다 내가 두 자리 그들을 사용되지 않을 수도 있습니다, 그들은 같은 일정해야합니다.
8. 두 자리 숫자는 동일한 전역 변수를 나타내지 않을 수 있습니다. 이것은 허점을 닫습니다. 제한 6은 함수, 연산자 및 상수에만 적용됩니다. 제한 4는 리터럴에만 적용됩니다. $SAFE함수, 연산자, 상수 또는 리터럴이 아닌 내장 전역 변수입니다. $SAFE허점을 사용 $SAFE하면 프로그램에서 모든 숫자 0을 생성하는 데 재사용 할 수 있습니다 . 전역 변수를 제한하기 위해 제한 6을 해석하여 허점을 닫습니다.

코멘트

첫 번째 줄은 #!ruby -rdate -rdigest -ropenssl -rprime -rset -rsocket입니다. Ruby는이 행을 구문 분석하고 표준 라이브러리의 6 개 부분을 by by require 'date'등 으로로드 require 'digest'합니다. 제한 3은 "표준 라이브러리 가져 오기 / 포함"을 제외하기 때문에이 56자를 세지 않습니다.

나머지 프로그램 print은 긴 인수 목록을 사용하여 문자열로 변환하고 순서대로 인쇄합니다. 인수는 다음과 같습니다.

1. 1from 2/2: division Fixnum # /
   . from ?.: 리터럴 단일 문자 문자열
2. 6from 9-3: 빼기 Fixnum #-
3. 1from 3&5: 비트 단위 및 Fixnum # &
   • 해석 5에 의해 3다시 사용할 수 있습니다 .
4. 8from 2*4: 곱셈 Fixnum # *
5. 0from 2^2: 비트 배타적 또는 Fixnum # ^
6. 3from 7%4: 계수 Fixnum # %
7. 3from 55>>4: 오른쪽 시프트 Fixnum # >>
8. 9from 5+4: 추가 Fixnum # +
9. 8from 2<<2: 왼쪽 시프트 Fixnum # <<
10. 8부터 -~7: 보완의 부정 Fixnum #-@ Fixnum # ~
    • 빼기 Fixnum #- 및 부정 Fixnum #-@ 은 다른 방법입니다.
11. 7from 5|2: 비트 또는 Fixnum # |
12. 4from 2**2: 지수 수정 번호 # **
13. 9from (2r+2+5).to_i: 합리적 추가 Rational # + Rational # to_i
    • 해석 2에서 Fixnum # + 와 Rational # + 는 다른 메소드입니다. 둘 다 숫자를 추가하지만 왼쪽 숫자의 다른 유형에서 시작하여 구현이 다릅니다.
    • 2rRuby 리터럴과 같은 합리적인 리터럴 은 새로운 기능입니다. Rational # +를2r+2 호출 하고 또 다른 합리적인 것을 리턴합니다. Rational # +를 다시 호출 합니다.2r+2+5
    • 루비는 다음과 같은 합리적을 출력 2/1하고 뜬다 2.0. 이 문제를 해결하기 위해 정수로 변환합니다. to_i 는 0으로 반올림하고 ceil은 반올림하고 바닥은 반올림합니다.
14. 8from (2.2+5).ceil: float 덧셈 Float # + Float # ceil
    • 해석 1로 괄호를 사용 ()하고 .다시 점을 찍을 수 있습니다 .
15. 9from (55r/5-2).floor: 합리적인 나눗셈과 빼기 Rational # / Rational #-Rational # floor
16. 4from (2.2*2).to_i: float 곱셈 Float # * Float # to_i
17. 8from (2r*2*2).ceil: 합리적인 곱셈 Rational # * Rational # ceil
18. 4보낸 사람 (2.2**2).floor: 유리 지수 합리
19. 8from 2.to_bn<<2: OpenSSL 큰 숫자를 사용한 왼쪽 시프트 Fixnum # to_bn OpenSSL :: BN # <<
20. 2from __LINE__: 현재 줄 번호에 대한 마법 상수
21. 0from $<.to_i: 표준 입력 IO # to_i 의 파일 디스크립터
22. 4from IO::LOCK_NB: 비 블로킹 파일 잠금 플래그
    • 이것은 시스템에 의존하는 많은 상수 중 첫 번째입니다. OpenBSD에는 4가 있습니다.
    • 해석 4에서는 더 이상 사용할 수 없습니다 IO. 해석 적으로, 나는 더 이상 4의 상수를 사용할 수 없다
23. 5from Errno::EIO::Errno: 입출력 오류 번호
24. 8from File::APPEND: 파일에 추가 할 플래그
    • 이것은 해석 4 주위의 허점입니다. 나는 사용하지 않을 수도 IO있지만 File에서 상수를 상속 받으 IO므로 File::APPEND다른 방법으로 얻을 수 IO::APPEND있습니다.
25. 6from 'aaaaaa'.size: 문자열 길이 String # size
26. 8from ?a.encoding.name.sub(/\D+/,''): 인코딩 이름의 일부 String # encoding 인코딩 #name 문자열 #sub
    • 해석 6으로 문자열 따옴표를 다시 사용할 수 있습니다.
    • Ruby 2.0부터 기본 인코딩은 UTF-8입니다. "UTF-8"이라는 이름을 사용하고 빈 문자열로 "UTF-"와 일치하는 / \ D + /를 사용합니다. 이것은 "8"을 산출합니다.
27. 3from %w[a a a].size: 배열 길이 Array # size
28. 4from %w[a b c d].to_set.size: 세트의 요소 수 Array # to_set Set # size
29. 3from %w[a a a].count: 모든 요소를 ​​계산합니다. Array # count
    • Array # size 와 Array # count 의 차이점 은 후자가 계산할 요소를 선택하기 위해 선택적 인수를 사용한다는 것입니다. 나는 인수를 전달하지 않으므로 모든 요소를 ​​계산합니다.
30. 6from Socket::AF_NS: NS 주소 패밀리의 번호
31. 5에서 Date.jd(Date::ITALY).wday: 평일 수 금요일 1582년 10월 15일, 이탈리아 그레고리 안 달력으로 전환을위한 날짜 : JD 날짜 번호의 wday
32. 6from *Digest::MD5.digest(?j).scan(/\d/): "j"의 이진 MD5 다이제스트의 첫 번째 ASCII 숫자 Digest :: MD5 :: digest String # scan
    • String # scan 은 모든 일치하는 배열을 반환합니다. 는 *인수로 배열 요소를 통과한다 print. 이 배열은 [ "6"]입니다.
33. 3from Set[?a,?b,?c].count: 모든 요소 수를 계산합니다. Set :: [] Enumerable # count
    • 해석 2에서 Array # count 와 Enumerable # count 는 다른 방법입니다.
34. 8from SignalException.new('FPE').signo: SIGFPE 클래스 수 #new SignalException # signo
35. 1from Float::ROUNDS: 반올림 모드, 반올림 근처 1
36. 1from begin(newline) exit false(newline) rescue Object(newline) $!.status(newline) end: 실패 상태 종료
    • 이것은와 같은 값 SystemExit.new(false).status이지만 해석 3으로 인해 더 이상 Class # new를 호출하지 않을 수 있습니다 . 대신 나는 SystemExit을 제기하고 구출한다.
37. 7from Process::RLIMIT_NPROC: 한 사용자의 프로세스 수에 대한 자원 제한 수
38. 7from :aaaaaaa.size: 심볼 길이 Symbol # size
39. 2from Prime.first: 첫 번째 소수 Enumerable # first
40. 0from ?/.next: "?"다음의 다음 문자열 문자열 # 다음
41. 3from {a:p,b:p,c:p}.size: 해시 길이 해시 # 크기 문자열 #p
42. 0from STDIN.lineno: 표준 입력 IO # lineno의 현재 줄 번호
    • 해석 8에 따르면 재사용 할 수 없습니다 $<. 사용 STDIN합니다. 차이점은 $<전역 변수이며 STDIN상수입니다. 프로그램이 $<다른 입력으로 설정 될 수 있지만 STDIN항상 원래 값은 $<입니다.
43. 3from ?a.crypt('at')[/\d/]: 암호화 된 비밀번호의 첫 번째 ASCII 숫자 String # crypt String # []
    • 다른 crypt () 함수를 가진 시스템은 다른 결과를 제공합니다.
44. 0from {a: :a}.find_index([:a,:a]): 첫 번째 키의 인덱스 : a, 해시의 값 : a Enumerable # find_index
    • Array # find_index 가 Array # index 의 별칭 이므로 곧 사용할 계획 이므로 배열이 아닌 해시 를 사용합니다.
45. 9from /b/=~'aaaaaaaaab': 문자열이 / b / Regexp # = ~ 와 일치하는 색인
46. 1from [?a,?b].index(?b): 배열 Array 에서 첫 번째 "b"의 색인
47. 7from :aaaaaaab=~/b/: 기호가 기호와 일치하는 색인 ​​/ b / Symbol # = ~
48. 9from ?\t.ord: 탭 "\ t"의 ASCII 값 String # ord
49. 8from 'aaaaaaaab'=~/b/: 문자열이 / b / String # = ~ 와 일치하는 색인
    • 해석 2에서 Regexp # = ~ 와 String # = ~ 는 다른 방법입니다.
50. 0from open(?/).pos: 루트 디렉토리 "/"를 파일로 연 후 파일의 위치 Kernel # open IO # pos
51. 5from 'aaaaab'.index(?b): 문자열 String # index 에서 첫 번째 "b"의 색인
52. 7from ?\a.bytes{|b|break b}: 경고 "\ a"의 ASCII 값 String # bytes
    • 이것은 "\ a"의 바이트를 반복하지만 첫 번째 바이트를 반환하여 루프를 끊으면 작동합니다.
53. 6from 'aaaaaaa'.rindex(?a): 문자열 String 에서 마지막 "a"의 색인
54. 2from %w[a a].map.size: 배열에서 매핑되는 열거 자의 크기 Array # map Enumerator # size

Java, 21 자리, 276 자

class C{public static void main(String[]a){System.out.print((3&5)+"."+(2|4)+Byte.BYTES+2*4+"".length()+(7-4)+~-4+(7+2)+(2<<2)+(int)Math.sqrt('@')+(2^5)+(int)Math.pow(2,2)+32%23+Byte.SIZE+('$'>>2)+Float.BYTES+Long.BYTES+Integer.BYTES+Double.BYTES+Short.BYTES+Math.round(.2));}}

class C {
  public static void main(String[] a) {
    System.out.print(
      (3&5)+       // 1
      "."+         // .
      (2|4)+       // 6
      Byte.BYTES+  // 1
      2*4+         // 8
      "".length()+ // 0
      (7-4)+       // 3
      ~-4+         // 3
      (7+2)+       // 9
      (2<<2)+      // 8
      (int)Math.sqrt('@')+  // 8
      (2^5)+       // 7
      (int)Math.pow(2,2)+   // 4
      32%32+       // 9
      Byte.SIZE    // 8

      // rest of explanation to come later today
    );
  }
}

루비, 74 문자, 10 자리

시작일뿐입니다. 나중에 개선해야합니다.

$><<[3-2,?.,3+3,?..size,2**3,$*.size,24/8,7%4,[*7..77][2],2*4,7.next].join

나중에 더 어려워 질 때 76자를 저장했습니다!

루비, 17 자리, 168 바이트

$><<[-~0,'.',9-3,3/3,2**3,$.,25%22,'   '=~/$/,2+7,2<<2,"10".oct,2|5,[2,2,2,2].size,[*$....2*5].last,(2^5).succ,'a'.to_i(25).pred,'aaaa'.count('a'),eval(55.chr.next)]*''

언 골프 드 :

$><<[
  -~0,                # 1
  '.',                # .
  9-3,                # 6
  3/3,                # 1
  2**3,               # 8
  $.,                 # 0
  25%22,              # 3
  '   '=~/$/,         # 3
  2+7,                # 9
  2<<2,               # 8
  "#{'a'.hex}".oct,   # 8
  2|5,                # 7
  [2,2,2,2].size,     # 4
  [*$....2*5].last,   # 9
  (2^5).succ,         # 8
  'a'.to_i(25).pred,  # 9
  'aaaa'.count('a'),  # 4
  eval(55.chr.next)   # 8
]*''

아직 영리한 일을 강요받지 않은 채 돌아와서 숫자를 추가 할 수 있습니다.

Golfscript , 17 자리

간단한 시도. Golfscript에는 영숫자가 아닌 1 글자가 내장되어있을 수 있지만 전체적으로 내장되어 있지는 않습니다.

".",                         # 1: string length (separate from array length)
'.'    
3 3+                         # 6: addition
''[49]+                      # 1: string concatenation
-9~                          # 8: bitwise not
2!                           # 0: boolean not
7 4%                         # 3: modulus
4(                           # 3: decrement
7))                          # 9: increment
257 2/2/2/2/2/               # 8: division
4 2*                         # 8: multiplication
22 5- 5- 5-                  # 7: subtraction
2 2?                         # 4: power
[2 5] 2 base                 # 9: base conversion
[2 2 2 2 2 2 2 2],           # 8: array length (separate from str length)
[2 2 2 2 2 2 2 2 2 5]5?      # 9: array.find()
2 2+                         # 4: addition
"2 2*2*"~                    # 8: eval

배쉬, 65 자리 5 자리

곧 업데이트하겠습니다! 지금은 단지 인쇄 1.6180만하고 숫자는 포함하지 않습니다.

false
tr -d ' '<<<$?.`wc -c<<<abcde``nl<<<' '``kill -l FPE`$(())

설명

다음 방법을 사용하여 숫자를 생성하십시오.

1 : 종료 상태 false

6 : 끈 길이

1 : nl남용

8 : kill신호 번호

0 : 빈 표현식의 숫자 값

Mathematica 9 8 자리, 86 83 78 자.

10`8FromDigits@#/10^Length@#&@{a/a,3!,-I I,2π/(45°),#&''[],Prime@2,Sqrt@9,4+5}

산출:

1.6180339

Julia-345 자에서 23 자리 (숫자 당 정확히 15 자리)

print(div(2,2),'.','/'+7,length(" "),2^3,size([])[end],isqrt(9),int(cbrt(27)),54-45,'h'$'P',[2:22][7],endof("2222222"),count(isodd,[5,5,5,5]),search("Hello man",'n'),nextpow2(5),rsearch("Love boat",'t'),sizeof('й'),("I"summary(b"H"))[22],iceil(float(pi)),iround(cosh(e)),ifloor(exp(catalan)),cmp(5,5),itrunc(5sin(one(Int))),uint(erfcx(-ones())))

출력 : 1.6180339887498948482045

특정 문자 나 문자열을 재사용하지 않는 한 문자와 문자열을 사용 가능한 것으로 해석했습니다 (문자열의 문자는 문자열이 아닌 한 재사용 할 수 있음). 그러나 나는 문자의 int 값을 직접 사용하는 것을 허용하지 않았습니다. 비 ASCII 문자 (й)가 하나 있습니다.

더 읽기 쉬운 방식으로 (실제 코드 아님) :

1> div(2,2)
.> '.'
6> '/'+7
1> length(" ")
8> 2^3
0> size([])[end]
3> isqrt(9)
3> int(cbrt(27))
9> 54-45
8> 'h'$'P'
8> [2:22][7]
7> endof("2222222")
4> count(isodd,[5,5,5,5])
9> search("Hello man",'n')
8> nextpow2(5)
9> rsearch("Love boat",'t')
4> sizeof('й')
8> ("I"summary(b"H"))[22]
4> iceil(float(pi))
8> iround(cosh(e))
2> ifloor(exp(catalan))
0> cmp(5,5)
4> itrunc(5sin(one(Int)))
5> uint(erfcx(-ones()))

줄당 C ++ 12.4 자, 각 자리 당 줄당 14 자

연산자를 재사용하는 실수를 수정했습니다.

#include <iostream>
#include <math.h>
#define S std::string
#define C(x) std::cout<<x
int main()
{
C(cos(0));
C(char(46));
C('j'%'d');
C('\0'+3-2);
C(sqrt('@'));
C(log(1));
C('c'/'!');
S s("xyz");
C(s.size());
return 0;
}

이와 같은 문자를 사용하는 것이 문자 리터럴로 계산되는지 확실하지 않습니까? 이 규정이 수용 가능하면 영원히 지속될 수 있으며 숯불은 상환됩니다.

#include <iostream>
#define C(x) std::cout<<x
int main()
{
C('b'-'a');//1
C(char(46));//.
C('g'-'a');//6
C('b'-'a');//1
C('i'-'a');//8
C('a'-'a');//0
C('d'-'a');//3
C('d'-'a');//3
C('j'-'a');//9
//etc
return 0;
}