PPCG 프라임 출력

69

PPCG 프라임입니다

624 자리 길이

777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777111111111111111111111111111111111111111111111111111111111111111111111111111111188888888118888888811188888811188888811188111118818811111881881111881881111881188111118818811111881881111111881111111188888888118888888811881111111881118888188111111118811111111881111111881111881188111111118811111111881111881881111881188111111118811111111188888811188888811111111111111111111111111111111111111111111111111111111111111111111111111111111333333333333333333333333333333333333333



39 자리마다 나누면

777777777777777777777777777777777777777
777777777777777777777777777777777777777
777777777777777777777777777777777777777
777777777777777777777777777777777777777
111111111111111111111111111111111111111
111111111111111111111111111111111111111
188888888118888888811188888811188888811
188111118818811111881881111881881111881
188111118818811111881881111111881111111
188888888118888888811881111111881118888
188111111118811111111881111111881111881
188111111118811111111881111881881111881
188111111118811111111188888811188888811
111111111111111111111111111111111111111
111111111111111111111111111111111111111
333333333333333333333333333333333333333

당신의 임무는 PPCG-Prime을 출력하는 것입니다

이것은 codegolf 입니다. 바이트 단위의 가장 짧은 코드가 승리합니다.

아래 Mathematica 함수에 PPCG-Prime을 입력하면이 결과가 나타납니다. 

ArrayPlot@Partition[IntegerDigits@#,39]&

여기에 이미지 설명을 입력하십시오

code-golf  kolmogorov-complexity  primes 
37
지구상에서 이것을 어떻게 찾았습니까?
— Stewie Griffin
5
@StewieGriffin 숫자 n가 소수 일 때의 평균 확률 은에 비례 1/log(n)합니다. 소수가 될 때까지 많은 숫자를 확인하십시오.
— user202729 년
2
의견은 긴 토론을위한 것이 아닙니다. 이 대화는 채팅 으로 이동 되었습니다 .
— Dennis
1
이 경우 @ user202729 log(n)에 관한 것 1436.6입니다.
— Jeppe Stig Nielsen
3
@ Fabian 나는이 방법이 효율적이라고 생각하지 않습니다 ...이 큰 (624 자리) 프라임의 경우, 당신이 요구하는 숫자는 621 자리 (골프하기가 더 어렵습니다)입니다. 초기!!! 전화 번호를 찾으려면 x/logxGauss 의 간단한 근사치

답변:

22

젤리 , 55 54 52 47 46 바이트

“=÷¡v⁺ʋiṂYR¤"bİɲ}Ñ1Ṇ⁴ẠV⁹yȥGẇ’“¿mŻ“p’Dx39jBo88V

개정 이력에는 더 복잡한 접근 방식이 있지만이 간단한 방법이 모든 것을 능가합니다.

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

작동 원리

“=÷¡v⁺ʋiṂYR¤"bİɲ}Ñ1Ṇ⁴ẠV⁹yȥGẇ’

이것은 Jelly의 코드 페이지에서 가져온 숫자 인 Bijective Base 250으로 인코딩 된 숫자 리터럴입니다. 체인의 (왼쪽) 인수와 반환 값은 인코딩 된 정수
n : = 0x21871c77d7d7af6fafafeff0c37f72ff7fbfbdbfdfef5edfeff8e3으로 설정 됩니다.

“¿mŻ“p’

위와 비슷한 리터럴이지만 “두 번째는 인코딩 된 두 정수를 분리합니다. 반환 값은 인코딩 된 배열 [777711, 113] 로 대체됩니다 .

Dx39

D반환 값을 10 진수 ( [[7, 7, 7, 7, 1, 1], [1, 1, 3]] )로 변환 한 다음 x39결과에서 각 개별 정수 / 자리를 39 회 반복합니다. 이렇게하면 한 쌍의 배열이 생성되는데, 여기에는 7 자 높은 텍스트 앞뒤에 숫자가 포함됩니다. 이 배열을 A 라고합시다 .

jB

먼저 B(왼쪽) 인수 n 을 이진수 로 변환합니다 . 이렇게하면 7 자 높은 텍스트를 형성하는 숫자가 생성되며 각 88 은 0 으로 대체되었습니다 .

그런 다음 이진 배열을 구분 기호로 사용하여 j배열 A를 조인합니다 .

o88

논리 OR을 88로 수행 하여 각 0 을 88로 바꿉니다 .

V

우리는 지금 정확한 숫자를 가지지 만, 7 , 1 , 88 , 3 의 배열로되어 있습니다. V이 배열을 암시 적으로 문자열로 변환 한 다음 회피하여 단일 정수를 생성합니다.

— 데니스
소스
6

풍선 껌 , 51 바이트

00000000: 331f c4c0 90ba c002 0a90 5986 d818 50d5  3.........Y...P.
00000010: 282c 3406 6e65 5036 1e4b 9195 8109 649d  (,4.neP6.K....d.
00000020: 5858 1896 4279 68b2 f895 61fa 94ca c098  XX..Byh...a.....
00000030: 3800 00                                  8..

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

— ovs
소스
6

SOGL V0.12 , 52 51 바이트

≡=vā⁷H↕↕jΥ_Ν↑∆∫▲pΖo	‘θδžΟwd╬2n?q[‘²Κ7n⌡"α¼■╤ģ⅞¹‘¹H∑

풍선 껌 관계!
이 답변에는 탭이 포함되어 있습니다.

여기 사용해보십시오!

Ps에 동일한 문자열을 재사용하여 바이트를 절약하려고합니다 .

설명:

...‘...‘²Κ7n⌡"..‘¹H∑  compressed strings replaced with ellipses to shorten the width
...‘                  pushes "1111111188888188888888111118811111881111188111118881118818111811111111188888188888888111118811111881111188118118888818818881811118111" - CG
    ...‘              pushes "1111111888888888888881118118111811811181181118118111811811188881111881" - P
        ²             join with itself - double the P
         Κ            reverse add - prepend the PP to CG
          7n          split to line lengths of 7
            ⌡         for each
             "..‘       push "311ŗ117777" with ŗ replaced with the ToS - current item looping over
                 ¹    wrap the results tn an array
                  H   rotate it counter-clockwise
                   ∑  join to a single string

거기의 숫자는 왼쪽 아래에서 시작하여 위로 올라간 다음 1 오른쪽 & 아래로, 위로 등으로 저장됩니다.

52 바이트 일반 압축 버전 :

#⅓→9E■Ν►1&⅝θ⅞%øøμ←N═]y)u⅝↓$A○░(ZF16Φ⅓Mč▓d⅛Hι‼∑υnη▲Z‘

여기 사용해보십시오!

— 자 지마
소스
게시 한 내용이 올바른 코드인지 확실하지 않습니다.
— Erik the Outgolfer
1
...‘그 숫자를 어떻게 얻습니까?
— Pureferret
1
@Pureferret 문자열 압축.
— 완전히 인간적인
@totallyhuman 그래서 어떻게 문자열을 '인코딩'/ 압축 ...‘합니까?
— Pureferret
@dzaima 나는 그것이 불행히도 실제로 이해하는 데 도움이되지 않는다고 생각합니다. CG해당 도구로 인코딩하는 첫 번째 부분을 입력 해도 해당 도구의 ...‘어느 부분도 제공하지 않습니다 .
— Pureferret
4

수학, 107 바이트

Uncompress@"1:eJxTTMoP8ixgYmAwH8TAkLrAAgqQWYbYGFDVGCxkBh5lCDNwWIqqDCyGrAGDhWEpFmXY3IaiDItPqQqMiQMA+yaAoA=="


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

— J42161217
소스
내가 틀렸다면 저를 수정하십시오.하지만 그게 REPL 전용 솔루션입니까? 그것은 함수가 아닌 것 같습니다 ( &끝에 하나로 고칠 수 있다고 생각합니다 ).
— numbermaniac
이것은 기능이 아닙니다. 이 코드는 OP가 요청한 것처럼 PPCG 프라임을 출력합니다.
— J42161217
4

CJam, ASCII, 61

Hs78f*~_@"'hfv;HH`>O4RU(_o^.U)9q&-1iadr`4tk"90b2b88fe|1$'339*

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

]s39/N*멋진 포장을 위해 추가하십시오 .

설명:

Hs         generate "17" (H=17)
78f*       repeat each character 78 times, getting an array of 2 strings
~_         dump the 2 strings on the stack, and duplicate the '7's
@          move the '1's to the top of the stack (first 6 lines done so far)
"…"90b     convert that string from base 90 (treating characters as numbers)
2b         convert the resulting number to base 2,
            obtaining a bit map for the "PPCG" part, with 1 for "1" and 0 for "88"
88fe|      replace (boolean OR) all the zeros with 88
1$         copy the string of 78 '1's
'339*      repeat '3' 39 times
— 아디 츠
소스
4

C, 519 427 414 396 377 바이트

Tas, Felix Palmen 및 Lynn에게 감사합니다.

#define p(n,l)for(i=40*l;i;)putchar(--i%40?n+48:10);
f(i){p(7,4)p(1,2)puts("188888888118888888811188888811188888811\n188111118818811111881881111881881111881\n188111118818811111881881111111881111111\n188888888118888888811881111111881118888\n188111111118811111111881111111881111881\n188111111118811111111881111881881111881\n188111111118811111111188888811188888811");p(1,2)p(3,1)}

여기에 더 길고 읽기 쉬운 버전이 있습니다.

#define p(n,l) for(i=40*l;i;) putchar(--i%40?n+48:10);
f(i) {
    p(7,4)
    p(1,2)
    puts("188888888118888888811188888811188888811\n\
       188111118818811111881881111881881111881\n\
       188111118818811111881881111111881111111\n\
       188888888118888888811881111111881118888\n\
       188111111118811111111881111111881111881\n\
       188111111118811111111881111881881111881\n\
       188111111118811111111188888811188888811");
    p(1,2)
    p(3,1)
}
— 자노에 툭스
소스
1
당신은 할 수 있습니다 훨씬 낮은 얻을 단순히 그들이 같이 1과 8S를 인쇄하고, 7, 3, 1에 대해 정의함으로써 (~ 450ish)
— TAS
@ Keyu Gan : 현재 버전의 GCC (7.2.0-debian11)로 컴파일 중이며 몇 년 동안 사용할 수 있습니다. 구문이 최신 C 표준 중 하나인지 확실하지 않습니다.
— xanoetux
2
@Keyu Gan : C99 및 C11에서 허용됩니다.
— xanoetux
1
— Felix Palmen
이 버전은 매우 까다 롭습니다. 적어도 나는 그것을 이해한다. 감사.
— xanoetux
4

자바 (OpenJDK 8) 165 바이트

n->{for(int i=0;++i<566;)System.out.print(i<157?7:i>526?3:i<236|i>446||new java.math.BigInteger("vnku5g6l0zenpa1kydel5rxw162k4fk4xapa154o",36).testBit(446-i)?1:88);}

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

크레딧

  • aditsu 덕분에 -10 바이트!
— 올리비에 그레고리
소스
165 :n->{for(int i=0;++i<566;)System.out.print(i<157?7:i>526?3:i<236|i>446||new java.math.BigInteger("vnku5g6l0zenpa1kydel5rxw162k4fk4xapa154o",36).testBit(446-i)?1:88);}
— aditsu
좋은 캐치, 더블 88, 감사합니다!
— Olivier Grégoire
2

배치, 364 335 333 바이트

@set a=888888&set b=1111111111111&set e=1881111&set d=1%e%&set f=333333333&for /L %%x in (1,1,156) do @cd|set/p=7
@echo %b%%b%%b%%b%%b%%b%1%a%8811%a%88111%a%111%a%1%d%188%e%188%e%88%e%88%d%188%e%188%e%1%d%1111%a%8811%a%88%d%111881118888%e%11%d%11%d%1%d%88%d%11%d%11%d%88%e%88%d%11%d%11111%a%111%a%%b%%b%%b%%b%%b%%b%11%f%%f%%f%%f%333
— 슈나이더
소스
1
다음으로 변경 echo|하여 2 바이트를 절약하십시오.cd|
— stevefestl
고마워, 나는 더 짧은 것이 있다는 것을 알고 있었지만 기억할 수 없었다
— schnaader
또한 다음 (1,1,156) do으로 단축 될 수 있습니다(1,1,156)do
— stevefestl
2

자바 (ES6) 187 181 바이트

@JustinMariner 덕분에 -6 바이트

r=s=>s[0].repeat(39),a=r`7`,b=r`1`,i="8888881",c=188+i,d=11+i,j="188111",e=j+1188,f=j+188,g=j+111,h=g+1,k=r`3`
z=>"aaaabbccdd1eeff1eeghccgj8888hhgf1hhff1hhdd1bbk".replace(/./g,eval)

매우 간단한 접근법; 아마 더 골프를 쳤을 것입니다.

설명

r=s=>s[0].repeat(39),                               // helper function to repeat character
a=r`7`,b=r`1`,i="8888881",c=188+i,d=11+i,j="188111",// Set the variables (a-k) to different
e=j+1188,f=j+188,g=j+111,h=g+1,k=r`3`               // parts of the prime       

_=>"aaaabbccdd1eeff1eeghccgj8888hhgf1hhff1hhdd1bbk" // Replace all letters in the string
    .replace(/./g,eval)                             // with the value of the variable

예제 코드 스 니펫 (출력에 줄 바꿈을 추가하는 일부 도우미 코드 포함)

코드 스 니펫 표시

— 허먼 L
소스
당신이 도우미 함수 정의하면 당신은 몇 바이트를 저장할 수 r등을 r=s=>s[0].repeat(39)한 후 교체 a, b및 k과 r`7` 등 온라인을보십시오! .
— 저스틴 마리너
2

C (gcc) , 269 267 바이트

함수는 간단한 RLE을 사용합니다.

x[]={39,79,80,156};k;f(i){for(char*c="d7b1882188316831683128512811285128112841281128412821285128112851281128712881882188212871283148112881288128712841282128812881284128112841282128812891683168c1a3";i=*c++;++c)for(i=i<97?i-48:x[i-97];i--;++k%39||puts(""))putchar(*c);}

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

— 펠릭스 팔멘
소스
L"'OP\x9c"대신 추천x
— ceilingcat
2

C (gcc) , 224 바이트

f(i,j,c){for(i=0;c="wwdfFdfFDfFDfFDFDDFFDDFFDddDDFdDDddDDddDDDdDDDDffDffDFDDDFDfdDDDDFDDDdDDDdDDFdDDDDFDDDdDDFFDdDFDDDdDDDDdfDdfD"[i/2]>>i++%2*4&15;c-6?putchar(c-4?c+48:49):printf("88"))for(j=0;j++<c%2*38;)putchar(c+48);}

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

인쇄 할 수없는 문자가 포함되어 있으며 문자열 리터럴은 "ww\x11dfFdfFDfFDfFDFDDFFDDFFDddDDFdDDddDDddDDDdDDDDffDffDFDDDFDfdDDDDFDDDdDDDdDDFdDDDDFDDDdDDFFDdDFDDDdDDDDdfDdfD\x11\x03"입니다.

— 린
소스
1

젤리 , 86 바이트

Lẋ@1,8żḣLẋ/€F
7ẋ156;1ẋ78¤©;“½Ẹ^o“2FẒ⁶ġbȥ“¡E⁷£cṿ“t¡ɗḋ“£F¢Xȥ“¡McṾbȥ“¬3Ṭo’DÇ€F¤;®;3rẋ39¤Ḍ

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

user202729 덕분에 -12 바이트

— 하이퍼 뉴트리노
소스
88 바이트 : TIO ( “수 separates a list of strings inside a string literal)
— user202729
당신 나라에서 몇시입니까? 왜 지금 깨어있어?
— user202729
감사합니다. 그리고 나는 UTC-4에있어 바보처럼 지냈고 늦게까지 머물러 있어야했습니다. P
— HyperNeutrino
1

젤리 , 85 바이트

”7ẋ“ɓ’80“¡Ȯ⁶LÑɓĠ⁶-€Øġ°$¤ṛọḳƓƒṭ⁽@^ḥ⁷Ofạ<e½Ṇż;,RṘ¶ṀḊ+`⁸ⱮḃĿþṛ9.wƑ¡kḟUẎgLLµ’ḃĖŒṙị⁾1839”3ẋ

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

Trinity Hall 과제에 대한 Dennis의 접근 방식을 기반으로 대칭에서 빼고 7s 및 후행을 뺀 값 3입니다.

— 아웃 골퍼 에릭
소스
3
Dennis는이 과제가 다르기 때문에이 과제에 다르게 접근했습니다. 난 당신이 아웃 고프 생각합니다!
@JoseZaman 그는 젤리 BTW를 만들었습니다.
— Outgolfer Erik
1

PowerShell , 164 바이트

$a='136361616151315131531532513151315215436365213213315454521532545453153254541616';6..2|%{$a=$a-replace$_,(11,88,22,34,3332)[$_-2]};'7'*156+'1'*78+$a+'1'*78+'3'*39

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

문자열 곱셈, 연결 및 대체 PowerShell에는 기본 36 또는 이와 유사한 것이 없으므로 많은 압축 옵션이 제한됩니다. 중간 부분을 "압축"하는 더 좋은 방법이있을 수 있습니다. 여전히 확인하고 있습니다.

— AdmBorkBork
소스
1

Wolfram Language (Mathematica) , 89 (17 + 71 + 1) 바이트

먼저 번호를 GZIP 파일로 내 보냅니다. 확장자가없는 "o"라는이 파일은 정확히 71 바이트이며 총계에 포함됩니다. 기본적으로 귀하의로 이동합니다 $TemporaryDirectory. 가독성을 위해 숫자를 생략했습니다.

Export["o",777777...,"GZIP"]

그때

"o"~Import~"GZIP"

숫자를 재구성합니다. 파일 이름은 1 바이트이므로 +1이 시작됩니다.

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

— 켈리 로우더
소스
1

루비, 109 바이트

스크립트 Zlib.inflate는 번호를 압축 해제하기 위해 호출 합니다. 루비 1.9.3 이상이 필요합니다. 인쇄 할 수없는 바이트가 포함되어 있으므로 여기에 붙여 넣을 수 없습니다.

출력을 붙여 넣습니다 vis prime-inflate.rb.

require'zlib'
puts Zlib.inflate DATA.read
__END__
x\M-Z37\^_\M-<\M-@\M^P\M-:\M-@\^B
\M^PY\M^F\M-X\^XP\M-U\^X,d\^F\^^e\^H3pX\M^J\M-*\^L,\M^F\M-,\^A\M^C\M^Ea)\^Ve\M-X\M-\\M^F\M-"\^L\M^KO\M-)
\M^L\M^I\^C\^@\^P\M-p~\M-!

unvis (1)가 unvis prime-inflate.vis > prime-inflate.rb있는 경우 109 바이트 스크립트를 복원하기 위해 실행 하십시오. 또는를 사용하여 아래의 Base64를 디코딩 할 수 있습니다 ruby -e 'print *STDIN.read.unpack(?m)' < prime-inflate.b64 > prime-inflate.rb.

cmVxdWlyZSd6bGliJwpwdXRzIFpsaWIuaW5mbGF0ZSBEQVRBLnJlYWQKX19F
TkRfXwp42jM3H7zAkLrAAgqQWYbYGFDVGCxkBh5lCDNwWIqqDCyGrAGDhWEp
FmXY3IaiDItPqQqMiQMAEPB+oQ==

전화를 걸기 Zlib.inflate때문에 자체 감압 알고리즘을 설계하고 골프를 칠 필요가 없습니다. 압축 문자열이 유효한 UTF-8이 아니기 때문에 DATA함께 사용 __END__합니다. Ruby 코드는 유효한 ASCII (Ruby 1.9.x) 또는 UTF-8 (Ruby 2.0)이거나 #coding:binary인코딩을 변경하기 위한 마법의 주석이 있어야 하지만 Ruby는 이후에 인코딩을 확인하지 않습니다 __END__.

— 커니
소스
1

6502 머신 코드 (C64) 142 122 바이트

00 C0 A9 27 85 FB A2 00 86 FC A2 04 CA 10 01 60 BC 70 C0 BD 74 C0 20 D2 FF C6
FB D0 0B 48 A9 27 85 FB A9 0D 20 D2 FF 68 88 D0 EB E0 02 D0 DD 48 A5 FC 4A A8
B9 4A C0 90 04 4A 4A 4A 4A 29 0F F0 08 E6 FC A8 68 49 09 D0 CD 68 D0 C0 28 38
36 36 52 12 52 12 42 12 42 22 52 12 52 12 72 82 28 28 72 32 14 82 82 72 42 22
82 82 42 12 42 22 82 92 36 06 27 50 4F 9C 33 31 31 37

온라인 데모

용법: sys49152

  • 큰 블록에 대해서도 동일한 방법 및 데이터 테이블을 더 잘 구현할 수있는 -20 바이트

설명

이것은 또한 중간 부분 의 길이 1와 8시퀀스를 사용합니다. 그것들이 모두 16보다 짧으므로, 그중 2 개는 바이트 당 인코딩됩니다.

주석 처리 된 분해 목록 :

         00 C0        .WORD $C000       ; load address
.C:c000  A9 27        LDA #$27          ; counter for newlines (39)
.C:c002  85 FB        STA $FB
.C:c004  A2 00        LDX #$00          ; index for run-length data
.C:c006  86 FC        STX $FC
.C:c008  A2 04        LDX #$04          ; index for "blocks" (counting down)
.C:c00a   .blockloop:
.C:c00a  CA           DEX
.C:c00b  10 01        BPL .continue     ; block index underflow -> done
.C:c00d  60           RTS
.C:c00e   .continue:
.C:c00e  BC 70 C0     LDY .lseqlens,X   ; load length of next block to Y
.C:c011  BD 74 C0     LDA .chars,X      ; load character of next block to A
.C:c014   .outloop:
.C:c014  20 D2 FF     JSR $FFD2         ; output character
.C:c017  C6 FB        DEC $FB           ; decrement newline counter
.C:c019  D0 0B        BNE .skipnl
.C:c01b  48           PHA               ; newline needed -> save accu
.C:c01c  A9 27        LDA #$27          ; restore newline counter
.C:c01e  85 FB        STA $FB
.C:c020  A9 0D        LDA #$0D          ; load newline character
.C:c022  20 D2 FF     JSR $FFD2         ; output character
.C:c025  68           PLA               ; restore accu
.C:c026   .skipnl:
.C:c026  88           DEY               ; decrement repeat counter
.C:c027  D0 EB        BNE .outloop      ; repeat until 0
.C:c029  E0 02        CPX #$02          ; check for block index of text part
.C:c02b  D0 DD        BNE .blockloop    ; not in text part -> repeat
.C:c02d   .textpart:
.C:c02d  48           PHA               ; save accu
.C:c02e  A5 FC        LDA $FC           ; load index for run-length data
.C:c030  4A           LSR A             ; and shift right
.C:c031  A8           TAY               ; -> to Y register
.C:c032  B9 4A C0     LDA .seqlens,Y    ; load run-length data
.C:c035  90 04        BCC .lownibble    ; carry clear from shift -> low nibble
.C:c037  4A           LSR A             ; shift high nibble into low nibble
.C:c038  4A           LSR A
.C:c039  4A           LSR A
.C:c03a  4A           LSR A
.C:c03b   .lownibble:
.C:c03b  29 0F        AND #$0F          ; mask low nibble
.C:c03d  F0 08        BEQ .textdone     ; run-length zero? then text block done
.C:c03f  E6 FC        INC $FC           ; increment index for run-length data
.C:c041  A8           TAY               ; run-length to y-register
.C:c042  68           PLA               ; restore accu
.C:c043  49 09        EOR #$09          ; toggle between '8' and '1'
.C:c045  D0 CD        BNE .outloop      ; and back to output loop
.C:c047   .textdone:
.C:c047  68           PLA               ; restore accu
.C:c048  D0 C0        BNE .blockloop    ; back to loop for next block
.C:c04a   .seqlens:
.C:c04a  28 38 36 36  .BYTE $28,$38,$36,$36
.C:c04e  52 12 52 12  .BYTE $52,$12,$52,$12
.C:c052  42 12 42 22  .BYTE $42,$12,$42,$22
.C:c056  52 12 52 12  .BYTE $52,$12,$52,$12
.C:c05a  72 82 28 28  .BYTE $52,$82,$28,$28
.C:c05e  72 32 14 82  .BYTE $72,$32,$14,$82
.C:c062  82 72 42 22  .BYTE $82,$72,$42,$22
.C:c066  82 82 42 12  .BYTE $82,$82,$42,$12
.C:c06a  42 22 82 92  .BYTE $42,$22,$82,$92
.C:c06e  36 06        .BYTE $36,$06
.C:c070   .lseqlens:
.C:c070  27 50 4F 9C  .BYTE $27,$50,$4F,$9C
.C:c074   .chars:
.C:c074  33 31 31 37  .BYTE "3117"
— 펠릭스 팔멘
소스
1

C (gcc) , 188 (187) 185 바이트

JonathanFrech에게 -1 감사합니다.

실링 캣 덕분에 -2.

#define F(c,n)for(c=0;c<n;c++)
i,j,k;r(d,n){F(k,n)printf("%d",d);}f(){r(7,156);r(1,79);F(i,45)F(j,6)r("pdpi8pIa7]R>=4gQ>Q2iPoX2=O4a1=QRJ17QR>=4a1i8p"[i]-49>>j&1?8:1,1);r(1,80);r(3,39);}

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

— gastropner
소스
2
PPCG에 오신 것을 환영합니다. 좋은 첫 답변입니다!
— ovs
백 슬래시를 피할 필요가없는 문자열로 문자열을 이동하여 187 바이트 를 얻을 수 있다고 생각합니다 .
— Jonathan Frech
@JonathanFrech 아, 좋아!
— gastropner
@ceilingcat 잘 잡아라!
— gastropner
0

Befunge-93 , 500 바이트

v F         >20g1-20p
>"3"20g10g`#^_>52*"F"20p30g10g`#v_"^!1"21p30p84*2+1p
^                       p03-1g03<
^>"81118888888811888888881>!"30p84*2+1p52*
^^"8888811188888811"*25"188111118"<>">#7"21p30p57*5p
>*"188111188188111188188111118818"^ $>:#,_@
^25"18811111881881111188188111111"<
>"8888811888888881"25*"1111111881"^
^"88811881111111881118888"*25"188"<
>"1188111111188111111118811111111"^
^"11881"*52"188111111118811111111"<
>"11111881"52*"188111188188111188"^
^"1118811111111188888811188888811"<

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

— ItsJ0el
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.