Jouer au golf sur la table multiple chinoise 9 * 9

18

Sortez le tableau suivant:

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

Ou vous pouvez utiliser les trois premières lettres de son mot anglais, au cas où certaines langues ne prennent pas en charge les caractères chinois:

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

Vous pouvez sortir dans n'importe quel format raisonnable, par exemple du texte brut séparé par un espace / virgule / tabulation et une nouvelle ligne, un tableau 2D où les espaces vides sont vides ou n'existent pas (L'endroit 2 * 1 est vide, donc il ne devrait rien y avoir dans le tableau).

Code golf, code le plus court en octets gagnant. Le codage GBK est autorisé, où chaque caractère chinois utilise 2 octets.

Conversion de la table:

一   One
二   Two
三   Thr
四   Fou
五   Fiv
六   Six
七   Sev
八   Eig
九   Nin
十   Ten
得   Get
l4m2
la source
Le reste semble assez intuitif, mais pourriez-vous au moins expliquer comment 十 et 得 fonctionnent?
Dennis
得 est utilisé uniquement lorsque le produit est inférieur à 10
l4m2
ahhh, donc s'il est supérieur à 10 à la place, nous sommes censés utiliser 十?
Luis felipe De jesus Munoz
@LuisfelipeDejesusMunoz et [11,19] sont spéciaux avec un 十 nu.
FrownyFrog
我 能 确认 这 是 正确 的。 (Traduction: je peux confirmer que c'est correct)
Esolanging Fruit

Réponses:

8

Stax , 66 caractères

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

Le nombre d'octets dépend du codage utilisé pour les caractères chinois.

Exécutez et déboguez en ligne!

Explication

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

Version alternative (Stax 1.0.6), 59 octets (par @recursive)

Cela utilise une fonctionnalité inspirée de ce défi et n'est incluse que dans Stax 1.0.6 qui est postérieur au défi.

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

La version ASCII est

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

Cette version construit le tableau d'index et utilise ensuite pour indexer la chaîne de caractères chinois pour éviter les opérations de pile redondantes ( c, a, n) et multiple @s.

Explication

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
la source
Stax 1.0.6 peut le faire en 59 , mais il est postérieur au défi, il n'est donc pas qualifié OMI.
récursif
À noter de toute façon. Il utilise également évidemment une optimisation qui est également disponible avant 1.0.6.
Weijun Zhou du
1
Je soupçonne qu'il reste encore une bonne quantité d'optimisation, mais je vais la laisser tranquille pour l'instant.
récursif
@recursive De nos jours, les nouveaux langages de programmation qui ne sont pas conçus à dessein pour une question ne doivent pas être marqués «non concurrents» (quelqu'un liera la méta-publication)
Stan Strum
1
@StanStrum Voici le méta post
PunPun1000
5

Python 3 , 151 149 146 146 octets

-3 octets grâce à 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)])

Essayez-le en ligne!

ovs
la source
Juste une petite note, vous pouvez utiliser un espace de largeur nulle '\u200b'(+2 octets) à la place de l'espace pour une sortie exacte
Rod
3

Javascript, 190 octets

(_="得一二三四五六七八九十")=>{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
la source
@ l4m2 Oui, je n'ai pas remarqué la différence lors de l'utilisation de 得
Luis felipe De jesus Munoz
1
@FrownyFrog quand est 10 est 一十mais quand est 15 ou 16 ou tout autre numéro que nous omettons ?
Luis felipe De jesus Munoz
@FrownyFrog Pouvez-vous jeter un œil maintenant?
Luis felipe De jesus Munoz
Tout va bien, bien fait.
FrownyFrog
Essayez (_="得一二三四五六七八九十")=>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"). Je n'ai pas regardé de trop près, mais il y a certainement d'autres choses que vous pouvez jouer au golf.
Mama Fun Roll
2

Rubis , 166 octets

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

Essayez-le en ligne!

Un lambda renvoyant un tableau 2D de chaînes.

->{
  (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
la source
2

Yabasic , 250 242 238 octets

Un réponse avec des caractères Unicode?! Quelle?

Une fonction anonyme et une fonction d'assistance déclarée, c(n)qui ne prennent aucune entrée et sortie à 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

Essayez-le en ligne!

Taylor Scott
la source
1

Python 3 , 196 octets

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

Essayez-le en ligne!

Dat
la source
二五一十九 二六一十二deux types de mal
l4m2
@FrownyFrog fixed ...
Dat
c[(i*j%10)]=> c[i*j%10]?
l4m2
1

Rétine , 100 caractères, 122 octets


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

Essayez-le en ligne!Explication:


9*

Insérer neuf _ s.

_
$`_$n

Développer jusqu'à 9 rangées de 1 à 9 _ s.

_
$%`_$.%= 

(notez l'espace de fin) Développez jusqu'à 9 rangées de 1 à i _ s plus i sous forme de chiffre.

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

Convertissez le _ s en décimal et multipliez par i.

\B.
:$&

Insérez un : si la réponse comporte deux chiffres. Cela deviendra le tenpersonnage.

:0
:

Supprimez zéro unité.

1:\b
:

Supprimer le 1à 1:moins qu'il ne soit1:0 dont le zéro a été supprimé.

,(. )
,0$1

Insérez un 0pour les réponses à un chiffre; cela deviendra leget personnage.

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

Réparez tous les personnages.

Neil
la source
1

JavaScript (Node.js) , 141/130 octets

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

Essayez-le en ligne!

l4m2
la source
Pourriez-vous s'il vous plaît supprimer le "UTF8" de l'en-tête? Ce n'est pas nécessaire, mais cela trompe les scripts du classement, ce qui leur fait penser que cette réponse ne fait que 8 octets.
RedClover
1

APL (Dyalog) , 75 100 caractères, 97 122 octets

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

Essayez-le en ligne!

Uriel
la source
Je serais ravi de l'améliorer si le downvoter dirait ce qui ne va pas.
Uriel
Oh, c'est vrai, donc pour 11 à 19 inclus, la sortie devrait être de 4 caractères, sans 一
FrownyFrog
@FrownyFrog fixe
Uriel
0

Python 3 , 142 octets

La structure est similaire à la réponse de 146 octets des ovs , mais les termes intermédiaires fonctionnent d'une manière différente.

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

Essayez-le en ligne!

Explication

Le terme le plus intéressant est le terme pour le nombre de dizaines:

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

Notez que cela 20>y!=10signifie 20 > y and y != 10que Falsele nombre de dizaines doit être inclus et Truesinon.

Falsea une valeur entière de 0et Truea une valeur entière de 1, donc alors qu'il n[y//10]fait toujours un caractère, l'indice [20>y!=10:]est équivalent à [0:1](c'est- à -dire "le caractère") lorsque le nombre de dizaines doit être inclus et [1:1](c'est-à-dire "pas de caractères") sinon.

Le terme suivant,

'得十'[y>9]

est plus facile à comprendre; Notez que:

  • La sortie pour chaque résultat <= 9 doit contenir
  • La sortie pour chaque résultat> 9 doit contenir
  • peut être gérée après le terme «dizaines» car le terme «dizaines» est toujours évalué comme une chaîne vide lorsqu'il y a un

Remarque sur les espaces de fin

Les espaces de fuite pour des multiples de dix étirent légèrement la spécification - comme mentionné par la tige , cela pourrait être rendu visuellement parfait en utilisant un espace de largeur nulle, mais vous devrez également déballer les tableaux en utilisant print(*[...])comme l'espace de largeur nulle est représenté comme littéral "\u200b"lorsqu'il est imprimé dans un tableau.

mjayfrancis
la source
0

JavaScript, 190 octets

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

J'essaierai de jouer au golf plus tard.

ericw31415
la source
0

Rubis , 136 octets

Le nombre d'octets en UTF-8 doit être de 128 octets avec des caractères Han comptés comme 2 au lieu 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","得一二三四五六七八九十"}}

Essayez-le en ligne!

  1. Construisez les chaînes à partir des chiffres des multiplicateurs et des produits, ces derniers étant séparés par Xun espace réservé pour .
  2. Amusez-vous à regex Xpour les produits <10, les principaux pour les produits «-teen» et les zéros à la fin.
  3. Traduire les chiffres et Xles caractères Han.
Kirill L.
la source
0

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

Essayez-le en ligne!

* La spécification autorise explicitement la conversion GBK → Unicode.

Erik le Outgolfer
la source
0

Pyth , 49 caractères, 71 octets

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

Utilise le codage UTF-8. Essayez-le en ligne ici .

Dans l'explication suivante, les ?caractères remplacent les bons caractères chinois - je suis trop paresseux pour que tout s'aligne correctement ...

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
la source