코드 골프 : 테트리스 플레이


83

기본 사항 :

다음 테트로 미노와 빈 경기장을 고려하십시오.

                                            0123456789
    IOZTLSJ []
                                           []
    # ## ## ### # ## # []
    # ## ## # # ## # []
    # ## ## []
    # []
                                           [==========]

경기장의 크기는 고정되어 있습니다. 상단의 숫자는 열 번호를 나타 내기 위해 여기에 있습니다 (입력 참조).

입력:

1 . 이미 테트로 미노로 부분적으로 채워질 수있는 특정 경기장 (위에 기반)이 제공됩니다 (이는 별도의 파일에 있거나 stdin을 통해 제공 될 수 있음).

샘플 입력 :

[]
[]
[]
[]
[# # #]
[## ######]
[==========]

2 . 어떤 열에 삽입 (및 드롭 다운) 할 tetromino를 설명 (공백으로 구분)하는 문자열이 제공됩니다. 테트로 미노는 회전 할 필요가 없습니다. 입력은 stdin에서 읽을 수 있습니다.

샘플 입력 :

T2 Z6 I0 T7

입력이 '올바른 형식'이라고 가정하거나 그렇지 않은 경우 정의되지 않은 동작을 생성 할 수 있습니다.

산출

결과 필드를 렌더링하고 ( '전체'줄이 사라져야 함) 점수 수를 인쇄합니다 (모든 줄이 10 점을 차지함).

위의 샘플 입력을 기반으로 한 샘플 출력 :

[]
[]
[]
[# ###]
[# ###]
[##### ####]
[==========]
10

우승자:

최단 솔루션 (코드 문자 수 기준). 사용 예가 좋습니다. 골프를 즐겨보세요!

편집 : +500답변자들이 이미 만든 좋은 노력에 더 많은 관심을 끌기 위해 명성 의 현상금을 추가했습니다 (그리고 아마도이 질문에 대한 몇 가지 새로운 해결책) ...


5
@omouse : meta.stackoverflow.com 확인-코드 골프는 일반적으로 허용됩니다 (커뮤니티 위키 양식)
ChristopheD

18
@omouse : 그것이 종결 투표의 목적입니다. 커뮤니티가 (마지 못해) 코드 골프가 존재하도록 허용했기 때문에 질문에 플래그를 지정하여 중재자를 여기로 끌어다 놓는다 고해서 인기를 얻지 못할 것입니다 (코드 골프 태그 및 메타 토론 참조, 새로운 것은 아닙니다). .
Mark Peters

8
@omouse : 주제에서 벗어난! = 스팸. 폐쇄 투표를 할 수 없더라도 스팸 플래그는 요청되지 않았습니다.
BoltClock

3
APL 운동을 기다리고 있습니다! 나는 그가 3.5 기호로 그것을 할 수 있다고 장담 할 것이다
n8wrl

3
치수는 고정되어야하지만 샘플 입력과 빈 필드의 높이가 다릅니다. 높이는 얼마입니까?

답변:


27

GolfScript-181 자

개행은 필요하지 않습니다. 출력은 표준 출력이지만 stderr에 일부 오류가 있습니다.
\10프로그램이 181자가되도록하려면 해당 ASCII 문자로 대체해야합니다.

{):X!-{2B{" #"=}%X" ":f*+-1%}%:P;:>.{\!:F;>P{\(@{3&\(@.2$&F|:F;|}%\+}%\+F![f]P+:P
;}do;{"= "&},.,7^.R+:R;[>0="#"/f*]*\+}0"R@1(XBc_""~\10"{base}:B/3/~4*"nIOZTLSJR "
";:"*~;n%)n*~ 10R*+n*

샘플 I / O :

$ cat inp
[          ]
[          ]
[          ]
[          ]
[ #    #  #]
[ ## ######]
[==========]
T2 Z6 I0 T7
$ cat inp|golfscript tetris.gs 2>/dev/null
[          ]
[          ]
[          ]
[#      ###]
[#     ### ]
[##### ####]
[==========]
10

Tetromino 압축 :
조각은 3 개의 기본 8 자리 숫자로 저장됩니다. 이것은 간단한 이진 표현 T=[7,2,0], S=[6,3,0], J=[2,2,3]입니다. 압축 [1]I조각에 사용 되지만 [1,1,1,1]나중에 명시 적으로 설정됩니다 (예 : 4*코드에서). 이러한 모든 배열은 단일 배열로 연결되어 정수로 변환 된 다음 문자열 (인쇄 할 수없는 문자, 길이를 최소화하고 utf8이 발생하지 않도록 기본 126)로 변환됩니다. 이 문자열은 매우 짧습니다 : "R@1(XBc_".

그러면 감압은 간단합니다. 먼저 기본 126 변환을 수행 한 다음 기본 8 변환을 수행합니다 ( "~\10"{base}/즉, "~\10"각 요소에 대해 기본 변환을 반복 하고 수행). 결과 배열은 3 개의 그룹으로 분할되고의 배열 I은 고정됩니다 ( 3/~4*). 우리는 다음베이스 2에 각 요소를 변환하고 (0을 제거한 후) 문자열의 해당 인덱스의 문자로 각 이진 숫자를 대체 " #"( 2base{" #"=}%...-1%- 메모를 우리가 다른 배열을 반대해야한다는 2될 것"# " 대신을 " #").

보드 / 조각 형식, 조각 떨어 뜨리기
보드는 단순히 각 줄에 하나씩 문자열의 배열입니다. 처음에는 이에 대한 작업이 수행되지 않으므로 n/(입력에 대해 생성 할 수 있습니다 . 조각은 또한 X 위치에 대해 왼쪽에 공백이있는 문자열 배열이지만 후행 공백은 없습니다. 조각은 어레이에 추가하고 충돌이 있는지 지속적으로 테스트하여 떨어집니다.

충돌 테스트는 조각의 모든 캐릭터를 반복하고 보드에서 동일한 위치의 캐릭터와 비교하여 수행됩니다. #+ =#+ #를 충돌 로 간주하고 싶으 므로 ((piecechar & 3) & boardchar)가 0이 아닌지 테스트합니다. 이 반복을 수행하는 동안 #+ , + 쌍의 값을 올바르게 설정하는 ((piecechar & 3) | boardchar)로 보드를 업데이트 (복사본)합니다 #. +[ . 조각을 다른 행 아래로 이동 한 후 충돌이 발생하면이 업데이트 된 보드를 사용합니다.

채워진 행을 제거하는 것은 매우 간단합니다. "= "&false 를 반환 하는 모든 행을 제거합니다 . 채워진 행이 어느 것 =또는 연계가 false로 동일시 빈 문자열이 될 것입니다, 그래서. 그런 다음 제거 된 행의 수를 세고 점수에 수를 더한 다음 그 수를 앞에 추가합니다 "[ ... ]". 우리는 그리드의 첫 번째 행을 복용하고 교체하여이 컴팩트하게 생성 #과를 .

보너스
우리는 조각이 떨어질 때 조각의 각 위치에서 보드가 어떻게 생겼는지 계산하기 때문에이를 삭제하는 대신 스택에 유지할 수 있습니다! 총 3 자 이상이면이 모든 위치를 출력 할 수 있습니다 (또는 보드 상태가 단일 간격 인 경우 2 자).

{):X!-{2B{" #"=}%X" ":f*+-1%}%:P;:>.{>[f]P+:P(!:F;{\(@{3&\(@.2$&F|:F;|}%\+}%\+F!}
do;{"= "&},.,7^.R+:R;[>0="#"/f*]*\+}0"R@1(XBc_""~\10"{base}:B/3/~4*"nIOZTLSJR "
";:"*~;n%)n*~ ]{n*n.}/10R*

여기에서 극단적 인 코드 골프가 진행되고 있습니다 (200 자 미만으로 수행 될 수 있다고 생각하지 않았습니다). 좋은 작업!
ChristopheD

8
놀랄 만한. GolfScript를 이해했으면합니다. 잠깐만 요.
P Daddy

26

Perl, 586523 483472 427407404386387356353

(defined-or //연산자 에는 Perl 5.10이 필요합니다 ).

stdin에서 모든 입력을받습니다. 여전히 심각한 골프가 필요합니다.
^ Q는 ASCII 17 (DC1 / XON), ^ C는 ASCII 3, ^ @는 ASCII 0 (NUL)을 나타냅니다.

while(<>){push@A,[split//]if/]/;while(/\w/g){for$i(0..6){for($f=0,$j=4;$j--;){$c=0;map{if($_){$i--,$f=$j=3,redo if$A[$k=$i+$j][$C=$c+$'+1]ne$";$A[$k][$C]="#"if$f}$c++}split//,unpack"b*",chr vec"3^@'^@c^@^Q^C6^@\"^C^Q^Q",index(OTZLSJI,$&)*4+$j,4;$s+=10,@A[0..$k]=@A[$k,0..$k-1],map{s/#/ /}@{$A[0]},$i++if 9<grep/#/,@{$A[$k]}}last if$f}}}print+(map@$_,@A),$s//0,$/

주석이 달린 버전 :

while(<>){
    # store the playfield as an AoA of chars
    push@A,[split//]if/]/;
    # while we're getting pieces
    while(/\w/g){
            # for each line of playfield
            for$i(0..6){
                    # for each line of current piece
                    for($f=0,$j=4;$j--;){
                            # for each column of current piece
                            $c=0;
                            map{
                                    if($_){
                                            # if there's a collision, restart loop over piece lines
                                            # with a mark set and playfield line decremented
                                            $i--,$f=$j=3,redo if$A[$k=$i+$j][$C=$c+$'+1]ne$";
                                            # if we already found a collision, draw piece
                                            $A[$k][$C]="#"if$f
                                    }
                                    $c++
                            # pieces are stored as a bit vector, 16 bits (4x4) per piece,
                            # expand into array of 1's and 0's
                            }split//,unpack"b*",chr vec"3^@'^@c^@^Q^C6^@\"^C^Q^Q",index(OTZLSJI,$&)*4+$j,4;
                            # if this playfield line is full, remove it. Done by array slicing
                            # and substituting all "#"'s in line 0 with " "'s
                            $s+=10,@A[0..$k]=@A[$k,0..$k-1],map{s/#/ /}@{$A[0]},$i++if 9<grep/#/,@{$A[$k]}
                    }
                    # if we found a collision, stop iterating over the playfield and get next piece from input
                    last if$f
            }
    }
}
# print everything
print+(map@$_,@A),$s//0,$/

편집 1 : 심각한 골프, 출력 버그 수정.
편집 2 : 일부 인라이닝, (드럼 롤 ...) 3 문자, 기타 골프의 그물 절약을 위해 두 개의 루프를 하나로 병합했습니다.
편집 3 : 일반적인 하위 표현 제거, 약간의 지속적인 병합 및 정규식 조정.
편집 4 : 테트로 미노 표현을 패킹 된 비트 벡터, 기타 골프로 변경했습니다.
편집 5 : tetromino 문자에서 배열 인덱스로보다 직접 번역, 인쇄 불가능한 문자 사용, 기타 골프.
편집 6 : Nakilon이 발견 한 r3 (편집 2)에 도입 된 버그 정리 상단 라인 수정. 인쇄 할 수없는 문자를 더 많이 사용하십시오.
편집 7 : vectetromino 데이터를 가져 오는 데 사용 합니다. 플레이 필드의 크기가 고정되어 있다는 사실을 활용하십시오. if성명 =>if수정 자, 편집 2의 루프 병합이 효과가 있기 시작합니다. 사용 //0 점수의 경우에.
편집 8 : Nakilon에 의해 발견 된 r6 (편집 5)에 도입 된 또 다른 버그를 수정했습니다.
편집 9 : 줄을 지울 때 새 참조를 만들지 말고 배열 슬라이스를 통해 참조를 이동하십시오. 두 개 map를 하나로 병합하십시오 . 더 똑똑한 정규식. "스마트" for. 기타 골프.
편집 10 : 인라인 tetromino 배열, 주석 버전 추가.


매우 잘 작동합니다 (이미 사소하지 않은 문제에 대해 이미 멋진 문자 수). 한 가지 작은 특징은 내 perl (perl, darwin-thread-multi-2level 용으로 구축 된 v5.10.0)이 결과를 두 번 인쇄하는 것 (파이프 입력)이라는 것입니다.
ChristopheD

@ChristopheD : 복제 된 출력을 수정했고, 메인 루프 내부에서 인쇄했지만 플레이 필드가없는 라인에만 인쇄했습니다. 줄 바꿈이 너무 많을 것입니다. :)
ninjalj

파이썬을 이길 4 문자 더 !!
Vivin Paliath

1
나는 아직 펄을 포기하지 않았다! xD (지금
poke

@Nakilon : 좋은 캐치! 거기에 좋은 테스트 케이스가 있습니다.
ninjalj 2010 년

24

루비 — 427408 398 369 359

t=[*$<]
o=0
u=->f{f.transpose}
a=u[t.reverse.join.scan /#{'( |#)'*10}/]
t.pop.split.map{|w|m=(g='I4O22Z0121T01201L31S1201J13'[/#{w[0]}\d+/].scan(/0?\d/).zip a.drop w[1].to_i).map{|r,b|(b.rindex ?#or-1)-r.size+1}.max
g.map{|r,b|b.fill ?#,m+r.size,r.to_i}
v=u[a]
v.reject!{|i|i-[?#]==[]&&(o+=10;v)<<[' ']*10}
a=u[v]}
puts u[a].reverse.map{|i|?[+i*''+?]},t[-1],o

아주 좋은 솔루션! 나는 당신이 테로 미노 형태를 정확히 어떻게 인코딩했는지 살펴 봐야 할 것입니다 (이렇게 매우 간결 해 보입니다).
ChristopheD

3
이 코드에 대한 자세한 설명을보고 싶습니다. 너무 아파 보여요…
Nils Riedemann

1
@Nils Riedemann, 지금 설명을 작성하고 있지만 지금 게시하거나 당첨자 발표 후 게시 할 생각입니다.) 어쨌든 일단 모든 질문을 게시하고 답변하겠습니다. 유용한 주요 아이디어가있는 커뮤니티 위키이기 때문입니다.)
Nakilon

데비안의 루비 1.9.2dev (2010-07-30)에서 이것은 paste.org.ru/?6ep1on의 테스트 케이스에서 실패합니다. 또한 항상 플레이 필드를 10 줄로 확장합니까?
ninjalj 2010 년

@ninjalj, ruby ​​1.9.2p0 (2010-08-18) [i386-mingw32] paste.org.ru/?1qnjhj 괜찮아 보입니다. 너비 10은 테트리스 표준이라고 생각합니다.
Nakilon 2010 년

17

Bash 셸 스크립트 ( 301304 자)


업데이트 : 맨 위 줄로 확장되는 조각과 관련된 버그를 수정했습니다. 또한 출력은 이제 표준 출력으로 전송되며, 추가로 스크립트를 다시 실행하여 게임을 계속할 수 있습니다 (이 경우 총 점수를 직접 합산해야 함).

여기에는 인쇄 할 수없는 문자가 포함되어 있으므로 16 진 덤프를 제공했습니다. 다른 이름으로 저장tetris.txt :

0000000: 7461 696c 202d 3120 245f 7c7a 6361 743e  tail -1 $_|zcat>
0000010: 753b 2e20 750a 1f8b 0800 35b0 b34c 0203  u;. u.....5..L..
0000020: 5590 516b 8330 10c7 dff3 296e 4c88 ae64  U.Qk.0....)nL..d
0000030: a863 0c4a f57d 63b0 07f7 b452 88d1 b4da  .c.J.}c....R....
0000040: 1a5d 5369 91a6 df7d 899a d05d 5e72 bfbb  .]Si...}...]^r..
0000050: fbff 2fe1 45d5 0196 7cff 6cce f272 7c10  ../.E...|.l..r|.
0000060: 387d 477c c4b1 e695 855f 77d0 b29f 99bd  8}G|....._w.....
0000070: 98c6 c8d2 ef99 8eaa b1a5 9f33 6d8c 40ec  ...........3m.@.
0000080: 6433 8bc7 eeca b57f a06d 27a1 4765 07e6  d3.......m'.Ge..
0000090: 3240 dd02 3df1 2344 f04a 0d1d c748 0bde  2@..=.#D.J...H..
00000a0: 75b8 ed0f 9eef 7bd7 7e19 dd16 5110 34aa  u.....{.~...Q.4.
00000b0: c87b 2060 48a8 993a d7c0 d210 ed24 ff85  .{ `H..:.....$..
00000c0: c405 8834 548a 499e 1fd0 1a68 2f81 1425  ...4T.I....h/..%
00000d0: e047 bc62 ea52 e884 42f2 0f0b 8b37 764c  .G.b.R..B....7vL
00000e0: 17f9 544a 5bbd 54cb 9171 6e53 3679 91b3  ..TJ[.T..qnS6y..
00000f0: 2eba c07a 0981 f4a6 d922 89c2 279f 1ab5  ...z....."..'...
0000100: 0656 c028 7177 4183 2040 033f 015e 838b  .V.(qwA. @.?.^..
0000110: 0d56 15cf 4b20 6ff3 d384 eaf3 bad1 b9b6  .V..K o.........
0000120: 72be 6cfa 4b2f fb03 45fc cd51 d601 0000  r.l.K/..E..Q....

그런 다음 bash 명령 프롬프트에서 다음과 같이 설치 하는 elvis것이 좋습니다.vimvi .

$ xxd -r tetris.txt tetris.sh
$ chmod +x tetris.sh
$ cat << EOF > b
> [          ]
> [          ]
> [          ]
> [          ]
> [ #    #  #]
> [ ## ######]
> [==========]
> EOF
$ ./tetris.sh T2 Z6 I0 T7 2>/dev/null
-- removed stuff that is not in standard out --
[          ]
[          ]
[          ]
[#      ###]
[#     ### ]
[##### ####]
[==========]
10

작동 원리

이 코드는 실행 프로그램이 gzexe 스크립트를 . Tetromino 조각은 vi 편집기 명령의 시퀀스로 표시됩니다. 문자 계수는 충돌을 감지하는 데 사용되며 줄 계수는 점수를 계산하는 데 사용됩니다.

압축을 푼 코드 :

echo 'rej.j.j.:wq!m'>I
echo '2rejh.:wq!m'>O
echo '2rej.:wq!m'>Z
echo '3rejh1.:wq!m'>T
echo 'rej.j2.:wq!m'>L
echo 'l2rej2h.:wq!m'>S
echo 'lrej.jh2.:wq!m'>J
for t
do for y in `seq 1 5`
do echo -n ${y}jk$((${t:1}+1))l|cat - ${t:0:1}|vi b>0
grep ========== m>0||break
[ `tr -cd '#'<b|wc -c` = `tr -cd '#'<m|wc -c` ]||break
tr e '#'<m>n
done
cat n>b
grep -v '##########' b>m
$((S+=10*(`wc -l < b`-`wc -l < m`)))
yes '[          ]'|head -7|cat - m|tail -7>b
done
cat b
echo $S

골프를 치기 전의 원래 코드 :

#!/bin/bash

mkpieces() {
    pieces=('r@j.j.j.' '2r@jh.' '2r@j.' '3r@jh1.' 'r@j.j2.' 'l2r@j2h.' 'lr@j.jh2.')
    letters=(I O Z T L S J)

    for j in `seq 0 9`; do
        for i in `seq 0 6`; do
            echo "jk$(($j+1))l${pieces[$i]}:wq! temp" > ${letters[$i]}$j
        done
    done
}

counthashes() {
    tr -cd '#' < $1 | wc -c
}

droppiece() {
    for y in `seq 1 5`; do
        echo -n $y | cat - $1 | vi board > /dev/null
        egrep '={10}' temp > /dev/null || break
        [ `counthashes board` -eq `counthashes temp` ] || break
        tr @ "#" < temp > newboard
    done
    cp newboard board
}

removelines() {
    egrep -v '#{10}' board > temp
    SCORE=$(($SCORE + 10 * (`wc -l < board` - `wc -l < temp`)))
    yes '[          ]' | head -7 | cat - temp | tail -7 > board
}

SCORE=0
mkpieces
for piece; do
    droppiece $piece
    removelines
done
cat board
echo $SCORE

1
bash 파일, 압축을 풀고 vi .. 실행하는 .. 그러한 혐오의 적법성에 대해 확신하지 못하지만 가장 인상적입니다. +1. 당신에게 찬사를 보냅니다.
Michael Anderson

완료하는 데 엄청나게 오랜 시간이 걸리고 테스트 케이스 "T2 Z6 I0 T7 T2 Z6 T2 I5 I1 I0 T4 O8 T1 T6 T3 Z0 I9 I6 O7 T3 I2 O0 J8 L6 O7 O4 I3 J8 S6 O1 I0 O4 "(예제 입력과 동일한 보드). 더욱이 수천 개의 쓰레기 라인이 파이프로 연결될 때 표준 출력이되고 보드의 결과가 아마도 거기로 갈 것입니다.
Nabb

Vim 대신에 Elvis를 vi로 설치하면 훨씬 빠를 것입니다.
PleaseStand 2010 년

2
@Nabb : 방금 세 문자를 사용하여 모든 문제를 해결했습니다.
PleaseStand 2010 년

와. 그것은 bash의 꽤 인상적인 남용입니다.
P Daddy

13

파이썬 : (504 개) 519 문자

(Python 3 솔루션) 현재 상단에 표시된 형식으로 입력을 설정해야합니다 (입력 코드는 계산되지 않음). 나중에 파일이나 stdin에서 읽을 수 있도록 확장하겠습니다. 이제 프롬프트로 작동합니다. 입력을 (총 8 줄)에 붙여 넣습니다.

R=range
f,p=[input()[1:11]for i in R(7)],p
for(a,b)in input().split():
 t=[' '*int(b)+r+' '*9for r in{'I':'#,#,#,#','O':'##,##','Z':'##, ##','T':'###, # ','L':'#,#,##','S':' ##,##','J':' #, #,##'}[a].split(',')]
 for r in R(6-len(t),0,-1):
  for i in R(len(t)):
   if any(a==b=='#'for(a,b)in zip(t[i],f[r+i])):break
  else:
   for i in R(0,len(t)):
    f[r+i]=''.join(a if b!='#'else b for(a,b)in zip(t[i],f[r+i]))
    if f[r+i]=='#'*10:del f[r+i];f[0:0]=[' '*10];p+=10
   break
print('\n'.join('['+r+']'for r in f[:7]),p,sep='\n')

거기에 훨씬 더 많이 저축 할 수 있는지 확실하지 않습니다. 비트 필드로의 변환에서 상당히 많은 문자가 손실되지만 문자열로 작업하는 것보다 훨씬 더 많은 문자를 절약 할 수 있습니다. 또한 더 많은 공백을 제거 할 수 있는지 확실하지 않지만 나중에 시도해 보겠습니다.
더 많이 줄일 수는 없습니다. 비트 필드 기반 솔루션을 사용한 후 더 압축하는 방법을 찾았 기 때문에 문자열로 다시 전환했습니다 (비트 필드에 8 자 저장!). 하지만 포함하는 것을 잊고 L안에있는 포인트에 오류가있어서 캐릭터 수는 한숨 만 올라갈뿐 ... 나중에 좀 더 압축 할 무언가를 찾을 수도 있지만, 거의 끝이 났다고 생각합니다. 원본 및 주석 처리 된 코드는 아래를 참조하십시오.

원래 버전 :

field = [ input()[1:11] for i in range(7) ] + [ 0, input() ]
# harcoded tetrominoes
tetrominoes = {'I':('#','#','#','#'),'O':('##','##'),'Z':('##',' ##'),'T':('###',' # '),'L':('#','#','##'),'S':(' ##','##'),'J':(' #',' #','##')}
for ( f, c ) in field[8].split():
    # shift tetromino to the correct column
    tetromino = [ ' ' * int(c) + r + ' ' * 9 for r in tetrominoes[f] ]

    # find the correct row to insert
    for r in range( 6 - len( tetromino ), 0, -1 ):
        for i in range( len( tetromino ) ):
            if any( a == b == '#' for (a,b) in zip( tetromino[i], field[r+i] ) ):
                # skip the row if some pieces overlap
                break
        else:
            # didn't break, insert the tetromino
            for i in range( 0, len( tetromino ) ):
                # merge the tetromino with the field
                field[r+i] = ''.join( a if b != '#' else b for (a,b) in zip( tetromino[i], field[r+i] ) )

                # check for completely filled rows
                if field[r+i] == '#' * 10:
                    # remove current row
                    del field[r+i]
                    # add new row
                    field[0:0] = [' '*10]
                    field[7] += 10
            # we found the row, so abort here
            break
# print it in the requested format
print( '\n'.join( '[' + r + ']' for r in field[:7] ) )
# and add the points = 10 * the number of redundant lines at the end
print( str( field[7] ) )

나는 이것이 옳다고 생각하지 않는다. 밑줄 만 사라질 수 있다는 규칙은 없지만 댓글로 판단하면 그 줄만 확인합니다.
Michael Madsen

작업에서와 같이 입력하십시오. 내 말은, 파일이나 STDIN의 입력입니다.
Nakilon 2010 년

6
축소 된 Python 코드도 여전히 상당히 읽기 쉬운 것이 마음에 들지 않습니까?
EMP

펄 또는 말레 볼제)에 비해 @Evgeny, 경우에만
Nakilon

글쎄, 나는 다른 코드 골프 답변에 비해 "읽을 수 있음"을 의미했습니다!
EMP

13

루비 1.9, 357 355 353 339 330 310 309 자

d=0
e=[*$<]
e.pop.split.map{|f|f="L\003\003\007J\005\005\007O\007\007Z\007\013S\013\007I\003\003\003\003T\017\005"[/#{f[j=0]}(\W*)/,1].bytes.map{|z|?\0+?\0*f[1].hex+z.to_s(2).tr("01"," #")[1,9]}
k,f,i=i,[p]+f,e.zip(f).map{|l,m|l.bytes.zip(m.to_s.bytes).map{|n,o|j|=n&3&q=o||0;(n|q).chr}*""}until j>0
e=[]
e+=k.reject{|r|r.sum==544&&e<<r.tr(?#,?\s)&&d+=10}}
puts e,d

점을 유의 \000(세 번째 줄에 널 바이트 포함) 이스케이프가 실제 인쇄 할 수없는 등가로 대체되어야한다.

샘플 입력 :

[          ]
[          ]
[          ]
[          ]
[ #    #  #]
[ ## ######]
[==========]
T2 Z6 I0 T7

용법:

ruby1.9 tetris.rb < input

또는

ruby1.9 tetris.rb input

테트로 미노를 떨어 뜨리고 모든 유리를 경계선이 있더라도 배열로 유지하는 또 다른 방법입니다. 이제 당신은 Ruby / Perl 리더가 될 것입니다. 추신 :에 대해 몰랐습니다 ?\s.
Nakilon 2010 년

12

기음 , 727 [...] 596 581 556 517 496 471 461 457 문자

이것은 내 첫 번째 코드 골프입니다. 문자 수가 훨씬 줄어들 수 있다고 생각 합니다. 숙련 된 골퍼가 힌트를 줄 수 있다면 좋을 것입니다.

현재 버전은 다른 차원의 플레이 필드도 처리 할 수 ​​있습니다. 입력은 DOS / Windows 및 Unix 형식 모두에서 줄 바꿈을 가질 수 있습니다.

코드는 최적화 이전에 매우 간단했습니다. 테트로 미노는 (7 * 3) x4 비트 배열로 해석되는 4 개의 정수로 저장되고, 플레이 필드는있는 그대로 저장되고, 타일이 삭제되고 각 시작과 이후에 완전한 라인이 제거됩니다. 타일 ​​드롭.

문자 수를 계산하는 방법을 몰랐기 때문에 불필요한 줄 바꿈을 모두 제거하고 코드의 파일 크기를 사용했습니다.

편집 596 => 581 : KitsuneYMG 덕분에 %ls제안을 제외한 모든 것이 완벽하게 작동했으며, putch대신 대신 putchar사용할 수 있음 ( getch어떻게 든 작동하지 않음)을 발견하고에서 모든 괄호를 제거했습니다 #define G.

수정 581 => 556 : 나머지 루프 for와 중첩 된 F루프에 만족하지 않았 으므로 루프를 병합, 변경 및 제거하는 작업이 있었는데, 꽤 혼란 스럽지만 그만한 가치가 있습니다.

편집 556 => 517 : 마침내 만드는 방법을 찾았습니다 a int 배열 . 일부 N;cbreak이상와 병합 되지 않았습니다.

수정 496 => 471 : 이제 플레이 필드 너비 높이가 수정되었습니다.

편집 471 => 461 : 사소한 수정, putcharputch 표준 기능이 아니므 로 다시 사용됩니다 .

편집 : 버그 수정, 대신 타일 드롭 전에 전체 줄이 제거 되었으므로 전체 줄이 끝에 남을 수 있습니다. 수정은 문자 수를 변경하지 않습니다.

#define N (c=getchar())
#define G T[j%4]&1<<t*3+j/4
#define X j%4*w+x+j/4
#define F(x,m) for(x=0;x<m;x++)
#define W while
T[]={916561,992849,217,1},C[99],c,i,j,s,t,x,A,a[99],w=13;
main(){F(j,7)C["IJLSTZO"[j]]=j;
F(j,91)a[j]=N;
W(N>w){t=C[c];x=N-86;
W(c){F(j,12)if(G&&X>1?a[X]-32:0)c=0;
F(j,12)if(G&&X>w&&!c)a[X-w]=35;x+=w;}N;
F(i,6){A=0;t=i*w;F(x,w)A|=(a[t+x]==32);
if(!A){s++;F(j,t)a[t+w-j]=a[t-j];
x=1;W(a[x]-93)a[x++]=32;}}}
F(i,91)putchar(a[i]);printf("%i0",s);}

1
당신은 정의 할 수 없습니다 for#define F(x,m) for(x=0;x++<m;)? 그것은 C #에서 작동합니다 ... : P
BrunoLM

@BrunoLM : 감사합니다. 그러나 이것은 작동하지 않습니다. fe F(x,3){printf("%i",x}는 이 변경 12대신 인쇄 합니다 012. 로 변경할 수 for(x=-1;x++<m;)있지만 아무것도 저장하지 않습니다. :)
schnaader

1
코드를 올바르게 작성했다면 C로 컴파일하면 stdio.h를 포함 할 필요가 없습니다. 몇 개의 문자를 저장하십시오 :)

1
N의 정의를 (c=getchar())6 문자를 절약하는 모든 c = N 행으로 바꾸고 제거 할 수 있습니다 . 내가 이것에 대해 틀리지 않는 한, 당신은 585
KitsuneYMG

1
type은 최소한 C89의 경우 변수에 대해서도 int로 기본 설정됩니다.
ninjalj

8

파이썬 2.6+ - 334 322 316 자

397 368 366 자 비 압축

#coding:l1
exec'xÚEPMO!½ï¯ i,P*Ýlš%ì­‰=‰Ö–*†­þz©‰:‡—Lò¾fÜ”bžAù,MVi™.ÐlǃwÁ„eQL&•uÏÔ‹¿1O6ǘ.€LSLÓ’¼›î”3òšL¸tŠv[ѵl»h;ÁºŽñÝ0Àë»Ç‡ÛûH.ª€¼âBNjr}¹„V5¾3Dë@¼¡•gO. ¾ô6 çÊsÃЮürÃ1&›ßVˆ­ùZ`Ü€ÿžcx±ˆ‹sCàŽ êüRô{U¯ZÕDüE+³ŽFA÷{CjùYö„÷¦¯Î[0þøõ…(Îd®_›â»E#–Y%’›”ëýÒ·X‹d¼.ß9‡kD'.decode('zip')

하나의 개행 문자가 필요하며 한 문자로 계산했습니다.

브라우저 코드 페이지 mumbo jumbo는이 코드의 성공적인 복사 및 붙여 넣기를 방해 할 수 있으므로 선택적으로 다음 코드에서 파일을 생성 할 수 있습니다.

s = """
23 63 6F 64 69 6E 67 3A 6C 31 0A 65 78 65 63 27 78 DA 45 50 4D 4F 03 21
10 BD EF AF 20 69 2C 50 2A 02 DD 6C 9A 25 EC AD 07 8D 89 07 3D 89 1C D6
96 2A 86 05 02 1B AD FE 7A A9 89 3A 87 97 4C F2 BE 66 DC 94 62 9E 41 F9
2C 4D 56 15 69 99 0F 2E D0 6C C7 83 77 C1 16 84 65 51 4C 26 95 75 CF 8D
1C 15 D4 8B BF 31 4F 01 36 C7 98 81 07 2E 80 4C 53 4C 08 D3 92 BC 9B 11
EE 1B 10 94 0B 33 F2 9A 1B 4C B8 74 8A 9D 76 5B D1 B5 6C BB 13 9D 68 3B
C1 BA 8E F1 DD 30 C0 EB BB C7 87 DB FB 1B 48 8F 2E 1C AA 80 19 BC E2 42
4E 6A 72 01 7D B9 84 56 35 BE 33 44 8F 06 EB 40 BC A1 95 67 4F 08 2E 20
BE F4 36 A0 E7 CA 73 C3 D0 AE FC 72 C3 31 26 9B DF 56 88 AD F9 5A 60 DC
80 FF 9E 63 78 B1 88 8B 73 43 E0 8E A0 EA FC 52 F4 7B 55 8D AF 5A 19 D5
44 FC 45 2B B3 8E 46 9D 41 F7 7B 43 6A 12 F9 59 F6 84 F7 A6 01 1F AF CE
5B 30 FE F8 F5 85 28 CE 64 AE 5F 9B E2 BB 45 23 96 59 25 92 9B 94 EB FD
10 D2 B7 58 8B 64 BC 2E DF 39 87 6B 44 27 2E 64 65 63 6F 64 65 28 27 7A
69 70 27 29
"""

with open('golftris.py', 'wb') as f:
    f.write(''.join(chr(int(i, 16)) for i in s.split()))

테스팅

인 테트리스

[]
[]
[]
[]
[# # #]
[## ######]
[==========]
T2 Z6 I0 T7

줄 바꿈은 Unix 스타일이어야합니다 (줄 바꿈 만 해당). 마지막 줄의 후행 개행은 선택 사항입니다.

테스트하려면 :

> 파이썬 golftris.py <intetris
[]
[]
[]
[# ###]
[# ###]
[##### ####]
[==========]
10

이 코드는 압축을 풀고 원래의 코드를, 그리고 그것을 실행합니다 exec. 이 압축 해제 된 코드의 무게는 366 자이며 다음과 같습니다.

import sys
r=sys.stdin.readlines();s=0;p=r[:1];a='[##########]\n'
for l in r.pop().split():
 n=int(l[1])+1;i=0xE826408E26246206601E>>'IOZTLSJ'.find(l[0])*12;m=min(zip(*r[:6]+[a])[n+l].index('#')-len(bin(i>>4*l&31))+3for l in(0,1,2))
 for l in range(12):
  if i>>l&2:c=n+l/4;o=m+l%4;r[o]=r[o][:c]+'#'+r[o][c+1:]
 while a in r:s+=10;r.remove(a);r=p+r
print''.join(r),s

줄 바꿈은 필수이며 각각 한 문자입니다.

이 코드를 읽으려고하지 마십시오. 변수 이름은 가장 높은 압축률을 찾기 위해 문자 그대로 무작위로 선택됩니다 (다른 변수 이름으로 압축 후 최대 342 자까지 보았습니다). 더 이해하기 쉬운 버전은 다음과 같습니다.

import sys

board = sys.stdin.readlines()
score = 0
blank = board[:1] # notice that I rely on the first line being blank
full  = '[##########]\n'

for piece in board.pop().split():
    column = int(piece[1]) + 1 # "+ 1" to skip the '[' at the start of the line

    # explanation of these three lines after the code
    bits = 0xE826408E26246206601E >> 'IOZTLSJ'.find(piece[0]) * 12
    drop = min(zip(*board[:6]+[full])[column + x].index('#') -
               len(bin(bits >> 4 * x & 31)) + 3 for x in (0, 1, 2))

    for i in range(12):
        if bits >> i & 2: # if the current cell should be a '#'
            x = column + i / 4
            y = drop + i % 4
            board[y] = board[y][:x] + '#' + board[y][x + 1:]

    while full in board:      # if there is a full line,
        score += 10           # score it,
        board.remove(full)    # remove it,
        board = blank + board # and replace it with a blank line at top
        
print ''.join(board), score

핵심은 내가 설명하겠다고 말한 세 가지 비밀 라인에 있습니다.

테트로 미노의 모양은 16 진수로 인코딩됩니다. 각 테트로 니모는 셀의 3x4 그리드를 차지하는 것으로 간주되며 각 셀은 공백 (공백) 또는 전체 (숫자 기호)입니다. 그런 다음 각 조각은 3 개의 16 진수로 인코딩되며 각 숫자는 하나의 4 셀 열을 설명합니다. 최하위 숫자는 가장 왼쪽 열을 설명하고 각 숫자의 최하위 비트는 각 열의 최상위 셀을 설명합니다. 비트가 0이면 해당 셀은 비어 있고 그렇지 않으면 '#'입니다. 예를 들어, I tetronimo는 00F최하위 열에있는 4 개의 숫자 기호를 인코딩하기 위해 설정된 최하위 숫자의 4 비트와 왼쪽 및 오른쪽에 설정된 상단 비트 를 사용하여로 인코딩됩니다 . 중간에 설정된 상위 2 개 비트입니다. T131

그러면 전체 16 진수가 왼쪽으로 1 비트 이동됩니다 (2 배). 이렇게하면 맨 아래 부분을 무시할 수 있습니다. 잠시 후에 이유를 설명하겠습니다.

따라서 입력에서 현재 조각이 주어지면 모양을 설명하는 12 비트가 시작되는 16 진수로 인덱스를 찾은 다음 bits변수 의 1-12 비트 (비트 0 건너 뛰기)가 현재 조각을 설명 하도록 아래로 이동합니다 .

에 대한 할당 drop은 조각이 다른 조각 조각에 착지하기 전에 조각이 떨어지는 그리드의 맨 위에서 몇 개의 행 을 결정합니다. 첫 번째 줄은 경기장의 각 열 상단에 얼마나 많은 빈 셀이 있는지 찾는 반면 두 번째 줄은 조각의 각 열에서 가장 낮은 점유 셀을 찾습니다. 이 zip함수는 튜플 목록을 반환합니다. 여기서 각 튜플은 입력 목록의 각 항목에서 n 번째 셀로 구성됩니다 . 따라서 샘플 입력 보드를 사용하면 zip(board[:6] + [full])다음이 반환됩니다.

[
 ('[', '[', '[', '[', '[', '[', '['),
 (' ', ' ', ' ', ' ', ' ', ' ', '#'),
 (' ', ' ', ' ', ' ', '#', '#', '#'),
 (' ', ' ', ' ', ' ', ' ', '#', '#'),
 (' ', ' ', ' ', ' ', ' ', ' ', '#'),
 (' ', ' ', ' ', ' ', ' ', '#', '#'),
 (' ', ' ', ' ', ' ', ' ', '#', '#'),
 (' ', ' ', ' ', ' ', '#', '#', '#'),
 (' ', ' ', ' ', ' ', ' ', '#', '#'),
 (' ', ' ', ' ', ' ', ' ', '#', '#'),
 (' ', ' ', ' ', ' ', '#', '#', '#'),
 (']', ']', ']', ']', ']', ']', ']')
]

이 목록에서 적절한 열에 해당하는 튜플을 선택하고 열에서 첫 번째 인덱스를 찾습니다 '#'. 이것은 우리가 호출하기 전에 "전체"행을 추가하는 이유입니다 zip, 그래서 index열이 비어 그렇지 않으면 때 (예외 상황을 던지는 대신에) 합리적인 수익을해야합니다.

그런 다음 '#'조각의 각 열 에서 가장 낮은 값을 찾기 위해 해당 열을 설명하는 4 비트를 이동하고 마스킹 한 다음 bin함수를 사용하여이를 1과 0의 문자열로 변환합니다. 이 bin함수는 중요한 비트 만 반환하므로 가장 낮은 점유 셀 (최상위 세트 비트)을 찾기 위해이 문자열의 길이 만 계산하면됩니다. bin기능은 앞에 추가 '0b'우리가 그것을 뺄 그래서. 또한 최하위 비트도 무시합니다. 이것이 16 진수가 왼쪽으로 1 비트 이동하는 이유입니다. 이것은 문자열 표현이 맨 위 셀만 가득 찬 열 (예 : T 조각) 과 길이가 동일한 빈 열을 고려하기위한 것 입니다.

예를 들어,의 열 I의 로, 앞서 언급의 Tetromino이 있습니다 F, 0그리고 0. bin(0xF)입니다 '0b1111'. 를 무시하면 '0b'길이가 4가됩니다. 그러나 bin(0x0)입니다 0b0. 를 무시한 '0b'후에도 여전히 '1'의 길이가 있으며 이는 올바르지 않습니다. 이를 설명하기 위해 우리는이 중요하지 않은 비트를 무시할 수 있도록 끝에 추가 비트를 추가했습니다. 따라서 +3코드 '0b'의 시작 부분과 끝 부분에 중요하지 않은 비트가 차지하는 추가 길이를 설명합니다 .

이 모든 것은 세 열 ( (0,1,2))에 대한 생성기 표현식 내에서 발생하며 , min결과를 가져와 세 열 중 하나에 닿기 전에 조각이 드롭 할 수있는 최대 행 수를 찾습니다.

나머지는 코드를 읽으면 이해하기 쉬울 것입니다. 그러나 for이러한 할당을 따르는 루프는 조각을 보드에 추가합니다. 그 후 while루프는 전체 행을 제거하고 상단의 빈 행으로 대체하고 점수를 집계합니다. 마지막에 보드와 점수가 출력에 인쇄됩니다.


6

Python, 298 자

지금까지 난해하지 않은 모든 언어 솔루션을 능가합니다 (Perl, Ruby, C, bash ...).


... 코드 압축 치카 너리도 사용하지 않습니다.

import os
r=os.read
b='[%11c\n'%']'*99+r(0,91)
for k,v in r(0,99).split():
    t=map(ord,' -:G!.:; -:; !-.!"-. !". !./')['IJLOSTZ'.find(k)*4:][:4];v=int(v)-31
    while'!'>max(b[v+j+13]for j in t):v+=13
    for j in t:b=b[:v+j]+'#'+b[v+j+1:]
    b=b.replace('[##########]\n','')
print b[-91:],1060-10*len(b)/13

테스트 예

[          ]
[          ]
[          ]
[          ]
[ #    #  #]
[ ## ######]
[==========]
T2 Z6 I0 T7

그것은 출력

[          ]
[          ]
[          ]
[#      ###]
[#     ### ]
[##### ####]
[==========]
10

추신. +5의 비용으로 Nakilon이 지적한 버그를 수정했습니다.


꽤 인상적인 코드입니다. 더 나은 방법이 없다면 수정하는 데 14 개의 문자가 더 필요하지만 ( ideone.com/zeuYB ) 여전히 GolfScript와 Bash를 제외한 모든 것을 능가합니다. 확실히 영리한 솔루션입니다.
P Daddy

예, 아주 훌륭한 솔루션입니다!
ChristopheD

@Nakilon : 감사합니다, 분명히 그 하나를 놓쳤습니다. 고정 @ 비용 293-> 298
Nas Banov

@P 아빠, 감사합니다-나는 "모든 비 밀교 적"이라고 솔직하게 말할 수 있도록 bash & toolchain 아래에 수정을 가져 오는 방법을 찾았습니다 :)
Nas Banov

@Nabb : 코드를 짧게 유지하기 위해 몇 가지 제한 사항을 염두에두고 작성되었습니다. 최대 33 개의 tetrominos와 최대 99 개의 라인 드롭과 같은 것입니다. +3의 가격으로 쉽게 확장 할 수 있습니다. 또는 저가의 경우 :) 제한을 완전히 해제 할 수 있습니다. BTW, 이것은 테스트 세트를 갖는 것이 사양을 명확히하는 방법의 좋은 예입니다 (주석에서 ChristopherD를 도청하고 있었던 것)
Nas Banov

5

Golfscript 260 자

저는 이것이 개선 될 수 있다고 확신합니다. 저는 Golfscript를 처음 접했습니다.

[39 26.2/0:$14{.(}:?~1?15?1?14 2??27?13.!14?2?27?14 1]4/:t;n/)\n*:|;' '/-1%.,:c;~{)18+:&;'XIOZTLSJX'\%~;,1-t\={{.&+.90>{;.}*|\=32=!{&13-:&;}*}%}6*{&+}/|{\.@<'#'+\)|>+}4*{'['\10*']'++}:
;n/0\~n+:|;0\{.'#'
={;)}{n+|+:|;}if\.}do;' '
n+\.@*|+\$+:$;.,1-<:|;}c*|n?$*

줄의 끝은 관련이 있습니다 (끝에 하나가 있어서는 안 됨). 어쨌든 다음은 내가 사용한 테스트 사례 중 일부입니다.

> 고양이 init.txt 
[]
[]
[]
[]
[# # #]
[## ######]
[==========]
T2 Z6 I0 T7> 고양이 init.txt | 루비 golfscript.rb tetris.gsc
[]
[]
[]
[# ###]
[# ###]
[##### ####]
[==========]
10

> 고양이 init.txt
[]
[]
[]
[]
[# # #]
[## #####]
[==========]
I0 O7 Z1 S4> 고양이 init.txt | 루비 golfscript.rb tetris.gsc
[]
[]
[]
[#]
[### ####]
[### #####]
[==========]
10

> 고양이 init.txt
[]
[]
[]
[## ###]
[# #]
[## ######]
[==========]
T7 I0 I3> 고양이 init.txt | 루비 golfscript.rb tetris.gsc
[]
[]
[]
[]
[# #]
[## # # #]
[==========]
20

입력 파일에는 줄 끝이 없으며 줄 끝은 스크립트를 그대로 중단합니다.


2
/ 나 그것은 ... 진정한 대회 언어는 아니 GolfScript을 골프 작업에 직선 모양의 단지 도서관,있어 고려 ...이 라이브러리의 크기는 ... golfscript 코드의 크기에 추가 할 수 있습니다
Nakilon

4
@Nakilon-원시 기계 언어로 작성되지 않은 것에 대해 비슷한 말을 할 수 없습니까? :) Python 인터프리터는 라이브러리 일 뿐이며 항목에 크기를 추가합니다. </ sarcasm>
bta 2010 년

2
@Nakilon : 그것은 단지 통역사입니다. 다른 언어로도 쓸 수 있습니다. 여전히 Golfscript가 실제 언어가 아니라고 말씀 하시겠습니까?
Michael Foukarakis 2010 년

1
@Nabb : 고마워요, 제가 놓친 트릭이 있다고 생각했습니다 ... 기분 나빠하지 마세요, 제 코드를 이해하는 것도 신경 쓰지 않았습니다. :).
coderaj

1
@Michael Foukarakis, 1 분 안에 통역사를 써서이 작업을 한 문자로 해결할 수 있습니다.
Nakilon 2010 년

4

O'Caml 809 개 782 숯을

open String let w=length let c s=let x=ref 0in iter(fun k->if k='#'then incr x)s;!x open List let(@),g,s,p,q=nth,ref[],ref 0,(0,1),(0,2)let l=length let u=Printf.printf let rec o x i j=let a=map(fun s->copy s)!g in if snd(fold_left(fun(r,k)(p,l)->let z=c(a@r)in blit(make l '#')0(a@r)(i+p)l;if c(a@r)=z+l then r+1,k else r,false)(j-l x+1,true)x)then g:=a else o x i(j-1)and f x=let s=read_line()in if s.[1]='='then g:=rev x else f(sub s 1 10::x)let z=f [];read_line();;for i=0to w z/3 do o(assoc z.[i*3]['I',[p;p;p;p];'O',[q;q];'Z',[q;1,2];'T',[0,3;1,1];'L',[p;p;q];'S',[1,2;q];'J',[1,1;1,1;q]])(Char.code z.[i*3+1]-48)(l!g-1);let h=l!g in g:=filter(fun s->c s<>w s)!g;for i=1to h-(l!g)do incr s;g:=make 10' '::!g done;done;iter(fun r->u"[%s]\n"r)!g;u"[==========]\n";u"%d\n"(!s*10)

4

커먼 리스프 667 657 645 개 숯을

코드 골프에 대한 첫 시도이므로 아직 모르는 트릭이 많이있을 것입니다. 약간의 "가독성"을 유지하기 위해 몇 개의 줄 바꿈을 남겼습니다 (줄 바꿈을 2 바이트로 계산 했으므로 6 개의 불필요한 줄 바꿈을 제거하면 12 개의 문자가 더 늘어납니다).

입력에서 먼저 도형을 입력 한 다음 필드를 입력합니다.

(let(b(s 0)m(e'(0 1 2 3 4 5 6 7 8 9)))
(labels((o(p i)(mapcar(lambda(j)(+ i j))p))(w(p r)(o p(* 13 r)))(f(i)(find i b))
(a(&aux(i(position(read-char)"IOZTLSJ")))(when i(push(o(nth i'((0 13 26 39)(0 1 13 14)(0 1 14 15)(0 1 2 14)(0 13 26 27)(1 2 13 14)(1 14 26 27)))(read))m)(a))))
(a)(dotimes(i 90)(if(find(read-char)"#=")(push i b)))(dolist(p(reverse m))
(setf b`(,@b,@(w p(1-(position-if(lambda(i)(some #'f(w p i)))e)))))
(dotimes(i 6)(when(every #'f(w e i))(setf s(1+ s)b(mapcar(lambda(k)(+(if(>(* 13 i)k)13(if(<=(* 13(1+ i))k)0 78))k))b)))))
(dotimes(i 6)(format t"[~{~:[ ~;#~]~}]
"(mapcar #'f(w e i))))(format t"[==========]
~a0"s)))

테스팅

T2 Z6 I0 T7
[          ]
[          ]
[          ]
[          ]
[ #    #  #]
[ ## ######]
[==========]
[          ]
[          ]
[          ]
[#      ###]
[#     ### ]
[##### ####]
[==========]
10
NIL

너무 짧지는 않지만 추함을 위해 +1! 나는 그것이 괄호와 함께 제공되면 알파벳 수프가 어떻게 생겼는지 상상합니다.
P Daddy

@P 아빠 : 감사합니다. 예, 아마 그렇게 보일 것입니다. :).
lpetru 2010 년

2

루비 505 479 474 442 439 426 문자

첫 번째 시도. IronRuby와 함께했습니다. 나는 그것이 개선 될 수 있다고 확신하지만, 나는 정말로 오늘 약간의 일을 끝내야한다!

p,q,r,s=(0..9),(0..2),(0..6),0
t=[*$<]
f=p.map{|a|g=0;r.map{|b|g+=2**b if t[6-b][a+1]==?#};g}
t.pop.split.map{|x|w,y=[15,51,306,562,23,561,113]["IOZTLSJ"=~/#{x[0]}/],x[1].to_i
l=q.map{|d|r.inject{|b,c|f[d+y]&(w>>(d*4)&15-c+1)>0?c:b}}.max
q.map{|b|f[b+y]|=w>>(b*4)&15-l}
r.map{i=f.inject{|a,b|a&b};f.map!{|a|b=i^(i-1);a=((a&~b)>>1)+(a&(b>>1))};s+=i>0?10:0}}
p.map{|a|r.map{|b|t[6-b][a+1]=f[a]&2**b>0??#:' '}}
puts t,s

테스팅

cat test.txt | ruby tetris.rb
[          ]
[          ]
[          ]
[          ]
[#      ###]
[#     ### ]
[##### ####]
[==========]
10

일반 루비를 사용하여 지금 편집하십시오 . 벽 출력을 얻었습니다 ..


루비 스트 하나 더! 그러나 벽돌 주위에 유리를 만드십시오.
Nakilon 2010 년

1

Ruby의 또 다른 문자 , 573546

: **

Z={I:?#*4,J:'#,###',L:'###,#',O:'##,##',S:'#,##, #',Z:' #,##,#',T:' #,##, #'}
t=[*$<]
R=->s{s.reverse}
T=->m{m.transpose}
a = T[R[t].join.scan /.#{'(\D)'*10}.$/]
t.pop.split.each{|z|
t,o=Z[z[0].to_sym].split(',').map{|x|x.split //},z[1].to_i
r=0..t.size-1
y=r.map{|u|1+a[o+u].rindex(?#).to_i-t[u].count(' ')}.max
(0..3).each{|i|r.each{|j|t[j][i]==?#&&a[o+j][y+i]=t[j][i]}}}
s=0
a.each{|x|s=a.max_by(&:size).size;x[s-=1]||=' 'while s>0}
a=R[T[a].reject{|x|x*''=~/[#]{10}/&&s+=10}.map{|x|?[+x*''+?]}[0..6]]
puts (0..8-a.size).map{?[+' '*10+?]},a,s

테스트 :

cat test.txt | ruby 3858384_tetris.rb
[          ]
[          ]
[          ]
[          ]
[#      ###]
[#     ### ]
[##### ####]
[==========]
10

수정a.each{|x|s=a.max_by(&:size).size;x[s-=1]||=' 'while s>0}
glebm 2010 년
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.