다음 테이블을 출력하십시오.

一一得一
一二得二 二二得四
一三得三 二三得六 三三得九
一四得四 二四得八 三四十二 四四十六
一五得五 二五一十 三五十五 四五二十 五五二十五
一六得六 二六十二 三六十八 四六二十四 五六三十 六六三十六
一七得七 二七十四 三七二十一 四七二十八 五七三十五 六七四十二 七七四十九
一八得八 二八十六 三八二十四 四八三十二 五八四十 六八四十八 七八五十六 八八六十四
一九得九 二九十八 三九二十七 四九三十六 五九四十五 六九五十四 七九六十三 八九七十二 九九八十一

또는 일부 언어가 한자를 지원하지 않는 경우 영어 단어에서 처음 세 글자를 사용할 수 있습니다.

OneOneGetOne
OneTwoGetTwo TwoTwoGetFou
OneThrGetThr TwoThrGetSix ThrThrGetNin
OneFouGetFou TwoFouGetEig ThrFouTenTwo FouFouTenSix
OneFivGetFiv TwoFivOneTen ThrFivTenFiv FouFivTwoTen FivFivTwoTenFiv
OneSixGetSix TwoSixTenTwo ThrSixTenEig FouSixTwoTenFou FivSixThrTen SixSixThrTenSix
OneSevGetSev TwoSevTenFou ThrSevTwoTenOne FouSevTwoTenEig FivSevThrTenFiv SixSevFouTenTwo SevSevFouTenNin
OneEigGetEig TwoEigTenSix ThrEigTwoTenFou FouEigThrTenTwo FivEigFouTen SixEigFouTenEig SevEigFivTenSix EigEigSixTenFou
OneNinGetNin TwoNinTenEig ThrNinTwoTenSev FouNinThrTenSix FivNinFouTenFiv SixNinFivTenFou SevNinSixTenThr EigNinSevTenTwo NinNinEigTenOne

공백 / 쉼표 / ​​탭으로 구분 된 일반 텍스트와 빈 줄이 비어 있거나 존재하지 않는 2D 배열 (2 * 1 장소가 비어 있으므로 아무 것도 없어야 함)과 같은 합리적인 형식으로 출력 할 수 있습니다. 정렬).

코드 골프, 바이트 단위의 가장 짧은 코드가 승리합니다. GBK 인코딩이 허용되며 각 중국어 문자는 2 바이트를 사용합니다.

테이블 변환 :

一   One
二   Two
三   Thr
四   Fou
五   Fiv
六   Six
七   Sev
八   Eig
九   Nin
十   Ten
得   Get

Stax , 66 자

9mYF"得一二三四五六七八九"cacy*~@ny@\p;11AH:b!n;A/X@]z?px'十z?p,A%sn@]z?' +qD

바이트 수는 한자에 사용되는 인코딩에 따라 다릅니다.

온라인으로 실행하고 디버그하십시오!

설명

9mYF...D    Loop `n` times and print a newline after each loop, `n`=1..9

"..."cay*~@ny@\p
"..."c              Push the string and duplicate it
      ay            Fetch the outer loop variable
        *           Multiply with the inner loop variable
         ~          Move the product to input stack for later use
          @         Take character at the index specified by inner loop variable
           ny@      Take character at the index specified by outer loop variable
              \p    Print the two characters

;11AH:b!n;A/X@]z?p
;11AH:b!        ?p    Is the product not in range [11,20)?
                      Output (*) if true, (**) if false.
        n;A/X@        Character at the index of the "ten" digit of product
              ]       Convert character to string (*)
               z      Empty string (**)

x'十z?p,A%sn@]z?' +q
x'十z?p                Print "十" if the "ten" digit is non-zero, nothing otherwise
       ,A%sn@]z?       Get the character specified by the last digit if that digit is non-zero, empty string otherwise
                ' +q   Append a space and print

대체 버전 (Stax 1.0.6), 59 바이트 (@recursive 기준)

이것은 이 도전에서 영감을 얻은 기능 을 사용 하며이 도전 이후의 Stax 1.0.6에만 포함됩니다.

éz░╖▐5à{│`9[mLùÜ•ëO╞îπl▼Γ─§╥|▒╛Δ◙Φµ'r╠eƒÿQ╫s♪Ω]£ï♪D3╚F◙δÿ%‼

ASCII 버전은

9mX{x\_x*YA/]yA-y20<*!*+y9>A*+yA%]0-+"NT|,,t.%,p&()(!'^pq kzi !X6"!s@mJ

이 버전은 인덱스 배열을 구성하고 중복 스택 작업을 피하기 위해 인덱스에 중국 문자의 문자열을 사용 ( c, a, n) 및 다중 @의.

설명

9mX{...m    Loop `n` times and map `1..n` to a list of strings, `n`=1..9
        J   Join the strings with space and print with a newline

x\_x*YA/]yA-y20<*!*+y9>A*+yA%]0-+"..."!s@
x\                                           A pair: (inner loop variable, outer loop variable)
  _x*Y                                       Product of inner and outer loop variable
      A/                                     floor(product/10)
        ]                                    [floor(product/10)]
         yA-                                 Product does not equal 10
            y20<                             Product is less than 20
                *!                           `Nand` of them
                                             This is true (1) if the product is in the range {10}U[20,81]
                  *                          Repeat [floor(product/10)] this many times
                                             This results in itself if the predicate above is true, or empty array if it is false
                   +                         Add it to the list of [inner loop var, outer loop var]
                                             This list will be used to index the string "得一二三四五六七八九十"
                    y9>A*                    Evaluates to 10 if the product is larger than 9, 0 otherwise
                                             When indexed, they become "十" and "得", respectively
                         +                   Append to the list of indices
                          yA%                Product modulo 10
                             ]0-             [Product modulo 10] if that value is not zero, empty array otherwise
                                +            Append to the list of index
                                 "..."!      "得一二三四五六七八九十"
                                       s@    Index with constructed array

파이썬 (3) , 151 (149) 146 바이트

Rod 덕분에 -3 바이트 .

l=" 一二三四五六七八九"
for i in range(1,10):print([l[j//i]+l[i]+('得',l[j//10][10<j<20:]+'十')[j>9]+l[j%10]for j in range(i,i*i+1,i)])

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

자바 스크립트, 190 바이트

(_="得一二三四五六七八九十")=>{for(i=1;i<10;i++){for(t="",v=0;v<i;t+=_[++v]+_[i]+[...(v*i+'')].map((a,b,c) => c.length>1&&b==0?(a>1?_[a]+'十':'十'):b==0?'得'+_[a]:_[a]).join``+' ');console.log(t)}}

a=(_=" 一二三四五六七八九")=>{for(i=1;i<10;i++){for(t="",v=0;v<i;t+=_[++v]+_[i]+[...(v*i+'')].map((a,b,c) => c.length>1&&b==0?(a>1||c[1]==0?_[a]+'十':'十'):b==0?'得'+_[a]:_[a]).join``+' ');console.log(t)}}
a()

루비 , 166 바이트

->{(1..9).map{|a|(1..a).map{|b|p=a*b;([b,a]+(p<10?[0,p]:p<11?[1,10]:p<20?[10,p%10]:[p/10,10]+(p%10<1?[]:[p%10]))).map{|d|"得一二三四五六七八九十"[d]}*""}}}

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

2D 문자열 배열을 반환하는 람다.

->{
  (1..9).map{|b|                  # b is the multiplier
    (1..b).map{|a|                # a is the multiplicand
      p=a*b;                      # p is the product
      (                           # We will build an array of indexes into a ref string:
        [a,b] + (                 #   The first two indexes will be a and b
        p<10 ? [0,p] :            #   Case 1: abGp (single digit sums)
        p<11 ? [1,10] :           #   Case 2: 251X (only happens once)
        p<20 ? [10,p%10] :        #   Case 3: abXd (12-18, d is the ones digit)
        [p/10,10]+(               #   (Cases 4 and 5 share a prefix)
          p%10<1 ? [] :           #   Case 4: abcX (20, 30, 40, c is the tens digit)
          [p%10]))                #   Case 5: abcXd (two-digit product, p = 10*c+d)
      ).map{|d|
        "得一二三四五六七八九十"[d] # Fetch the character for each index
      }*""                        # Join the characters into words
    }
  }
}

Yabasic , _{250 (242)} 238 바이트

유니 코드 문자로 된 기본 답변?! 뭐?

c(n)STDOUT에 입력 및 출력을받지 않는 익명 함수 및 선언 된 도우미 함수

For r=1To 9
For c=1To r
c(c)
c(r)
If!r*c>9Then?"得";Fi
c(r*c)
?" ";
Next
?
Next
Sub c(n)
s$="一二三四五六七八九"
If n>19Then?Mid$(s$,Int(n/10)*3-2,3);Fi
If n=10Then?"一";Fi
If n>9Then?"十";Fi
?Mid$(s$,Mod(n,10)*3-2,3);
End Sub

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

파이썬 3 , 196 바이트

lambda c=' 一二三四五六七八九':[[c[j]+c[i]+[('得'+c[(i*j%10)]),((c[(int(i*j/10))]*((i*j>19)or(i*j==10)))+'十'+(c[i*j%10])*(i*j%10!=0))][i*j>9]for j in range(1,i+1)]for i in range(1,10)]

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

레티 나 , 100 자, 122 바이트

9*
_
$`_$n
_
$%`_$.%= 
(_+)(.)
$.1,$2,$.($.1*$2*)
\B.
:$&
:0
:
1:\b
:
,(. )
,0$1
T`,d:`_得一二三四五六七八九十

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

9*

9 _초 삽입

_
$`_$n

1-9 _초의 9 행으로 확장합니다 .

_
$%`_$.%= 

(후행 공백 참고) 1에서 i까지 9 행을 _더한 숫자로 i를 확장합니다 .

(_+)(.)
$.1,$2,$.($.1*$2*)

_s를 10 진수로 변환하고 i를 곱합니다.

\B.
:$&

:답에 두 자리 숫자가 있으면 a를 삽입하십시오 . 이것은 ten캐릭터 가 될 것 입니다.

:0
:

제로 단위를 삭제하십시오.

1:\b
:

0을 제거 하지 않은 경우 1from을 삭제하십시오 .1:1:0

,(. )
,0$1

Inser a를 0한 자리 답변; 이것은 get캐릭터 가 될 것 입니다.

T`,d:`_得一二三四五六七八九十

모든 문자를 수정하십시오.

자바 스크립트 (Node.js) , 141/130 바이트

(s=[...'得一二三四五六七八九'])=>s.map((A,i)=>s.map((B,j)=>i<j|!j?'':B+A+[s[(q=i*j)/10|-(q>11&q<19)]]+(q>9?'十':'')+[s[q%10||s]]))

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

APL (Dyalog) , 75 개 (100) 문자, 97 122 바이트

k t←' 一二三四五六七八九得十'10
∘.{⍺<⍵:''⋄(s=10)∨19<s←⍺×⍵:k[1+⍵⍺(⌊s÷t)11,t|s]⋄9<s:k[1+⍵⍺,11,t|s]⋄k[⍵⍺t s+1]}⍨⍳9

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

파이썬 3 , 142 바이트

구조는 ovs 의 146 바이트 응답 과 유사 하지만 중간 용어는 다른 방식으로 작동합니다.

n=" 一二三四五六七八九"
for x in range(1,10):print([n[y//x]+n[x]+n[y//10][20>y!=10:]+'得十'[y>9]+n[y%10]for y in range(x,x*x+1,x)])

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

설명

가장 흥미로운 용어는 수십 개의 용어입니다.

n[y//10][20>y!=10:]

20>y!=10즉 20 > y and y != 10, False수십을 포함해야하는 경우 를 의미 True합니다.

False의 정수 값이 0과 True의 정수 값이 1너무 반면, n[y//10]항상 하나 개의 문자 길이, 첨자가 [20>y!=10:]동일합니다 [0:1](즉, "문자") 수만의 수가 포함되어야 때 [1:1](즉, "아무 문자") 그렇지.

다음 용어

'得十'[y>9]

이해하기 쉽다; 참고 :

• 모든 결과 <= 9의 출력에는 다음이 포함되어야합니다. 得
• > 9 이상의 모든 결과에 대한 출력은 十
• 得 'tens'항은 항상 빈 문자열로 평가되므로 'tens'항 다음에 처리 할 수 ​​있습니다. 得

후행 공백에 대한 참고 사항

에서 언급 한 바와 같이 - 다음은 사양에 약간 열 스트레치의 배수에 대한 후행 공백을 로드 ,이 제로 폭 공간을 사용하여 완벽하게 시각적으로 할 수 있지만, 당신은 또한 사용하여 배열을 압축 해제해야 print(*[...])제로 폭 공간이 표시됩니다으로 "\u200b"배열로 인쇄 할 때 리터럴로 .

자바 스크립트, 190 바이트

(s="得一二三四五六七八九十",o="")=>eval(`for(i=1;i<10;i++){for(j=1;j<=i;j++){o+=s[j]+s[i]+(i*j<10?s[0]:i*j<11?s[1]+s[10]:i*j<20?s[10]:s[i*j/10|0]+s[10])+(i*j%10?s[i*j%10]:"")+" "}o+="\\n"}`)

나는 이것을 나중에 골프하려고 노력할 것이다.

루비 , 136 바이트

UTF-8의 바이트 수는 Han 문자가 3이 아닌 2로 계산 된 128 바이트 여야합니다.

1.upto(9){|x|p (1..x).map{|y|[y,x,x*y/10,?X,x*y%10].join.sub(/(?<=0)X|1(?=X[1-9])|0$/,'').tr"0-9X","得一二三四五六七八九十"}}

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

1. 승수 및 제품의 숫자에서 문자열을에 X대한 자리 표시 자로 구분하여 구성 합니다 十.
2. X10 개 미만의 제품, "-teen"제품의 주요 제품 및 후행 0에 대해 정규식을 사용하십시오 .
3. 숫자와 X한자로 변환합니다.

/// , 301 바이트 (GBK *)

/*/\/\///1/一*2/二*3/三*4/四*5/五*6/六*7/七*8/八*9/九*0/十*=/得*I/
1*t/ 2*T/ 3/11=1I2=2t2=4I3=3t3=6T3=9I4=4t4=8T402 4406I5=5t510T505 4520 55205I6=6t602T608 46204 5630 66306I7=7t704T7201 47208 57305 67402 77409I8=8t806T8204 48302 5840 68408 78506 88604I9=9t908T9207 49306 59405 69504 79603 89702 99801

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

^{* 사양은 GBK → 유니 코드 변환을 명시 적으로 허용합니다.}

Pyth , 49 자, 71 바이트

J" 一二三四五六七八九"jmj;m+s@LJkr6>3+\得j\十@LJj*FkT,RdSdS9

UTF-8 인코딩을 사용합니다. 여기에서 온라인으로 사용해보십시오 .

다음 설명에서 ?문자는 올바른 한자를 대신합니다. 모든 항목을 올바르게 정렬하기에는 너무 게으 릅니다.

J" ?????????"jmj;m+s@LJkr6>3+\?j\?@LJj*FkT,RdSdS9   
J" ?????????"                                       Assign space + glyphs for 1-9 to J
                                               S9   [1-9]
              m                                     Map each element, as d, using:
                                             Sd       [1-d]
                                          ,Rd         Pair each element of the above with d
                                                        e.g. for d=3, yields [[1,3],[2,3],[3,3]]
                 m                                    Map each element, as k, using:
                                      *Fk               Get the product of the pair
                                     j   T              Get decimal digits of the above (convert to base 10)
                                  @LJ                   Map each digit to its index in J
                               j\?                      Join the above on ? ("Ten")
                            +\?                         Prepend ? ("Get")
                          >3                            Take the last 3 characters of the above
                        r6                              Strip whitespace
                  +                                     Prepend to the above...
                   s@LJk                                Concatenated digits of k in lookup string
               j;                                     Join result on spaces
             j                                      Join result on newlines, implicit print