46

फ्रांसीसी ने अजीबोगरीब तरीके से संख्याएँ निकालीं।

1-16 "सामान्य" हैं
१-१९ को १० + out बताया जाता है । 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] , और इसे "फ्रेंच तरीका" आउटपुट। आपको इसे ठीक उसी तरह से आउटपुट करना होगा जैसा कि नीचे दिखाया गया है, साथ *और +, ऐसा 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

code-golf number kolmogorov-complexity

— स्टीवी ग्रिफिन
स्रोत

14

हर भाषा मैं जानता हूँ कि "किशोर" में एक संक्रमण, से एक की तरह है 16करने के लिए 10+7ऊपर। (अंग्रेजी में यह बीच 12- बीच में होता है 10+3, थोड़ा अधिक रूपात्मक प्रच्छन्नता के साथ।) मैं हमेशा इस तथ्य के साथ थोड़ा अतिरंजित रहा हूं कि विभिन्न भाषाएं अलग-अलग संख्याओं में उस संक्रमण को बनाती हैं।

— ग्रेग मार्टिन

25

22"डिक्स-हूट" होने पर "विन्ग- ड्यूक्स" क्यों होना चाहिए 10+8?

— टाइटस

11

सौभाग्य से, यह एक प्रोग्रामिंग पहेली साइट है, न कि एक भाषाई सामान्य ज्ञान साइट। अन्यथा जब ओपी मूर्खतापूर्ण गलती करता है तो लोग नाराज हो सकते हैं। ओह!

— स्टीवी ग्रिफिन

4

@StewieGriffin से लोग अब भी नाराज थे।

— लीक नून

2

एक फ्रेंच के रूप में मुझे यह काफी ठीक लगता है: डी।

— वालफ्रैट

13

एक्सेल, 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 अभी भी बेकार है।

यहाँ पर एक विशिष्ट उत्तर नहीं मिल सकता है, कोड-गोल्फ tbh के नियमों को सुनिश्चित नहीं करना। क्या मैं एक्सेल में कई कोशिकाओं का उपयोग कर सकता हूं, और प्रत्येक की बाइट गिनती जोड़ सकता हूं?

अर्थात। सेल 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 के लिए?

— qoou
स्रोत

मुझे लगता है कि इसे कई कोशिकाओं में कोड लिखने की अनुमति दी जानी चाहिए। IMHO यह अन्य प्रोग्रामिंग भाषाओं में मध्यवर्ती चर या फ़ंक्शन होने जैसा है।

— पाजोंक

मुझे लगता है कि कई कोशिकाओं का उपयोग करने का कुछ दंड होना चाहिए, जैसे कि अन्य भाषाओं में फ़ंक्शन का उपयोग करने का एक दंड है (फ़ंक्शन को घोषित करने के लिए बॉयलरप्लेट टाइप करने का)। शायद सबसे अधिक समर्थित एन्कोडिंग (यानी CSV), इसलिए कॉमा की आवश्यक संख्या और (यदि आवश्यक हो) उद्धरण?

— मुजेर

मुझे किसी भी प्रारूप के बारे में पता नहीं है कि एक्सेल फाइल को पहचानने योग्य आउटपुट के साथ बचाया जा सकता है। CSV फाइलें इन जैसे डिफ़ॉल्ट सपोर्ट फंक्शंस द्वारा नहीं होती हैं, और कॉमा का उपयोग करने वाले किसी भी फ़ंक्शन को तोड़ देगी। यदि कोशिकाओं के बीच एक नई लाइन के साथ एक कॉलम में शुद्ध पाठ के रूप में सहेजा जाता है, तो इसे सीधे एक्सेल और फ़ंक्शन में कॉपी किया जा सकता है। इस स्थिति में, प्रत्येक अतिरिक्त सेल के लिए 1 बाइट जोड़ी जाएगी।

— किउउ

परिवर्तित करके एक बाइट सहेजें IF(A1=80,,IF(MOD(A1,20)>16,"+10+"&MOD(A1,20)-10,"+"&MOD(A1,20)))करने के लिएIFS(A1=80,,MOD(A1,20)>16,"+10+"&MOD(A1,20)-10,1,"+"&MOD(A1,20))

— Greedo

लिब्रेऑफ़िस कैल्क में, आप )अंत में छोड़ सकते हैं, क्या आप एक्सेल में भी ऐसा कर सकते हैं? तो आप 5 "बाइट्स" बचा सकते हैं (वास्तव में UCS2-Chars हैं, इसलिए यदि आप बाइट == ओकटेट कहते हैं, तो आपको इसे दोगुना करना होगा)। और अगर आप को बदलना होगा ,में;

— 12431234123412341234123

8

रेटिना , 52 48 बाइट्स

4 बाइट्स ने नील को धन्यवाद दिया

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

इसे ऑनलाइन आज़माएं! या सभी इनपुट सत्यापित (नील द्वारा प्रदान)

व्याख्या

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

पहले हम we०, handle० और ९ ० का अनुवाद संभालते हैं। इन पहले ३ चरणों में, start में एक और अक्षर के साथ शुरुआत के बाद इसे बदल दिया जाता है 60+1। इसी तरह 9से 81, और 8द्वारा प्रतिस्थापित किया जाता है 4*20+1। के प्रतिस्थापन 9अनिवार्य रूप से इसे "अस्सी-दस" में बदल रहा है और इस तरह, ताकि 8अगले प्रतिस्थापन द्वारा नियंत्रित किया जाता है, जो 4*20+1दो बार लिखने पर बाइट्स बचाता है ।

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

इस के मामलों को संभालती है 17, 18, और 19, की जगह 1के साथ प्रत्येक में 10+।

\+0

अंत में, कभी भी अंत में नहीं होना चाहिए +0, इसलिए इसे वहां होने पर हटा दें।

— बिजनेस कैट
स्रोत

निश्चित रूप से इसके बजाय अगर लुक बिहाइंड और लुकहेड्स आप कैप्चर समूहों का उपयोग कर सकते हैं

— डाउगोएट

के लिए काम नहीं करता है 7-9, लेकिन मुझे नहीं लगता कि आपको उस खोज की आवश्यकता है: इसे ऑनलाइन आज़माएं!

— नील

@ नील मुझे एहसास हुआ कि जब मैं गया था: पी लेकिन नए संस्करण के लिए धन्यवाद!

— बिजनेस कैट

@Downgoat मैं लुकहैड को एक कैप्चरिंग ग्रुप के साथ बदल सकता था, लेकिन यह तब तक किसी भी बाइट को नहीं बचाएगा, जब $1तक कि यह है ?=।

— बिजनेस कैट

7

पायथन 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]

इसे ऑनलाइन आज़माएं!

— XNOR
स्रोत

7

जावास्क्रिप्ट (ईएस 6), 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'

— ETHproductions
स्रोत

1

बहुत सारे इनपुट के लिए विफल रहता है; वास्तव में यह केवल 1..20, 30, 40, 50, 60, 80 और 100 के लिए काम करता है

— टाइटस

@ मुझे लगता है कि आप अधिकांश आउटपुट को गलत समझ रहे हैं। 23उदाहरण के लिए, आउटपुट के लिए माना जाता है 23, नहीं 20+3।

— ETHproductions

दो बाइट्स बचाएं(m=n%20)

— टाइटस

@Titus धन्यवाद, लेकिन मैंने पहले ही कोशिश की थी, और यह 70-99 पर काम नहीं करता है क्योंकि कॉल में mरीसेट हो जाता है । (यह एक वैश्विक चर है)0f(n-n%20)

— ETHproductions

आप को बदलने के द्वारा एक बाइट बचा सकते हैं n<70|n>99करने के लिए n%100<70। इसके अलावा, क्या आप एक परीक्षण-संकलक जोड़ सकते हैं?

— केविन क्रूज़सेन

5

आर, 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)

— नील
स्रोत

(i-r)/10इसके बजाय प्रयास करें floor(i/10)। और i>15होना चाहिए i>16।

— टाइटस

5

PHP, 99 बाइट्स (मैं खुश होना चाहता हूं संस्करण)

ETHproductions´ JS का एक सीधा पोर्ट , 4 बाइट्स गोल्फ वाली। ओपी द्वारा पूछे गए नंबरों को प्रिंट करता है।

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
;}

— टाइटस
स्रोत

4

पायथन 2, 130 108 बाइट्स

22 बाइट्स @mathjunkie की बदौलत बच गईं

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`

इसे ऑनलाइन आज़माएं!

— Uriel
स्रोत

108 बाइट्स: टीआईओ

— गणित के नशेड़ी

1

आपको गिनती करने की आवश्यकता है f=क्योंकि आपने इसे लैम्ब्डा के अंदर उपयोग किया था।

— लीक नून

@LeakyNun तय

— Uriel

3

बैच, 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 बाइट की बचत और सृजन करना । संपादित करें: सहेजे गए 3 बाइट @ ConorO'Brien के लिए धन्यवाद।

— नील
स्रोत

आप @echo offहेट लूप स्टेटमेंट को छोड़कर सभी स्टेटमेंट को हटाकर और उपसर्ग करके 3 बाइट्स बचा सकते हैं@

— कॉनर ओ'ब्रायन

@ ConorO'Brien Huh, मुझे आश्चर्य है कि मैं इस बार ऐसा क्यों करना भूल गया ...

— नील

2

जेली , 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

— जोनाथन एलन
स्रोत

2

पायथ, 61 56 बाइट्स

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

इसे ऑनलाइन टेस्ट करें!

5 बाइट सुधार के लिए लीक नून को धन्यवाद!

स्पष्टीकरण:

                     | 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

— के झांग
स्रोत

*-Q100>Q69→}/QTr6T

— लीक नून

@]b}17 19→}b}17 19

— लीक नून

+"10+"eb→j\+,Teb

— लीक

@LeakyNun गोल्फिंग की मदद के लिए धन्यवाद! मैंने आपके द्वारा सुझाए गए परिवर्तन किए हैं।

— के झांग

1

पायथन 3, 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__।

— एमु
स्रोत

PPCG में आपका स्वागत है! मेरा मानना है कि पूर्णांक से ऑब्जेक्ट में मैपिंग के रूप में एरेज़ को प्रस्तुत करने के बारे में मेटा पर चर्चा हुई थी, लेकिन मैं इसे फिलहाल नहीं ढूंढ सकता। मैं आपको बता दूंगा कि क्या मैं करता हूं (और उस चर्चा का परिणाम क्या था)। किसी भी तरह से, आपको आवश्यकता नहीं होगी f=, क्योंकि अनाम फ़ंक्शन (जैसे कि प्रस्तुत फ़ंक्शन का मूल्यांकन करने वाले भाव) ठीक हैं, जब तक कि पुनरावृत्ति जैसी किसी चीज़ के लिए नाम की आवश्यकता नहीं है।

— मार्टिन एंडर

कोई स्पष्ट सहमति नहीं है, लेकिन मामूली रूप से शीर्ष मतदान जवाब आपके समाधान की अनुमति देता है।

— मार्टिन एंडर

0

जावा 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));
    }
  }
}

— केविन क्रूज़सेन
स्रोत

संख्याओं का फ्रेंच में अनुवाद करें

एक्सेल, 153 149 बाइट्स

रेटिना , 52 48 बाइट्स

पायथन 2 , 98 बाइट्स

जावास्क्रिप्ट (ईएस 6), 73 71 बाइट्स

आर, 110 बाइट्स

PHP, 99 बाइट्स (मैं खुश होना चाहता हूं संस्करण)

मैं सही संस्करण होना चाहता हूँ, 114 98 बाइट्स

पायथन 2, 130 108 बाइट्स

बैच, 220 217 बाइट्स

जेली , 55 बाइट्स

कैसे?

पायथ, 61 56 बाइट्स

पायथन 3, 127 बाइट्स

जावा 7, 97 96 109 बाइट्स