프랑스 인 들은 독특한 방식으로 숫자 를 철자합니다 .

• 1-16 은 "정상"입니다
• 17-19 는 10 + 7로 표시됩니다. 10 + 8, 10 + 9 .
• 20-69 는 "정상적"입니다.
• 70-79 는 60 + 10, 60 + 11 ... 60 + 10 + 7, 60 + 10 + 8, 60 + 10 + 9 입니다.
• 80-99 는 4 * 20, 4 * 20 + 1, 4 * 20 + 2 ... 4 * 20 + 16, 4 * 20 + 10 + 7, 4 * 20 + 10 + 8, 4 * 20 + 10 +입니다. 9

도전:

[1,100] 범위의 양의 정수를 가져 와서 "French way"로 출력하십시오. 당신은 출력이 정확히과 함께, 아래와 것 같은 있어야 *하고 +그래서 97입니다 4*20+10+7하지, [4 20 10 7]또는 뭔가 다른.

테스트 사례 :

1  - 1
.. - ..
16 - 16
17 - 10+7
18 - 10+8
19 - 10+9
20 - 20
21 - 21
.. - ..
69 - 69
70 - 60+10
71 - 60+11
72 - 60+12
77 - 60+10+7
78 - 60+10+8
79 - 60+10+9
80 - 4*20
81 - 4*20+1
82 - 4*20+2
.. - ..
90 - 4*20+10
91 - 4*20+11
96 - 4*20+16
97 - 4*20+10+7
98 - 4*20+10+8
99 - 4*20+10+9
100 - 100

엑셀 153 149 바이트

=IF(OR(A1<17,A1>99,AND(A1>19,A1<70)),A1,IF(A1<20,"10+"&A1-10,IF(A1<80,"60","4*20")&IF(A1=80,,IF(MOD(A1,20)>16,"+10+"&MOD(A1,20)-10,"+"&MOD(A1,20)))))

이것이 더 좋을 것이라고 확신합니다. # 80을 설명하는 효율적인 방법을 찾기 위해 고심했습니다.

편집 : 4 바이트를 절약하기 위해 '일반'사례를 더 잘 통합했습니다. # 80은 여전히 ​​짜증나.

code-golf tbh의 규칙을 잘 모르는 여기에서 특정 답변을 찾을 수 없습니다. Excel에서 여러 셀을 사용하고 각각의 바이트 수를 추가 할 수 있습니까?

즉. 셀 A1의 입력

A2 : 11 바이트

=MOD(A1,20)

A3 (결과) : 125 바이트

=IF(OR(A1<17,A1>99,AND(A1>19,A1<70)),A1,IF(A1<20,"10+"&A1-10,IF(A1<80,"60","4*20")&IF(A1=80,,IF(A2>16,"+10+"&A2-10,"+"&A2))))

총 136 개?

레티 나 , 52 48 바이트

Neil 덕분에 4 바이트 절약

^7\B
60+1
^9\B
81
^8\B
4*20+
1(?=7|8|9)
10+
\+0

온라인으로 사용해보십시오! 또는 모든 입력을 확인하십시오 (Neil 제공)

설명

^7\B
60+1
^9\B
81
^8\B
4*20+

먼저 우리는 70, 80, 90의 번역을 처리합니다.이 첫 3 단계에서 시작시 7 개의 문자가 뒤에 다른 문자로 바뀝니다 60+1. 마찬가지로, 9로 대체 81하고 8의해 4*20+1. 의 대체 9는 본질적으로 그것을 "80"으로 변경하는 것이므로 8다음 대체에서 처리 되므로 바이트를 4*20+1두 번 쓰는 것 보다 바이트가 절약됩니다 .

1(?=7|8|9)
10+

이 경우의 처리 17, 18및 19교체하는 의해 1각하여 10+.

\+0

마지막으로 +0끝에는 없어야 하므로 삭제하십시오.

파이썬 2 , 98 바이트

f=lambda x:[`x`*(x%100<70),'10+'+`x-10`][16<x<20]or['60+'+f(x-60),'4*20'+x/81*('+'+f(x-80))][x/80]

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

자바 스크립트 (ES6), 73 71 바이트

f=n=>n>16&n<20?'10+'+n%10:n<70|n>99?n:n%20?f(n-n%20)+'+'+f(n%20):'4*20'

실제로 추가 2 바이트로 철자가 표시된 숫자를 인쇄하는 보너스 버전 :

f=n=>n<17|n>99?n:n<20?'10+'+n%10:n%20?f(n-n%20)+'+'+f(n%20):n-80?n:'4*20'

R, 110 바이트

i=scan()
r=i%%10;paste0(ifelse(i>16&i<20,"10+",ifelse(i>69&i<80,"60+10+",ifelse(i>16&i<20,"4*20+",i-r/10))),r)

PHP, 99 바이트 (행복한 버전이되고 싶다)

ETHproductions JS 의 직선 포트 , 4 바이트 골프. OP가 요청한 번호를 인쇄합니다.

function f($n){return$n<17|$n>19?$n>60&$n<100?($m=$n%20)?f($n-$m)."+".f($m):'4*20':$n:"10+".$n%10;}

고장

function f($n){return
    $n<17|$n>19
        ?$n>69&$n<100
            ?($m=$n%20)
                ?f($n-$m)."+".f($m) # 70..79, 81..99
                :'4*20'             # 80
            :$n                     # 1..16, 20..69
        :"10+".$n%10                # 17..19
    ;
}

나는 올바른 버전이되고 싶다, 114 98 바이트

ETHproductions 에서 영감을 얻은 새로운 접근 방식 은 실제로 철자가 나오는 숫자를 인쇄합니다.

function f($n){return$n>16&$n<100?$n-80?($m=$n%($n>60?20:10))?f($n-$m)."+".f($m):$n-$m:'4*20':$n;}

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

고장

function f($n){return
    $n>16&$n<100
        ?$n-80
            ?($m=$n%($n>60?20:10))
                ?f($n-$m)."+".f($m) # $n%$m>0
                :$n-$m              # 10,20,30,40,50,60
            :'4*20'                 # 80
        :$n                         # 1..16, 100
;}

파이썬 2 130 108 바이트

@mathjunkie 덕분에 22 바이트 절약

f=lambda x:79<x<100and('4*20'+('+'+f(x-80))*(x>80))or 69<x<100and'60+'+f(x-60)or 16<x<20and'10+'+`x-10`or`x`

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

배치, (220) 217 바이트

@set/pn=
@set s=
@if %n% gtr 99 goto g
@if %n% gtr 79 set s=+4*20&set/an-=80
@if %n% gtr 69 set s=+60&set/an-=60
@if %n% gtr 16 if %n% lss 20 set s=%s%+10&set/an-=10
:g
@if %n% gtr 0 set s=%s%+%n%
@echo %s:~1%

STDIN에서 입력을받습니다. 선행을 생성하고 제거하면 +특수 케이스 80보다 1 바이트가 절약됩니다. 편집 : @ ConorO'Brien 덕분에 3 바이트가 절약되었습니다.

젤리 , 55 바이트

⁹
’,ṃ60Ṁ€
⁹%80“4*20”,
Dj⁾0+µ¹e?“×ØŒ‘
%ȷ2:“FP‘S‘ŀḟ0Ç€j”+

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오

의심 할 여지없이 더 짧은 방법이 있습니다!

어떻게?

+ - Link 1, helper for 1-69&100: number s=0, number n
⁹ - link's right argument, n

’,ṃ60Ṁ€ - Link 2, helper for 70-79: number s=1, number n
’       - decrement s -> 0
 ,      - pair -> [0,n]
  ṃ60   - base decompress (vectorises) using [1,2,...60]  effectively -> [60,[1,n%60]]
     Ṁ€ - maximum for €ach effectively -> [60,n%60]

⁹%80“4*20”, - Link 3, helper for 80-99: number s=2, number n
⁹           - link's right argument, n
 %80        - mod 80
    “4*20”  - literal ['4','*','2','0']
          , - pair -> [['4','*','2','0'],n]

Dj⁾0+µ¹e?“×ØŒ‘ - Link 4, reformat 17-19: element v (may be char list or number)
        ?      - if
       e       - v exists in
         “×ØŒ‘ - literal [17,18,19]
               - then:
D              -   convert to decimal list  e.g. [1,7]
  ⁾0+          -   literal ['0','+']
 j             -   join                          [1,'0','+',7]
     µ         - else:
      ¹        -   identity, v

%ȷ2:“FP‘S‘ŀḟ0Ç€j”+ - Main link: number n in [1,100]
 ȷ2                - literal 100
%                  - mod (convert 100 to 0)
    “FP‘           - literal [70,80]
   :               - integer division (vectorises)
        S          - sum (0 for 1-69&100; 1 for 70-79; 2 for 80-99)
         ‘         - increment (...1, 2 or 3)
          ŀ        - call link at index (1, 2 or 3) as a dyad(sum, n)
           ḟ0      - filter out zeros (remove 0 from 4*20+0)
             ǀ    - call the last link (4) as a monad for each
                ”+ - literal '+'
               j   - join

Pyth, 61 56 바이트

L?}b}17 19++T\+eb|bk?}/QTr6T.s+?<Q80"60+""4*20+"y%Q20\+y

온라인으로 테스트하십시오!

5 바이트 개선을위한 Leaky Nun에 감사합니다!

설명:

                     | Implicit: Q=eval(input())
L                    | Define y(b):
 ?}b}17 19           |  If b is in the inclusive range from 17 to 19:
          ++T\+eb    |   Return "10+" + (last digit of b)
                 |b  |  Else: if b!=0: return b
                   k |   Else: return an empty string (Leaves a trailing '+' for case 80)
_____________________|________________
?}/QTr6T                              | If 70<=Q<100:
          +                           |  Concatenate the next two expressions:
           ?<Q80                      |   If Q<80:
                "60+"                 |    Evaluate to "60+"
                     "4*20+"          |    Else: Evaluate to "4*20+"
                            y%Q20     |   y(Q%20)
        .s                       \+   |  Strip off trailing '+', if present (for case 80)
                                   y  | Else: return y(Q)
                                   (Q)| Trailing Q is implicitly added

Python3, 127 바이트

m,r=map,range;l=[*r(1,17),*m("10+{}".format,(7,8,9))];f=[0,*l,*r(20,61),*m("60+{}".format,l),"4*20",*m("4*20+{}".format,l),100]

각 배열 요소에는 다음과 같은 표현이 포함됩니다.

for i in range(1,101):
    print(i, f[i])

코드는 실제로 함수를 만들지 않고 배열을 만듭니다. 허용되는지 알 수 없습니다. 그렇지 않으면을 추가 하여이 139 바이트를 만들어야합니다 f=[...].__getitem__.

자바 7 97 96 109 바이트

String c(int i){return i>16&i<20?"10+"+(i-10):i%100<70?i+"":i<80?"60+"+c(i-60):"4*20"+(i<81?"":"+"+c(i-80));}

버그 수정 사례의 경우 +13 바이트 80.. :(

설명:

String c(int i){      // Method with integer parameter and String return-type
  return i>16&i<20?   //  If 17..19:
    "10+"+(i-10)      //   Return "10+" + `i`-10
   :i%100<70?         //  Else if 1..16; 20..69; 100:
    i+""              //   Return `i`
   :i<80?             //  Else if 70..79:
    "60+"+c(i-60)     //   Return "60+" + recursive-call with `i`-60
   :                  //  Else (80..99):
    "4*20"+           //   Return "4*20" +
     (i<81?           //   If 80:
      ""              //    nothing
     :                //   Else (81..99)
      "+"+c(i-80));   //    recursive-call with `i`-80
}                     // End of method

테스트 코드 :

여기에서 시도하십시오.

class M{
  static String c(int i){return i>16&i<20?"10+"+(i-10):i%100<70?i+"":i<80?"60+"+c(i-60):"4*20"+(i<81?"":"+"+c(i-80));}

  public static void main(String[] a){
    for (int i = 1; i <= 100; i++) {
      System.out.println(c(i));
    }
  }
}