高尔夫中国9 * 9多桌

18

输出下表：

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

或者，如果某些语言不支持汉字，则可以在英语单词中使用前三个字母：

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
code-golf  kolmogorov-complexity 
— 平方米
source
其余的似乎很直观，但是您至少可以解释一下十和得如何工作吗？
— 丹尼斯
仅当产品小于10
— l4m2（
嗯，所以如果大于10而得了，我们应该使用十？
— 路易斯·费利佩·德·耶稣·穆诺兹
@LuisfelipeDejesusMunoz和[11,19]仅有十个特别之处。
— FrownyFrog
（翻译：我可以确认这是正确的）
— Esolanging Fruit

Answers:

8

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
— 周卫军
source
Stax 1.0.6可以在59中做到这一点，但是它推迟了挑战，因此它不是合格的IMO。
— 递归
无论如何值得一提。显然，它还使用了一些优化功能，这些优化功能也可以在1.0.6之前使用。
— 周
1
我怀疑里面还有大量的优化空间，但是我现在暂时不谈。
— 递归
@recursive如今，并非故意针对某个问题制作的较新的编程语言不必标记为“非竞争性”（某人链接到元文章）
— Stan Strum，
1
@StanStrum 这是meta帖子
— PunPun1000
5

Python 3中，151个 149 146字节

-3个字节，感谢Rod。

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

在线尝试！

— ovs
source
请注意，您可以使用零宽度的空格'\u200b'（+2个字节）代替确切的输出
— Rod
3

Javascript，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()
展开摘要

— 路易斯·费利佩·德·耶稣·穆诺兹
source
@ l4m2是的，我没有注意到使用得
— Luis felipe De jesus Munoz
1
@FrownyFrog何时为10，一十但何时为15或16或我们忽略的任何其他数字一？
— 路易斯·费利佩·德·耶稣·穆尼奥斯
@FrownyFrog你现在可以看看吗？
— 路易斯·费利佩·德·耶稣·穆诺兹
一切都很好，做得很好。
— FrownyFrog
尝试(_="得一二三四五六七八九十")=>eval("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``+' ');t")。我没有仔细观察，但是肯定还有其他一些可以打高尔夫球的东西。
— Mama Fun Roll
2

红宝石 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字符串数组的lambda。

->{
  (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
    }
  }
}
— benj2240
source
2

Yabasic，250 242 238个字节

一个基本的 Unicode字符的答案？什么？

匿名函数和声明的辅助函数，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

在线尝试！

— 泰勒·斯科特
source
1

Python 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)]

在线尝试！

— 达特
source
二五一十九 二六一十二两种错误
— l4m2
@FrownyFrog固定...
— 逸
c[(i*j%10)]=> c[i*j%10]？
— l4m2
1

视网膜，100个字符，122字节


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

在线尝试！说明：


9*

插入九_秒。

_
$`_$n

扩展到1到9 _秒的9行。

_
$%`_$.%=

（请注意尾随空格）扩展为1到i _s的9行加i作为数字。

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

将_s 转换为十进制并乘以i。

\B.
:$&

:如果答案有两位数字，请插入。这将成为ten角色。

:0
:

删除零个单位。

1:\b
:

除非删除了零1，1:否则请1:0从中删除。

,(. )
,0$1

插入a 0表示个位数的答案；这将成为get角色。

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

修正所有字符。

— 尼尔
source
1

JavaScript（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]]))

在线尝试！

— 平方米
source
您能从标题中删除“ UTF8”吗？没必要，但是它欺骗了排行榜脚本，使他们认为此答案只有8个字节长。
— RedClover
1

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

在线尝试！

— 尤里尔
source
如果降级者可以告诉它出了什么问题，我希望进行改进。
— Uriel's
哦，对了，因此对于11到19之间（含11和19），输出应为4个字符，且不带任何
— 文字。– FrownyFrog
@FrownyFrog已修复
— Uriel
0

Python 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'项之后进行处理，因为当存在 得

注意尾随空格

该十拉伸的倍数说明书略微尾随位-如通过提及杆，这可以在视觉上由通过使用零宽度空间完善，但你也必须解压使用阵列print(*[...])作为零宽度空间被表示作为文字"\u200b"打印在数组中时。

— 麦弗朗西斯
source
0

JavaScript，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"}`)

我稍后会尝试打高尔夫球。

— ericw31415
source
0

红宝石，136字节

UTF-8中的字节数应为128字节，汉字字符应计为2而不是3。

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. X对于小于10的产品，对“青少年”产品的前导产品和零结尾的产品，请进行一些正则表达式的乐趣。
  3. 将数字翻译X成汉字。
— 基里尔
source
0

///，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

在线尝试！

* Spec明确允许GBK→Unicode转换。

— 暴民埃里克
source
0

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
— ok
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.