Golf o chinês 9 * 9 mesa múltipla

18

Saída da seguinte tabela:

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

Ou você pode usar as três primeiras letras da palavra em inglês, caso alguns idiomas não suportem caracteres chineses:

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

Você pode imprimir em qualquer formato razoável, por exemplo, texto sem formatação separado por espaço / vírgula / guia e nova linha, matriz 2D onde os lugares vazios estão vazios ou não existem (o local 2 * 1 está vazio, portanto não deve haver nada no array).

Código de golfe, o código mais curto em bytes ganha. A codificação GBK é permitida, onde cada caractere chinês usa 2 bytes.

Tabela de conversão:

一   One
二   Two
三   Thr
四   Fou
五   Fiv
六   Six
七   Sev
八   Eig
九   Nin
十   Ten
得   Get
l4m2
fonte
O resto parece bastante intuitivo, mas você poderia ao menos explicar como 十 e 得 funcionam?
Dennis
得 é usado apenas quando o produto é menor que 10
l4m2
ahhh, então se for maior que 10 em vez disso, devemos usar 十?
Luis felipe De jesus Munoz
@LuisfelipeDejesusMunoz e [11,19] são especiais com apenas um 十.
precisa saber é o seguinte
Translation 能 确认 这 是 的 (Tradução: Posso confirmar que isso está correto) #
Esolanging Fruit

Respostas:

8

Stax , 66 caracteres

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

O número de bytes depende da codificação usada para caracteres chineses.

Execute e depure online!

Explicação

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

Versão alternativa (Stax 1.0.6), 59 bytes (por @recursive)

Ele usa um recurso inspirado nesse desafio e está incluído apenas no Stax 1.0.6, que é posterior ao desafio.

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

A versão ASCII é

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

Esta versão constrói a matriz de índice e, em seguida, usa-lo para indexar o conjunto de caracteres chineses para evitar operações de pilha redundantes ( c, a, n) e múltipla @s.

Explicação

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
Weijun Zhou
fonte
O Stax 1.0.6 pode fazer isso em 59 , mas pós-data do desafio, portanto, não é IMO qualificado.
recursiva
Vale mencionar de qualquer maneira. Obviamente, também usa alguma otimização que também está disponível antes da 1.0.6.
Weijun Zhou
1
Suspeito que ainda haja uma quantidade decente de espaço de otimização, mas deixarei em paz por enquanto.
recursivo
@recursive Hoje em dia, as linguagens de programação mais recentes que não são feitos propositadamente para uma pergunta não tem que ser marcado 'não competindo' (ligação a alguém o pós meta)
Stan Strum
1
@StanStrum Aqui está a meta postagem #
PunPun1000 /
5

Python 3 , 151 149 146 bytes

-3 bytes graças a 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)])

Experimente online!

ovs
fonte
Apenas uma pequena nota, você pode usar o espaço de largura zero '\u200b'(+2 bytes) em vez espaço para uma saída exata
Rod
3

Javascript, 190 bytes

(_="得一二三四五六七八九十")=>{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()

Luis felipe De jesus Munoz
fonte
@ l4m2 Sim, eu não notar a diferença quando se utiliza得
Luis Felipe de Jesus Munoz
1
@FrownyFrog quando é 10 é 一十mas quando é 15 ou 16 ou qualquer outro número que omitimos ?
Luis felipe De jesus Munoz
@FrownyFrog Você pode dar uma olhada agora?
Luis felipe De jesus Munoz
Tudo bem, bem feito.
FrownyFrog
Tente (_="得一二三四五六七八九十")=>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"). Eu não olhei muito de perto, mas definitivamente existem outras coisas que você pode jogar golfe.
Mama Fun Roll
2

Ruby , 166 bytes

->{(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]}*""}}}

Experimente online!

Um lambda retornando uma matriz 2D de seqüências de caracteres.

->{
  (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
fonte
2

Yabasic , 250 242 238 bytes

Uma resposta com caracteres unicode ?! O que?

Uma função anônima e uma função auxiliar declarada, c(n)que não leva nenhuma entrada e saída para 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

Experimente online!

Taylor Scott
fonte
1

Python 3 , 196 bytes

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

Experimente online!

Dat
fonte
二五一十九 二六一十二dois tipos de errado
l4m2
@FrownyFrog fixo ...
Dat
c[(i*j%10)]=> c[i*j%10]?
L4m2 10/0318
1

Retina , 100 caracteres, 122 bytes


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

Experimente online! Explicação:


9*

Insira nove _s.

_
$`_$n

Expanda para 9 linhas de 1 a 9 _s.

_
$%`_$.%= 

(observe o espaço à direita) Expanda para 9 linhas de 1 a i _s mais i como um dígito.

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

Converta _s em decimal e multiplique por i.

\B.
:$&

Insira a :se a resposta tiver dois dígitos. Isso se tornará oten personagem.

:0
:

Exclua zero unidades.

1:\b
:

Exclua o 1 de, a 1:menos que seja o 1:0seu zero removido.

,(. )
,0$1

Insira a 0para respostas de um dígito; isso se tornará o getpersonagem.

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

Corrija todos os personagens.

Neil
fonte
1

JavaScript (Node.js) , 141/130 bytes

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

Experimente online!

l4m2
fonte
Você poderia remover o "UTF8" do cabeçalho? Não é necessário, mas engana os scripts da tabela de classificação, fazendo-os pensar que essa resposta tem apenas 8 bytes.
RedClover 20/03/19
1

APL (Dyalog) , 75 100 caracteres, 97 122 bytes

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

Experimente online!

Uriel
fonte
Eu adoraria melhorá-lo se o downvoter dissesse o que há de errado com ele.
Uriel
Oh, bem, então para 11 a 19, inclusive, a saída deve ser 4 caracteres, sem一
FrownyFrog
@FrownyFrog corrigido
Uriel
0

Python 3 , 142 bytes

A estrutura é semelhante à resposta de 146 bytes do ovs , mas os termos do meio funcionam de maneira diferente.

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

Experimente online!

Explicação

O termo mais interessante é o termo para o número de dezenas:

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

Observe que 20>y!=10significa 20 > y and y != 10, que éFalse quando o número de dezenas deve ser incluído ou Truenão.

Falsetem um valor inteiro de 0e Truetem um valor inteiro de 1, portanto, embora n[y//10]sempre tenha um caractere, o índice[20>y!=10:] é equivalente a[0:1] (ou seja, "o caractere") quando o número de dezenas deve ser incluído e[1:1] (por exemplo, "sem caracteres").

O termo a seguir,

'得十'[y>9]

é mais fácil de entender; Observe que:

  • A saída para cada resultado <= 9 deve conter
  • A saída para cada resultado> 9 deve conter
  • pode ser manipulado após o termo 'dezenas' porque o termo 'dezenas' sempre é avaliado como uma cadeia vazia quando existe um

Nota sobre espaços à direita

Os espaços à direita para múltiplos de dez esticam um pouco a especificação - como mencionado pela haste , isso pode ser visualmente perfeito usando um espaço de largura zero, mas você também precisa descompactar as matrizes usando print(*[...])como o espaço de largura zero é representado como um literal "\u200b"quando impresso em uma matriz.

mjayfrancis
fonte
0

JavaScript, 190 bytes

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

Vou tentar jogar isso mais tarde.

ericw31415
fonte
0

Ruby , 136 bytes

A contagem de bytes em UTF-8 deve ter 128 bytes, com caracteres Han contados como 2 em vez de 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","得一二三四五六七八九十"}}

Experimente online!

  1. Construa as strings a partir dos dígitos dos multiplicadores e dos produtos, separados por X como um espaço reservado para .
  2. Faça algum regex divertido de largar X para produtos <10, principais para produtos com "quatorze" e zeros à direita.
  3. Converta dígitos e Xpara caracteres Han.
Kirill L.
fonte
0

/// , 301 bytes (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

Experimente online!

* Spec permite explicitamente a conversão GBK → Unicode.

Erik, o Outgolfer
fonte
0

Pitão , 49 caracteres, 71 bytes

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

Usa codificação UTF-8. Experimente online aqui .

Na explicação a seguir, os ?caracteres são substitutos dos caracteres chineses corretos - tenho preguiça de fazer tudo alinhar corretamente ...

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
Sok
fonte