क्रमबद्ध एक नंबर। sorta

Question

अ -छांट-छांट -ए-अंकों-अंकों-बिना-उपयोग-एक-सरणी से प्रेरित , लेकिन मुझे लगा कि यह एसओ प्रश्न से बेहतर कोड गोल्फ बना।

एक सकारात्मक पूर्णांक को देखते हुए, उस पूर्णांक में अंकों को क्रमबद्ध करें।

सबसे कम स्कोर जीत!

1. 0 अंक से शुरू करें।
2. प्रति वर्ण एक बिंदु जोड़ें।
3. आपके द्वारा उपयोग किए जाने वाले प्रत्येक सरणी के लिए 20 अंक जोड़ें।
4. अपने कोड में प्रत्येक मल्टी-कैरेक्टर स्ट्रिंग के लिए 10 अंक जोड़ें। (प्रारंभिक इनपुट को छोड़कर जब तक कि यह किसी भी अन्य ऑपरेशन के बिना पूर्णांक में परिवर्तित नहीं हो जाता है।)
5. यदि आपके प्रोग्राम को हैंडल करने की अधिकतम संख्या आपके प्रोग्राम (मशीन के विपरीत) तक सीमित है, तो 32 अंक जोड़ें।
6. 10 अंक घटाएं यदि आपका कोड किसी अन्य तर्क दिए गए सॉर्ट की दिशा बदल सकता है (जो भी आप चाहते हैं, लेकिन उदाहरण के लिए 0 अवरोही क्रम के लिए और 1 आरोही के लिए।)

हर भाषा अलग है, लेकिन यह विचार किसी भी तरह के चलने-फिरने के अंक से बचने का है।

उदाहरण:

इनपुट : 52146729

आउटपुट : 97654221 या 12245679

टिप्पणियाँ:

1. किसी भी अंतर्निहित छँटाई क्षमताओं का उपयोग करें जो आपकी प्रोग्रामिंग भाषा प्रदान करती है, लेकिन अगर उस तरह की सुविधा में तार या सरणियाँ शामिल हैं, तो जुर्माना लें!
2. आप समाधान को एक फ़ंक्शन के रूप में लिख सकते हैं जो सीधे एक पूर्णांक लेता है, या एक प्रोग्राम के रूप में जो argv, एक फ़ाइल या स्ट्रीम से एक तर्क लेता है और इसे पूर्णांक में परिवर्तित करता है। जब तक आप इसे तुरंत एक पूर्णांक में बदल देते हैं और उस पर आगे कोई ऑपरेशन किए बिना मूल चार * इनपुट को छोड़ देते हैं, कोई भी जुर्माना लागू नहीं होता है।
3. दंड न केवल आपके प्रोग्राम टेक्स्ट में स्ट्रिंग शाब्दिकों पर लागू होता है, बल्कि आपके प्रोग्राम के किसी भी हिस्से में यकीनन इनपुट या आउटपुट स्ट्रिंग या पुनरावृत्त करता है। उदाहरण के लिए, जावास्क्रिप्ट String.prototype.splitमें इनपुट के रूप में कम से कम एक स्ट्रिंग ( this) और आउटपुट के रूप में एक सरणी है, इसलिए उस का उपयोग करने के लिए +30।
4. मैंने इन नियमों को एल्गोरिथ्म डिज़ाइन के सिद्धांत को बनाने की कोशिश की है, न कि प्रारंभिक / अंतिम I / O (इसलिए # 2 नोट करें)। मुझे नहीं लगता कि जुर्माना लगाने की जरूरत है, int(input())भले ही inputहस्ताक्षर यह एक स्ट्रिंग लौटाता है, जब तक कि अभिव्यक्ति कार्यक्रम का प्रारंभिक प्रवेश बिंदु है। इसी तरह, यदि प्रोग्राम का अंतिम आउटपुट है print(x)और xएक स्ट्रिंग होना चाहिए, तो जुर्माना अंतिम-खाई स्ट्रिंग कास्टिंग ऑपरेशन पर लागू नहीं होता है। सभी ने कहा, मैंने स्पष्ट रूप से कभी नहीं कहा कि यह एक कार्यक्रम होना था या जहां मुझे / ओ को आना या जाना था। एक फ़ंक्शन जो एक लेता है intऔर एक रिटर्न देता है, intवह सेवा करेगा, और इन अस्पष्टताओं से ग्रस्त नहीं होगा।

Comments

करता है " "एक के रूप में गिना बहु चरित्र स्ट्रिंग? एक एकल चरित्र को "बहु" के रूप में नहीं माना जाएगा ...

— वैलीवेस्ट

मेरे लिए नींद का एक आसान कार्यान्वयन की तरह लगता है।

— user12205

आप भाषा की छंटाई के लिए मना नहीं करते हैं।

— user80551

मैं बिल्ट-इन फ़ंक्शंस के बारे में बेहतर नियम लिखूंगा, दंड भी बहुत कम हैं: यह वैकल्पिक (शायद लंबे समय तक) पद्धति के बजाय एक सरणी के उपयोग को प्रोत्साहित करता है।

— एंटोनियो रागैगिन

@AntonioRagagnin मैं दंड पूर्व पद परिवर्तन को बदलना नहीं चाहता था, लेकिन मैंने अंतर्निहित कार्यों के आसपास के नियमों को स्पष्ट किया।

— कोजिरो

Answer 1

GolfScript, 11 4

(4 + 10 (स्ट्रिंग) - 10 (रिवर्स ऑप्शन))

STDIN पर इनपुट।

~`$%

इनपुट प्रारूप यह है:

(1 or -1) (the number)

1सामान्य रूप से क्रमबद्ध करना, -1उल्टा करना। 4 वर्ण - रिवर्स ऑप्शन के लिए 10 = -6 का स्कोर।

इनपुट तकनीकी रूप से एक स्ट्रिंग है, इसलिए मुझे यकीन नहीं है कि यह +10 के लिए मायने रखता है। मैं नियम की व्याख्या "आपके कार्यक्रम में घोषित एक स्ट्रिंग" के रूप में कर रहा हूं (क्योंकि यह "आपके कोड में" कहता है)।

---

पुराना उत्तर (स्कोर 11):

$

Comments

जीएस में स्ट्रिंग्स तकनीकी रूप से सरणियों हैं, बस स्कोरिंग बहस को जटिल बनाने के लिए।

— पीटर टेलर

हां, एक स्ट्रिंग का इनपुट (जो तुरंत पूर्णांक में परिवर्तित नहीं होता है) +10 है।

— कोजिरो

@kojiro ~तुरंत पूर्णांक में परिवर्तित हो जाता है। लेकिन तब इसे वापस स्ट्रिंग के साथ बदल दिया जाता है `। क्या एक स्ट्रिंग गणना में परिवर्तित होता है? क्योंकि कभी कभी स्ट्रिंग multicharacter (1 अंकों इनपुट) नहीं हो सकता है

— दरवाज़े

हाँ, एक स्ट्रिंग में परिवर्तित करना जब तक कि फ़ंक्शन (या जो भी हो) केवल एक-वर्ण स्ट्रिंग को आउटपुट कर सकता है । यह फ़ंक्शन हस्ताक्षर या प्रलेखन के आधार पर मूल्यांकन किया जाना चाहिए। यदि यह एक वर्ण (जैसे chr) को आउटपुट करने के लिए डिज़ाइन किया गया है , तो यह ठीक है।

— कोजिरो

Answer 2

हास्केल 106

t=10;d=divMod;s z|z<w z=s$w z|t>0=z
w x|x<t=x|y>z=(q*t+y)*t+z|t>0=y+t*(w v)where{(v,y)=d x t;(q,z)=d v t}

उदाहरण:

ghci> s 502010406072952146729521467295214672952146729
999997777766666555554444422222222221111100000

एक जवाब जो सवाल को चकमा नहीं देता है।

एक स्पष्टीकरण का अनुरोध किया गया था, यहां यह अपुष्ट है। यह एक बहुत ही अकुशल बबल सॉर्ट है।

-- t=10 - alias for 10. d=divMod - alias for divMod.
-- The alias for '10' turns out to be unnecessary; inlining it
-- and using '1>0' for True has the same character count. It's
-- a relic of earlier versions of the code.

-- 's': if no digits need swapped, return the number,
-- otherwise return 's' applied to the number with
-- that pair of digits swapped.
sort z=
  let temp=sort_pair z
  -- because we are sorting in descending order,
  -- sorting a pair of digits always increases the number.
  -- testing > costs one less char than ==.
  if z<temp then
    -- golfed version uses guards instead of if/else to save space.
    -- t>0 is '10 > 0', which is 'True', in fewer chars.
    sort temp
  else
    z
-- 'w': recursively swap one pair of out of order digits, or
-- return the original number if no pairs needed swapped.
sort_pair x=
  -- haskell does the assignments below lazily, they aren't
  -- calculated unless I use them. 'divMod' lets me do this
  -- with fewer chars.
  let y = x `mod` 10 -- last digit
      v = x `div` 10 -- all but last digit
      z = v `mod` 10 -- second last digit
      q = v `div` 10 -- all but last 2 digits
  in
  if x < 10 then
    x
  else if y > z then
    -- last 2 digits are out of order. swap them & return
    -- This is rearranged using Horner's method to save space
    -- http://en.wikipedia.org/wiki/Horner%27s_method
    -- ... although it turns out not to save anything, it's a relic.
    (q * 10 + y)*10 + z
  else
    -- last digit is ok, so try sort_pair on remaining digits
    let temp = sort_pair v in
    -- put last digit back on the end and return
    -- having the bracketed expression last here
    -- let me remove a space before 'where'
    y+(10*temp)

Shask जवाब हास्केल में मौजूद हैं, जो पोस्ट किए गए कुछ अन्य लोगों के बराबर हैं:

import Data.List;s=read.sort.show::Integer->Integer

... स्कोर 52 + 20 = 72, या यह, स्कोरिंग 45 + 20 = 65:

import Data.List;main=interact(reverse.sort)

... लेकिन सवाल की भावना - कोई सरणियाँ, तार, या वर्ण - अधिक दिलचस्प नहीं है।

Comments

क्या आप एक स्पष्टीकरण जोड़ सकते हैं?

— user80551

हास्केल के अंतर्निहित मनमाना सटीक पूर्णांक के कारण पूर्णांक इनपुट आकार को मशीन द्वारा सीमित नहीं होने के लिए आपको एक बोनस अंक में कमी मिलनी चाहिए ।

— पुनरावृत्ति.निन्जा

@ वाशबर्न खैर, वह मिल गया (यानी उसने 32 अंक नहीं जोड़े!) और माना जाता है, तो मैंने ( यहां )

— भूख ब्लू देव

@ambigram_maker मुझे लगता है कि उनका मतलब है कि आपका, उदाहरण के लिए, इनपुट से बड़ा नहीं ले सकता- Integer.MAX_VALUEयह एक लेता है int। मेरा, और दूसरों से कुछ, किसी भी आकार इनपुट-निवेश के प्रकार को स्वीकार sहै Integer, में बराबर BigDecimalजावा में। यही कारण है कि मैं सवाल का मतलब नहीं है, हालांकि, मुझे लगा कि यह जवाब दे रहा था कि 'एक ही अंक' क्रमबद्ध करें।

— बाज़रघ

यह आसानी से बदल गया है। मुझे नहीं लगता कि यह एक बड़ी बात है।

— bazzargh

Answer 3

सी + x86 विधानसभा, 636

मुझे पता है कि यह जीतने वाला नहीं है, लेकिन यह इतना अप्राकृतिक है और मुड़ जाता है कि मुझे इसे साझा करना पड़ा। कोई सरणियाँ या तार (जब तक आप इनपुट तर्कों की गिनती नहीं करते)। 32 बिट रेंज द्वारा इसके सीमित अंकों की संख्या।

तो यहाँ मैंने क्या किया पर थोड़ा स्पष्टीकरण है:

मैंने सोचा कि मैं बिना किसी सरणियों या तार का उपयोग किए बिना ऐसा करूंगा, और फिर पुनरावृत्ति मन में आ गई, लेकिन निश्चित रूप से, पुनरावृत्ति के साथ मैं अन्य पुनरावर्ती कॉलों से मूल्यों को स्वैप करने में सक्षम नहीं होगा ... और तब मुझे एहसास हुआ कि एक रास्ता था। मेरे सी प्रोग्राम को असेंबली फ़ंक्शन के साथ जोड़ना मैं स्टैक में कूद सकता हूं और वांछित कॉल के बेस पॉइंटर को एक पॉइंटर लौटा सकता हूं, यही "रिकर्सियनस्टैकएट" फ़ंक्शन करता है। बेशक recursionStackAt एक बहुत ही बदसूरत फ़ंक्शन है, इसका परिणाम केवल इनपुट या प्रोग्राम की स्थिति पर ही नहीं बल्कि कॉलर पर भी निर्भर करता है। ध्यान दें कि इसने मुझे 0 से 1 के आधार पर अनुक्रमित को बदलने के लिए बनाया है।

आगे की हलचल के बिना, यहाँ कोड है:

#include <stdio.h>
#include <stdlib.h>

int numberToSort;
int totalLength = 0;
int decreasing;

int* recursionStackAt(int pos); //Here's the magic

void swapAtStack(int pos1, int pos2) {
    int a = *(recursionStackAt(pos1)+3);
    *(recursionStackAt(pos1)+3) = *(recursionStackAt(pos2)+3);
    *(recursionStackAt(pos2)+3) = a;
}

int getAt(i) {
    return *(recursionStackAt(i)+3);
}

void printNumber(int len) {
    int i = 0;
    for(i = 1; i <= len; ++i) {
        printf("%d",*(recursionStackAt(i)+3));
    }
    printf("\n");
}

void computeNextDigit(int remainingNumber, int nextDigit) {

    if(remainingNumber == 0) {
        //Bubble sort cause I was lazy and it's quite compact
        ++totalLength;

        int i, j;

        for(i = 1; i <= totalLength; ++i)
            for(j = 1; j <= totalLength-1; ++j) {
                if(decreasing) {
                    if(getAt(j) > getAt(j+1)) 
                        swapAtStack(j,j+1);
                }
                else { 
                    if(getAt(j) < getAt(j+1))
                        swapAtStack(j,j+1);
                }
            }

        printNumber(totalLength);   
    }
    else {
        ++totalLength;
        computeNextDigit(remainingNumber/10, remainingNumber%10);
    }
}

int main(int argc, char* argv[]) {
    if(argc == 3) {
        numberToSort = atoi(argv[1]);
        decreasing = atoi(argv[2]);
    }
    else exit(1);
    computeNextDigit(numberToSort/10, numberToSort%10);
} 

और निश्चित रूप से x86 (AT & T sintax, btw) असेंबली कोड recursionStackAt फ़ंक्शन के लिए:

.text
    .align 4
    .globl  recursionStackAt
    .type   recursionStackAt, @function
recursionStackAt:
        pushl %ebp
        movl %esp,%ebp
        pushl %esi
        movl $0, %esi #i = 0
        movl (%ebp), %eax #pointer
while:  
        cmp %esi, 8(%ebp)
        je endwhile
        movl (%eax),%eax
        incl %esi
        jmp while
endwhile:
        popl %esi
        movl %ebp, %esp
        popl %ebp
        ret

आउटपुट पर कुछ उदाहरण: (1 का मतलब बढ़ता है और 0 घटता है)

$ ./sortasort 6543210 1
0123456
$ ./sortasort 32507345 1
02334557
$ ./sortasort 32507345 0
75543320

यहाँ ओफ़्फ़ुसेटेड संस्करण है (जो अपठनीय है लेकिन ठीक काम करता है):

http://pastebin.com/XkYt9DLy (C कोड) http://pastebin.com/h0S0dfeU (x86 कोड)

तो अगर लिबरऑफिस में मेरा ओफ़्फ़ुसेट कोड नहीं है, तो इसमें 646 अक्षर हैं (रिक्त स्थान के बिना, क्या मुझे उन्हें गिनना चाहिए?) और अन्य सभी शर्तों के साथ मुझे मिला-incresing / घटती पसंद के लिए -10 मिलता है।

ओह, और इसे संकलित करने के लिए आपको (यूनिक्स जैसी प्रणालियों पर) करना चाहिए

gcc -c [-m32] recursionStackAt.s 
gcc -o sortasort [-m32] sortasort.c recursionStackAt.o

ध्यान दें कि -m32 ध्वज केवल तभी है जब आप 64 बिट मशीन पर हों। इसे संकलित करने के लिए आपको 32 बिट पुस्तकालयों की भी आवश्यकता है।

Comments

मुझे लगता है कि आवश्यक व्हाट्सएप को आम तौर पर गिना जाता है। अनावश्यक व्हाट्सएप बंद करने के बाद, कम से कम मैं क्या करता हूं। किसी को भी, जो इस तरह से ढेर के साथ गड़बड़ करने के लिए गेंदों को मेरे उत्थान हो जाता है! +1

— डिजिटल ट्रॉमा

Answer 4

बैश (गूंज) (0 + 7 + 0 + 0 + 32-10) = 29

sorta:

echo $*

उपयोग:

sorta 5
5

रिवर्स में छाँटने के लिए "-e" का प्रयोग करें:

sorta -e 3
3

• सकारात्मक पूर्णांक 1-9, प्लस 0 के लिए सही परिणाम देता है
• किसी भी तरह के चलने-फिरने वाले अंकों की हैकिंग से बचा जाता है।
• 7 अक्षर (+7)
• कोई ऐरे नहीं
• कोई मल्टी-कैरेक्टर स्ट्रिंग्स नहीं
• अंकों की अधिकतम संख्या इसे संभाल सकती है: 1 (+32)
• वैकल्पिक रूप से सॉर्ट को उल्टा कर सकते हैं (-10)

संपादित करें: "कैट" को "इको" में बदल दिया ताकि यह वास्तव में काम करे। EDIT 2: "$ *" जोड़ा और इसे "सॉर्टा" स्क्रिप्ट में डाल दिया

Comments

haha; ); अच्छा चाल, लेकिन यह अभी भी सभी से बाहर खोने जवाब (यह भी शासन-झुकने) अब तक का जवाब देता है

— दरवाज़े

पूरी चीज अवांछनीय है; छँटाई पर क्यों चुना?

— ग्लेन रैंडर्स-पीहरसन

नियमों का पौराणिक दुरुपयोग। +1

— डिजिटल ट्रॉमा

@ कोकोजी: उदाहरण के लिए, -eरिवर्स आउटपुट के लिए तर्क के रूप में इस्तेमाल किया जा सकता है।

— हेइको ओबर्डिएक

कोई बात नहीं, आप सही हैं, "-ई" के साथ-साथ "" भी काम करेगा। मुझे उपयोगकर्ता मैनुअल को फिर से लिखना होगा, और पिछड़े कंपैटिबिलिटी के लिए मुझे "" स्वीकार करना जारी रखना होगा।

— ग्लेन रैंडर्स-पीरसन

Answer 5

python3

मेरी स्क्रिप्ट विशेषताएं:

कोई ऐरे नहीं

कोई संबंध नही

जटिलता O (n) है: मैंने काउंटर्सॉर्ट का उपयोग किया (सरणियों का उपयोग न करने के लिए मेरे द्वारा संशोधित किया गया, लेकिन प्रमुख संख्याओं को गिनने के लिए)

आकार में कोई सीमा नहीं

वर्ण: २६० २३४

n=int(input())
def C(n,k):
    return (n//(10**(k-1)))%10
P=lambda l:((((29-6*l%2,19-2*l%2)[l<9],13-2*l%2)[l<7],2*l-1)[l<5],2)[l==1]

p=1
while n>=1:
    c =C(n,1)
    p*=P(c+1)
    n=n//10
f=1
k=r=0
while p>2:
    if(p%P(f)==0):
        r+=(f-1)*10**k
        p=p//P(f)
        k+=1
    else: f+=1
print(r)

Comments

मैं गलत हो सकता है, लेकिन मुझे लगता है कि आप कुछ वर्णों को बंद करने के लिए उस अंकगणित के आसपास के पार्न्स खो सकते हैं।

— कोजिरो

मुझे वास्तव में यहाँ primes का उपयोग पसंद है। यह बहुत अजीब है । इसके अलावा, मुझे लगता है कि Pलिखा जा सकता है lambda l:((((29-6*l%2,19-2*l%2)[l<9],13-2*l%2)[l<7],2*l-1)[l<5],2)[l==1], काफी कुछ पात्रों को शेविंग। मैंने इसे थोड़ा गड़बड़ कर दिया है, लेकिन यह विचार पुराने स्कूल पायथन टर्नेरी के एक नेस्टेड संस्करण का उपयोग करने के लिए है (इससे पहले कि पायथन में एक टर्नरी था) (false_result, true_result)[boolean]।

— कोजीरो

इंटरनेट से यादृच्छिक आदमी धन्यवाद! BTW मैं अब इसके साथ मज़े कर रहा हूँ, यह देखने की कोशिश करें कि क्या आप इसे पसंद करते हैं: codegolf.stackexchange.com/a/25086/16992

— एंटोनियो रैगैगिन

Answer 6

बैश + कोरुटिल्स, 14 (24 वर्ण - 10 रिवर्स के लिए)

मुझे लगता है कि यह नियमों को थोड़ा झुका सकता है, लेकिन यहाँ जाता है, इसका शुक्रवार ...

मुझे लगता है कि मानक पुस्तकालयों के उपयोग की अनुमति है। के लिए मानक पुस्तकालय की मेरी व्याख्या bashहै coreutils:

fold -1|sort $1|tr -d\\n

• इसके बजाय कोई सरणियाँ - धाराएँ उपयोग की जाती हैं
• कोई उद्धरण नहीं == कोई बहु-चरित्र तार नहीं
• इनपुट / आउटपुट लंबाई की कोई सीमा नहीं
• वैकल्पिक arg "-r" आउटपुट को उलट देता है।

स्टड से इनपुट। उपयोग में:

$ declare -i i=52146729
$ ./ksort.sh <<< $i
12245679 $ 
$ ./ksort.sh -r <<< $i
97654221 $ 
$ 

Comments

मैं वास्तव में चाहता हूं कि मैं इस कार्यक्रम के खिलाफ एक नियम शामिल करूं जो किसी भी चीज के साथ काम नहीं करता है। मुझे लगता है कि अब बहुत देर हो चुकी है।

— कोजिरो

"\\ n" के बाद नई लाइन की गिनती न करें, ताकि आप 20 नहीं 21 का स्कोर करें।

— ग्लेन रैंडर्स-पीरसन

मैं न्यूलाइन की गिनती नहीं कर रहा हूं, लेकिन एक फाइल में सहेजी गई स्क्रिप्ट के रूप में यह ईओएफ में एक 0 है जैसा कि मेरे संपादक द्वारा सहेजा गया है। मैं आमतौर पर इनकी गिनती वैसे भी करता हूं। लेकिन मैं उस \ 0 को हटा सकता हूं, और स्क्रिप्ट अभी भी काम करती है, इसलिए मैं इसे ले जाऊंगा!

— डिजिटल ट्रामा

@kojiro यह bashपूर्णांक के विचार के साथ भी काम करता है (घोषित -आई)। संपादित।

— डिजिटल ट्रामा

(बीएसडी / ओएसएक्स trआपके सिंटैक्स को पसंद नहीं करता है, जिससे आपको उन प्रणालियों पर एक चरित्र खर्च करना होगा।) वैसे भी, मैं तर्क दूंगा कि ये अभी भी दिल के सभी स्ट्रिंग ऑपरेशन हैं। declare -iएक नाम को पूर्णांक नहीं बनाता है, यह सिर्फ असाइनमेंट अभिव्यक्तियों के आरएचएस पर इस पर शेल उपयोग अंकगणितीय संदर्भ बनाता है।

— कोजिरो

Answer 7

सी - 64 अक्षर, 64 अंक

main(int a,char**b){b++;qsort(*b,strlen(*b),1,strcmp);puts(*b);}

आपको आश्चर्य हो सकता है कि बिना किसी हेडर के काम करने के लिए मुझे यह कैसे मिला। सरल, के साथ संकलन:

gcc -include stdio.h stdlib.h string.h test.c -o test --std=gnu11 -Wall -g -O3

संयुक्त राष्ट्र के golfed:

#include <stdio.h> 
#include <stdlib.h>
#include <string.h>

main(int a, char **b)
{
    b++;
    qsort(*b, strlen(*b), sizeof(char), strcmp);  // sizeof(char) is guaranteed to be 1 by standards
    puts(*b);
}

---

मैंने भी पात्रों को छांटने का निर्णय लिया, क्योंकि मैं कर सकता था।

टेस्ट रन:

$ ./test 132815
112358
$ ./test 423791
123479
$ ./test 1234767189728975213132471243985123957120837412
0111111112222222233333344445556777777788889999
$ ./test 4789359uihjasvb8ygohq9poi3n4jiouy58g
3344557888999abgghhiiijjnooopqsuuvyy

Comments

"गोल्फिंग" का अच्छा प्रदर्शन किया: डी

— प्रोग्रामरडान

मैं इसे 14.04 उबंटू में संकलित नहीं कर सकता, लेकिन मैं संकलन कर सकता हूं main(int a,char**b){b++;qsort(*b,strlen(*b),1,strcmp);puts(*b);}जो वैसे भी कम है।

— gmatht

@gmatht मुझे यकीन नहीं है कि यह संकलन क्यों नहीं होगा, यह मेरे सिस्टम पर ठीक था। संकेत BTW के लिए धन्यवाद!

— syb0rg

यह पसंद नहीं आया c(*a, जीसीसी के मेरे संस्करण ने जोर दिया कि हमें c(char*aइसके बजाय करने की आवश्यकता है ।

— gmatht

Answer 8

c फंक्शन (लिटिल-एंडियन आर्क), 131 108 वर्ण

स्लीपर्स उत्तर के बिना कोई छंटनी चुनौती पूर्ण नहीं है । इसे वापस लौटने में 10 सेकंड का समय लगेगा, लेकिन यह काम करता है, और मुझे लगता है कि यह पूरी तरह से कल्पना के भीतर है। यह फ़ंक्शन एकल इंट परम लेता है और दशमलव अंक के साथ एक इंट रिटर्न देता है:

c=0,d;
k(i){
    for(;i;i/=10,fork()?c++:(sleep(d),exit(d)))
        d=i%10;
    for(;c--;i=i*10+(d>>8&255))
        wait(&d);
    return i;
}

_{पठनीयता के लिए नए अंक और इंडेंटेशन जोड़े गए}

कॉल इस प्रकार है:

int main (int argc, char **argv) {
    int i = 52146729;

    printf("%d\n", k(i));
    return (0);
}

Comments

अच्छा लगा। लेकिन मुझे लगता है कि आप कुछ चार्ट को बचाने के लिए वैश्विक चर का उपयोग कर सकते हैं। इसके अलावा, आप के ?:बजाय उपयोग कर सकते हैं if-else। fork()?c++:(sleep(d),exit(d));

— user12205

@ace सुझावों के लिए धन्यवाद! मैंने पहले टर्नरी ऑपरेटर की कोशिश की, लेकिन फिसल गया (,)।

— डिजिटल ट्रामा

Answer 9

जावा: 262 अंक

हाँ, मुझे पता है, यह निराशाजनक है, लेकिन फिर भी ..

class G{Object m(StringBuffer s,int o){for(int i=1;i<s.length();i++){int j=i-1,t=s.charAt(i),u=s.charAt(j);boolean c=o==0?t>u:t<u;for(;j>-1&c;){s.setCharAt(j+1,s.charAt(j));c=--j>-1;c=c?(o==0?t>s.charAt(j):t<s.charAt(j)):c;}s.setCharAt(++j,(char)t);}return s;}}

विश्लेषण (अंकन):

1. 0. से शुरू (स्कोर = 0)
2. कुल 262 वर्ण। (स्कोर = 0 + 262 = 262)
3. +10 - उपयोग करने के लिए StringBuffer(मैंने इसका इस्तेमाल किया क्योंकि यह इससे छोटा है StringBuilder) (स्कोर = 262 + 10 = 272)
4. -10 - आउटपुट को लचीला बनाने के लिए। मैंने 0 = अवरोही माना है , 1 = आरोही , तो वापस 262 पर!

उपयोग:

जब आप G.javaकमांड प्रॉम्प्ट में फ़ाइल को आज़माते और संकलित करते हैं , तो यह बहुत सारी समस्याओं (त्रुटियों) का एक नरक उत्पन्न करता है। तो, समाधान?

संकलित G.javaकी तरह एक IDE में वर्ग NetBeansया Eclipseया यहाँ तक कि BlueJ। इसे बिना किसी परेशानी के संकलित करना चाहिए (किसी भी चेतावनी को अनदेखा करना)।

फिर, इस वर्ग को main()किसी अन्य वर्ग (या यहां तक ​​कि स्वयं कक्षा) से एक विधि द्वारा बुलाया जाना चाहिए । मैं इसे दूसरी कक्षा में रख रहा हूं, इसलिए मैं इसे अपने कैरेक्टर काउंट में शामिल नहीं कर रहा हूं। अन्य वर्ग को समान तरीके से (बिना उपयोग किए cmd) संकलित करें । अब दूसरी कक्षा main()में विधि कुछ इस तरह होनी चाहिए:

public static void main(String[]a){
    System.out.println(new G().m(new StringBuffer(a[0]),1));
    //for descending, put '0' instead of '1'
}

अनावश्यक रिक्त स्थान, टिप्पणियों और लाइन विराम को छोड़कर, यह एक और 93 वर्ण है। मैं इसे अपने चरित्र से नहीं जोड़ रहा हूं क्योंकि यह सिर्फ कंसोल के माध्यम से प्रदर्शन के लिए है।

आउटपुट:

शून्य अर्थात 0माना जाता है। माना जाता है कि बाहरी वर्ग है Helper.java, और इसे सफलतापूर्वक संकलित किया गया है, कंसोल के माध्यम से कुछ उदाहरण हैं:

INPUT :C: ...> जावा हेल्पर 008321
OUTPUT:001238

INPUT :C: ...> जावा हेल्पर 79359105
OUTPUT:01355799

जब बदलकर 0उतरते हुए ...

INPUT :सी: ...> जावा हेल्पर +०,०८,३२१
OUTPUT:832,100

INPUT :C: ...> जावा हेल्पर 79359105
OUTPUT:99755310

टिप्पणियाँ:

1. मैंने स्पष्ट रूप से किसी भी सरणी को घोषित नहीं किया था G.java। वह कोर क्लास है।
2. मैं अंक-वार को सॉर्ट करने के लिए प्रविष्टि प्रकार का उपयोग कर रहा हूं ।
3. संख्या अधिकतम लंबाई की हो सकती है - Integer.MAX_VALUEक्योंकि अधिकतम आकार किसी भी सरणी को (जावा में) पकड़ सकता है।
4. इस जवाब को छोटा किया जा सकता है (मेरा मानना ​​है) इसलिए कृपया मेरी मदद करें (मेरा पहला उत्तर सुधारें)।
5. हिम्मत उन महान भगवानों की जिन्होंने अकस्मात जावा की तरह इतनी लंबी और इतनी बड़ी भाषा बनाई (और जो कोड सम्मेलनों के साथ आए)!

Answer 10

TeX / LaTeX (332)

यदि वास्तविक कोड एक पैकेज में रखा गया है s, तो मुख्य LaTeX फ़ाइल अच्छी और आसान लगती है। नंबर सिर्फ गणित के रूप में दिया गया है। यदि संख्या नकारात्मक है, तो क्रमबद्ध क्रम उलट जाता है। पैकेज का कोड sसादे TeX के साथ भी इस्तेमाल किया जा सकता है, नीचे उदाहरण।

\documentclass{book}
\usepackage{s}
\begin{document}
  $52146729$

  $-52146729$ % reversed ordering

  $277981468517523153773703292073191466142223027369188752287219582183$
\end{document}

पैकेजs (एक पंक्ति, पंक्ति समाप्त होने की आवश्यकता नहीं है):

\TeXXeTstate1\everymath{\aftergroup\B\def~#1{\gdef#1{}\aftergroup#1}
~\a~\b~\c~\d~\e~\f~\g~\h~\i~\j\aftergroup\E\xdef\B{}\xdef\E{}}
\def~#1#2{\mathcode`#1"8000\lccode`~`#1\lowercase{\def~{\xdef#2{#2#1}}}}
~0\a~1\b~2\c~3\d~4\e~5\f~6\g~7\h~8\i~9\j\mathcode`-"8000\lccode`~`-
\lowercase{\def~{\xdef\B{\beginR}\xdef\E{\endR}}}

परिणाम:

स्कोर: निराशाजनक

• etexया के साथ सादा TeX का उपयोग कर pdftex, फ़ाइल को निम्न तक घटाया जा सकता है:

  <contents of s.sty>\rm\shipout\hbox{$<number>$}\bye

  बाइट्स: संख्या के बिना शेष के लिए 318 बाइट्स ( s.sty) + 24 बाइट्स

• Arrays का उपयोग नहीं किया जाता है: 0

• मैं बहु-चरित्र तार नहीं देखता: 0

• संख्या एल्गोरिथ्म द्वारा सीमित नहीं है। सबसे बड़ा TeX नंबर 2 ³¹ - 1 = 2147483647 है। उदाहरण 66 अंकों की संख्या का उपयोग करता है, जिस तरह से बड़ा: 0

• यदि एक माइनस दिया जाता है, तो छँटाई क्रम को अवरोही पर वापस लाया जाता है: .10

0 + 318 + 24 + 0 + 0 - 10 = 332

कलन विधि:

अंक गणित विधा में सक्रिय वर्ण बनाए जाते हैं। प्रत्येक अंक एक मैक्रो में प्रत्येक usages को याद करता है और एकत्र करता है। गणित विधा के बाद आरोही क्रम में अंकों के साथ मैक्रोज़ आउटपुट होते हैं।

दिशा-परिवर्तन दाएं-बाएं पाठ, एक ई-टीएक्स फ़ीचर द्वारा किया जाता है।

में कोड के Degolfed संस्करणs.sty

\TeXXeTstate = 1 % enable mixed direction typesetting
\everymath{%
  % \B and \E surround the number, they will be redefined
  % with right-to-left primitives to output the reverted number
  \xdef\B{}
  \xdef\E{}
  \aftergroup\B
  % the active character ~ is defined as help macro;
  % the argument is the collector macro
  \def~#1{%
    \gdef#1{}% initially the macro is empty
    \aftergroup#1%
  }%
  % the ten macros \a to \j form the result number
  ~\a~\b~\c~\d~\e~\f~\g~\h~\i~\j
  \aftergroup\E
}
% the active ~ is used as helper macro;
% first argument is the digit, the second argument is the collector macro
\def~#1#2{%
  \mathcode `#1  = "8000 % make digit active in math mode
  \lccode `~ = `#1 % trick for defining the active digit 
  \lowercase{%
    \def~{%
      \xdef#2{#2#1}% the digit adds itself to its collector macro
    }%
  }%
}
~0\a~1\b~2\c~3\d~4\e~5\f~6\g~7\h~8\i~9\j
% Defining the minus character as switch for descending digits:
\mathcode `- = "8000 % minus sign active in math mode
\lccode `~ = `- % trick for defining the active minus
\lowercase{%
  % the minus sign redefines the wrapper macros \B and \E that
  % surround the result number. These macros now uses
  % primitives for right-to-left typesetting.
  \def~{%
    \xdef\B{\beginR}%
    \xdef\E{\endR}%
  }%
}

प्रजनन

कुछ ऑनलाइन लाटेक्स संकलक हैं, एक सूची यहां पाई जा सकती है । मैंने सूची में पहले आइटम की कोशिश की, विज्ञान पर LaTeX सर्वलेट । इसका उपयोग बिना हस्ताक्षर के किया जा सकता है और यह स्थायी यूआरएल भी बना सकता है: स्रोत और परिणाम छवि के रूप में ।

Comments

मेरे पास खुद का आकलन करने के लिए लाटेक्स चॉप्स नहीं हैं। मुझे इसके लिए आपका शब्द लेना होगा। :)

— कोजिरो

@kojiro: LaTeX के लिए कुछ ऑनलाइन कंपाइलर हैं, उदाहरण के लिए अद्यतन उत्तर देखें।

— हाइको ओबेरडिएक

यह भयावह है, Heiko। +1! XD

— सीन एलेड

Answer 11

सी - 65

r,t,i;s(n){for(;++i;)for(t=n;t;t/=10)r=t%10-i?r:10*r+i;return r;}

आश्चर्यजनक पर्यवेक्षक ध्यान दें कि यह छँटाई एल्गोरिथ्म O (n) समय में अंकों की संख्या पर चलता है n।

व्यावहारिक पर्यवेक्षक नोट करेगा कि यह छँटाई एल्गोरिथ्म समय पर प्लेटफ़ॉर्म पर हस्ताक्षर किए गए पूर्णांकों की सीमा के अनुपात में चलता है, कि यह वैश्विक स्थिति को उत्परिवर्तित करता है जिसे रनों के बीच फिर से आरंभ किया जाना चाहिए, और यह कि कई अन्य बलिदान संक्षिप्तता के पक्ष में किए गए हैं।

Ungolfed संस्करण बिल्कुल समतुल्य नहीं है, लेकिन इसमें शामिल वास्तविक एल्गोरिदम को बेहतर तरीके से व्यक्त करता है।

int s(int n)
{
    int r = 0;
    int t;
    int i;
    for(i = 0; i < 10; i++)
    {
        for(t = n; t != 0; t /= 10)
        {
            if(t % 10 == i)
            {
                r = 10 * r + i;
            }
        }
    }
    return r;
}

यहाँ समारोह के लिए एक परीक्षण हार्नेस है:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
    if(argc != 2) return 1;
    printf("%d\n", s(atoi(argv[1])));
    return 0;
}

Answer 12

हास्केल - 96

96 वर्ण, कोई सरणियाँ, कोई तार, कोई पूर्णांक सीमा नहीं, उलट नहीं कर सकता

d=(`divMod`10)
a&(0,0)=a
a&(y,z)=(z%d a)&d y
a%(y,z)|z>a=10*(a%d y)+z|1<3=100*y+10*z+a
s=(0&).d

उदाहरण:

λ: s 52146729
12245679
λ: s 502010406072952146729521467295214672952146729
1111122222222224444455555666667777799999
λ: s 100
1

यह एक प्रविष्टि प्रकार है, जो सीधे पूर्णांक पर किया जाता है। यह अन्य हास्केल प्रविष्टि के समान है जो बबल सॉर्ट है, हालांकि मैं कसम खाता हूं कि मैं इसे देखने से पहले इस पर काम कर रहा था।

संक्षिप्त गाइड:

• dइकाइयों और दसियों में एक संख्या को विभाजित करता है, अर्थात: d 135जोड़ी है(13,5)
• a%xaसंख्या में अंकों की प्रविष्टि को क्रमबद्ध किया जाता हैx
• a&xxइकाइयों में अंकों को सम्मिलित करके aऔर परिणाम और शेष पर आवर्ती करके सॉर्ट करें
• s xसॉर्ट x &को 0 पर और पुनरावृत्ति को बंद करकेx

चाल यह है कि दूसरा तर्क %और सीधे &नहीं xहै, लेकिन xdivMod'd का उपयोग कर रहा हैd

Comments

अच्छा लगा। मैं infix के उपयोग के बारे में भूल गया हूँ। मैं शायद इस तरह से कुछ चार दाढ़ी काट सकता हूं, लेकिन आपने मुझे हरा दिया है। +1

— बाज़रघ

Answer 13

पायथन 3.3 61 अंक

print(''.join(sorted(input())))

यह प्रोग्राम इनपुट में एक स्ट्रिंग के रूप में लेता है, जो एक स्ट्रिंग के रूप में गिना जाता है क्योंकि इसे तुरंत एक पूर्णांक में नहीं बदला जाता है। +10

स्ट्रिंग को एक सरणी +10 में सॉर्ट किया जाता है

यह सरणी एक स्ट्रिंग +10 में एक साथ जुड़ जाती है

नोट:'' सरणी की सामग्री को शामिल होने के लिए इस्तेमाल किया एक बहु चरित्र स्ट्रिंग है, तो 10 के स्कोर में नहीं जोड़ा जाता है नहीं है।

कार्यक्रम में 31 वर्ण होते हैं। +31

31 + 10 + 10 + 10 = 61 अंक

Comments

+1 हालांकि आपके द्वारा संसाधित की जाने वाली डेटा संख्या कभी नहीं होती है । (यह ऐसा एकमात्र उत्तर नहीं है, मुझे पता है।)

— कोजिरो

यह स्पष्ट रूप से नहीं कहा गया है, हालांकि ऐसा कहा जाता है। मेरा मूल कोड था print(int(''.join(sorted(input())))), लेकिन पूर्णांक के लिए कलाकारों ने केवल अंक जोड़े और कोड को नियमों का पालन नहीं किया। मुझे लगता है मैं सच में चुनौती के लिए सच नहीं था। लेकिन वह बताता है कि इनपुट एक स्ट्रिंग हो सकता है, और आउटपुट एक स्ट्रिंग हो सकता है (प्रिंट स्टेटमेंट के लिए), और बीच में कुछ भी नहीं कहता है:]]

— erdekhayser

Answer 14

जे, 10 अक्षर (+ 1 स्ट्रिंग) स्कोर = २०

s=./:~&.":

उपयोग:

   s 52146729
12245679

सभी 32 बिट संख्या के लिए काम करता है।

स्पष्टीकरण:

/:~प्रारूप के &.तहत क्रमबद्ध करें ":। मेरे पिछले संस्करण ने एक सरणी का उपयोग किया, लेकिन वे महंगे हैं इसलिए अब मुझे केवल एक स्ट्रिंग का उपयोग करने और वर्णों को वर्णानुक्रम में सॉर्ट करने की आवश्यकता है। ":वह संख्या जो इनपुट को एक स्ट्रिंग में परिवर्तित करता है और /:~अंकों को आरोही क्रम में क्रमबद्ध करता है। क्योंकि सॉर्ट 'फॉर्म' के तहत किया जाता है, जब सॉर्ट खत्म हो जाता है, तो स्ट्रिंग वापस एक नंबर में बदल जाती है। रिवर्स करने की क्षमता को जोड़ने से शायद इससे अधिक खर्च होता है, इसलिए मैं परेशान नहीं हुआ।

यह तर्क दिया जा सकता है कि चूंकि एपी और के जैसे जे, एक सरणी-आधारित भाषा है, इसलिए एकल इनपुट 1 आइटम की एक सरणी है, लेकिन मैंने अपने स्कोर की गणना करते समय ऐसा कठोर दृश्य नहीं चुना।

32-बिट सीमा मेरे कार्यक्रम के बजाय J द्वारा लगाई गई है। कोई भी उच्च और जम्मू संख्या को वैज्ञानिक संकेतन में बदल देता है। यह इस सवाल से स्पष्ट नहीं है कि इस मामले में 32 अंक जुर्माना लागू होता है, लेकिन भले ही दोनों पिछले जुर्माना लागू होते हैं (मुझे नहीं लगता कि उन्हें चाहिए) स्कोर 72 तक जाता है और अभी भी आराम से दूसरे के विशाल बहुमत को मारता है जवाब।

Comments

क्या आप एक स्पष्टीकरण प्रदान कर सकते हैं? ऐसा लगता है कि यह एक स्ट्रिंग के रूप में संख्या को प्रारूपित कर रहा है, एक सरणी में विभाजित कर रहा है, सरणी को सॉर्ट कर रहा है, फिर इसे स्ट्रिंग के रूप में सुधार कर रहा है ... क्या सरणी और स्ट्रिंग के लिए दंड नहीं हैं?

— bazzargh

@bazzargh मैंने जानबूझकर स्कोर घोषित नहीं किया जब मैंने दो कारणों से अपना जवाब प्रस्तुत किया: 1) यह टैग किया गया है [कोड-गोल्फ] तो बोनस वास्तव में समझ में नहीं आता है, और 2) यह मेरे लिए स्पष्ट नहीं था जो लागू होगा । मैं एक स्पष्टीकरण जोड़ दूँगा।

— गारेथ

मुझे किस टैग का उपयोग करना चाहिए था? यह दंड के साथ कोड गोल्फ है ...

— kojiro

@ कोकोजी - कोड-गोल्फ टैग पर माउस यह आपको बताता है - कोड-चुनौती।

— २०:३

Answer 15

पायथन 2.7: 174

import math
i=input()
d={n:0for n in xrange(10)}
for n in(i/10**c%10for c in xrange(1+math.log10(i))):d[n]+=1
print"".join(str(n)for n in xrange(10)for c in xrange(d[n]))

• इसके बजाय कोई सरणियाँ (पुनरावृत्तियों और एक शब्दकोश का उपयोग किया जाता है)
• कोई मल्टी-कैरेक्टर स्ट्रिंग्स (आउटपुट को छोड़कर)
• अंकों की कोई कृत्रिम अधिकतम संख्या नहीं
• कोई उलटा नहीं

यह सभी 10 अंकों की मैपिंग को 0. से शब्दकोश बनाने के द्वारा काम करता है। फिर यह संख्या की लंबाई ( log10(i)), प्रत्येक अंक ( (i / (10 ** c)) % 10) को निकालता है , और शब्दकोश में उस अंक के लिए काउंटर को बढ़ाता है। अंत में यह सभी 10 अंकों पर पुनरावृत्ति करके बनाया गया एक स्ट्रिंग बनाता है, और प्रत्येक अंक के लिए एक स्ट्रिंग के रूप में अंक का एक उदाहरण उपज होता है।

मैं अंतिम पंक्ति को बदल सकता था print"".join(d[n]*str(n)for n in xrange(10))जिसमें 16 अक्षर कम होंगे, लेकिन बहु-वर्ण स्ट्रिंग्स का उपयोग करेंगे।

Comments

i=int(input())बस के i=input()रूप input()में संख्या स्वचालित रूप से हो सकता है ।

— user80551

@ user80551: हां, बिल्कुल! अच्छा निर्णय।

— गाबे

Answer 16

C (C90 तक) या C ++, 78 66 अंक

एक पूर्णांक को सॉर्ट करने वाले फ़ंक्शन को कहा जाता है s।

s(i){t=10,a=i?s(i/t):0,b=i%t,c=a%t;return c>b?t*s(a-c+b)+c:t*a+b;}

स्कोरिंग:

• 66 वर्ण (+66)
• 0 सरणियाँ (+0)
• 0 स्ट्रिंग्स (+0)
• मशीन द्वारा परिभाषित सीमा (आकार int) (+0)
• केवल एक छँटाई दिशा (-0)

पुराना संस्करण (78 अंक, C ++ और अधिक आधुनिक C संस्करणों के साथ भी काम करता है)

int s(int i){int t=10,a=i?s(i/t):0,b=i%t,c=a%t;return c>b?t*s(a-c+b)+c:t*a+b;}

Answer 17

सी # - 179

using System.Linq;class S{void Main(string[] a){Console.Write(string.Concat(string.Concat(a).Replace("-","").OrderBy(o=>a[0].Contains('-')?-o:o)));}}

संयुक्त राष्ट्र के golfed

using System.Linq;

class S
{
    void Main(string[] a)
    {
        Console.Write(string.Concat( 
            string.Concat(a)
                .Replace("-", "")
                .OrderBy(o => a[0].Contains('-') ? -o : o )));
    }
}

परीक्षा

सामान्य:

app.exe 52313698

उलट:

app.exe 52313698-

बिंदु: (मुझे आशा है कि मैंने बिंदु प्रणाली को ठीक से समझ लिया है - सही करने के लिए स्वतंत्र महसूस करता हूं)

• शुल्क: 149
• स्ट्रिंग्स: 10 + 10
• एरर्स: +20
• क्रम: -10
• कुल: 149 + 10 + 20-10 = 179

---

LINQPAD के साथ C # - 123

void Main(string[] a){Console.Write(string.Concat(string.Concat(a).Replace("-","").OrderBy(o=>a[0].Contains('-')?-o:o)));}

परीक्षा

सामान्य:

lprun.exe sorta.linq 52313698

उलट:

lprun.exe sorta.linq 52313698-

अंक:

• शुल्क: 122
• स्ट्रिंग्स: 10 + 10
• एरर्स: +20
• क्रम: -10
• कुल: 122 + 10 + 20-10 = 152

Answer 18

जावा 1469

जावा में एक स्ट्रिंग और सरणी मुक्त समाधान। 1437 वर्ण + 32 क्योंकि यह केवल इनपुट के रूप में Long.MAX_VALUE तक लेता है। डबल का उपयोग करके मैं इसके बजाय 300 से अधिक अंकों तक जा सकता हूं लेकिन यह लागू करने के लिए बहुत थकाऊ होगा। इससे बड़ा कुछ भी बिगइंटर और AFAIK की आवश्यकता होगी जो आंतरिक रूप से सरणियों का उपयोग करता है। यदि आप इनपुट के लिए 19 से कम अंकों का उपयोग करते हैं तो आउटपुट में अग्रणी शून्य होंगे। नकारात्मक इनपुट सभी शून्य देगा और कुछ भी नहीं एक संख्या एक अपवाद का कारण बनेगी।

जिस तरह से मैंने सबसे आसान इस्तेमाल किया उसके बारे में सोच सकता हूं इसलिए यह काफी अक्षम है। (ओ होना चाहिए (n * n))

input:  9212458743185751943
output: 1112233444555778899

मुझे पता है कि यह वास्तव में अन्य भाषाओं में समाधान की तुलना नहीं करता है, लेकिन मुझे लगता है कि यह कम से कम मैं इसे जावा में प्राप्त कर सकता हूं। (अगर किसी को पता है कि यह कैसे भी कम / संपादित करने के लिए स्वतंत्र महसूस करने के लिए)

class D
{
    long c,d,e,f,g,h,k,l,m,n,o,p,q,r,s,t,u,v,w;
    long x;

    public D(Long a)
    {
        x = a;
        c = g();
        d = g();
        e = g();
        f = g();
        g = g();
        h = g();
        k = g();
        l = g();
        m = g();
        n = g();
        o = g();
        p = g();
        q = g();
        r = g();
        s = g();
        t = g();
        u = g();
        v = g();
        w = g();
        int i=0;
        while(i++ < 19) s();
        System.out.printf("%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d",c,d,e,f,g,h,k,l,m,n,o,p,q,r,s,t,u,v,w);
    }

    long g()
    {
        if( x <= 0 ) return 0;
        long b = x % 10;
        x = x / 10; 
        return b;
    }

    void s()
    {
        if(c > d) {c += d; d = c - d; c -= d;}
        if(d > e) {d += e; e = d - e; d -= e;}
        if(e > f) {e += f; f = e - f; e -= f;}
        if(f > g) {f += g; g = f - g; f -= g;}
        if(g > h) {g += h; h = g - h; g -= h;}
        if(h > k) {h += k; k = h - k; h -= k;}
        if(k > l) {k += l; l = k - l; k -= l;}
        if(l > m) {l += m; m = l - m; l -= m;}
        if(m > n) {m += n; n = m - n; m -= n;}
        if(n > o) {n += o; o = n - o; n -= o;}
        if(o > p) {o += p; p = o - p; o -= p;}
        if(p > q) {p += q; q = p - q; p -= q;}
        if(q > r) {q += r; r = q - r; q -= r;}
        if(r > s) {r += s; s = r - s; r -= s;}
        if(s > t) {s += t; t = s - t; s -= t;}
        if(t > u) {t += u; u = t - u; t -= u;}
        if(u > v) {u += v; v = u - v; u -= v;}
        if(v > w) {v += w; w = v - w; v -= w;}
    }

    public static void main(String[] y)
    {
        D d = new D(Long.parseLong(y[0]));
    }
}

Answer 19

AWK - 101

'X' फ़ाइल:

BEGIN{n=ARGV[1]
r=ARGV[2]
for(d=r;d<10;d++)for(p=1;p<=length(n);p++){D=r?d:9-d
if(D==substr(n,p,1))printf D}print}

दौड़:

$ awk -f x 52146729
97654221
$ awk -f x 52146729 0
97654221
$ awk -f x 52146729 1
12245679
$ awk -f x 1234567890123456789012345678901234567890
9999888877776666555544443333222211110000
$ awk -f x 1234567890123456789012345678901234567890 1
111122223333444455556666777788889999

उपयोग किया गया एकमात्र सरणी ARGV है और यह सॉर्ट करने में कोई मदद नहीं करता है, यह केवल कमांडलाइन मापदंडों तक पहुंच है और ये मान गैर-सरणी चर में हैं जहां वास्तव में गणना के लिए आवश्यक है। मुझे लगता है कि यह इस समाधान के खिलाफ नहीं गिना जाएगा। निम्नलिखित गणना ARGV- सरणी को ध्यान में नहीं रखती है:

111 (वर्ण) - 10 (रिवर्स कर सकते हैं)

Comments

कभी-कभी एक पागल दुनिया के लिए एकमात्र पागल जवाब पागलपन है। - फॉक्स मुल्डर

— कोजिरो

:- डी एक्ट! :-D

Answer 20

मुझे प्रश्न में कार्यों को छाँटने के बारे में कुछ भी दिखाई नहीं देता है, इसलिए ... (यदि मैं झुकता हूं या नियमों को तोड़ता हूं, तो मुझे जवाब हटा देना चाहिए)

जावास्क्रिप्ट 56 96

function s(){alert(+prompt().split('').sort().join(''))}

जावास्क्रिप्ट 69 109 (प्रतिवर्ती)

function s(r){x=prompt().split('').sort();x=r?x.reverse():x;alert(+x.join(''))}

EcmaScript 6 एरो फ़ंक्शंस का उपयोग करके थोड़ा नीचे गोल्फ किया जा सकता है :

ईएस 6 50 90

s=()=>{alert(+prompt().split('').sort().join(''))}

ES6 63 103 (प्रतिवर्ती) (73-10)

s=(r)=>{x=prompt().split('').sort();x=r?x.reverse():x;alert(+x.join(''))}

Comments

promptएक स्ट्रिंग लौटाता है (कि आप तुरंत पूर्णांक में परिवर्तित नहीं होते हैं): +10; splitएक सरणी देता है: +20; sortइन-प्लेस सॉर्ट करता है (इसलिए यह अभी भी वही एरे है); joinएक नया स्ट्रिंग देता है, +10। कुल: 96.

— कोजिरो

नियमों को कैसे लिखा जाता है, इससे मुझे समझ में आया कि केवल शाब्दिक गणना की गई थी। वैसे भी स्कोर को अपडेट करना।

— निकोलो कैम्पोलुंगो

Answer 21

SED 67 शुल्क (स्कोर 67 या 107)

s/$/;0123456789/;:a;s/\(.\)\(.\)\(.*;.*\2.*\1\)/\2\1\3/;ta;s/;.*//;

यह संक्षिप्तता के लिए एक बुलबुला प्रकार का उपयोग करता है। यदि प्रत्येक नियमित अभिव्यक्ति पैटर्न और एक स्ट्रिंग के रूप में प्रतिस्थापन की गिनती (यानी 67 + (10 * 4)) स्कोर 107 होगा

स्मृति द्वारा सीमित अंकों की संख्या (और शायद धैर्य)

Answer 22

पायथन लैम्बडा फ़ंक्शन (प्रतिवर्ती), 69

lambda n,d:''.join(sorted(n,reverse=d))

• 39 वर्ण (+39)
• दो बहु-चार तार: n(इनपुट) और ''.join(...) (+20)
• एक सूची: sorted(...) (+20)
• पैरामीटर (-10) के आधार पर दिशा को उल्टा कर सकते हैंd

---

पायथन लैम्बडा फ़ंक्शन (गैर-प्रतिवर्ती), 67

lambda n:''.join(sorted(n))

---

EDIT: इनपुट एक स्ट्रिंग होना चाहिए। मैं सीधे उस स्ट्रिंग का उपयोग करने के दंड पर विचार कर रहा हूं।

Comments

मैंने खेल को थोड़ा ऊपर स्पष्ट किया, विशेष रूप से अंतर्निहित रूपों का उपयोग करने के बारे में। एक जनरेटर ठीक हो सकता है, लेकिन पायथन मदद (2 और 3 दोनों के लिए) स्पष्ट रूप से बताता है raw_input([prompt]) -> string, इसलिए sorted(raw_input())+10 है। इसके अलावा sorted -> new sorted list, इसलिए +20। फिर, S.join -> stringइसलिए +10 फिर से। स्लाइस नोटेशन से तार भी निकलता है, इसलिए +10 (स्लाइस नोटेशन का समर्थन करने वाले कुछ और भी +20 होगा)। इसलिए मैं क्रमशः 73 और 108 की गणना करता हूं।

— कोजिरो

@kojiro कृपया स्पष्ट करें: क्या मैं एक फ़ंक्शन का उपयोग कर सकता हूं जो संख्या के स्ट्रिंग को तर्क के रूप में लेता है (मैं जुर्माना स्वीकार करता हूं)। क्या मैं एक फ़ंक्शन का उपयोग कर सकता हूं printजो returnआईएनजी के बजाय है ?

— user80551

कृपया देखें नोट 4. (हालांकि एक विशिष्ट नोट पर, मैं उत्सुक हूं कि आपने lambdaयहां क्यों इस्तेमाल नहीं किया ।)

— kojiro

@kojiro प्रिंट / रिटर्न के बारे में मेरा मुख्य मुद्दा printछोटा है और इसमें रैपर की आवश्यकता नहीं है। मुझे नहीं पता था कि आप लैम्ब्डा कार्यों की अनुमति देंगे। जब मैंने पढ़ा कि चेहरे की तरह। क्या यह अब सही है?

— 1580 पर user80551

''.join(sorted(str(n))).क्या आप मुझे बताएं कि इसे उत्तर के रूप में क्यों नहीं माना जाएगा? मैं नया हूँ

— आलोक

Answer 23

आम लिस्प - 126

(defun s(n p)(labels((a(n)(if(= 0 n)()(cons(mod n 10)(a (floor n 10)))))(b(a)(if(null a)0(+(car a)(* 10(b(cdr a)))))))(b(sort(a n) p))))

Ungolfified (स्टाइलिस्ट के साथ-साथ लेक्सिकली, लेकिन कार्यात्मक रूप से समान) संस्करण:

(defun sorta (n p)
  (labels ((digits (n)
             (unless (zerop n)
               (multiple-value-bind (quotient remainder)
                   (truncate n 10)
                 (cons remainder (digits quotient)))))
           (digit-cat (digits)
             (if (null digits)
                 0
               (+ (car digits)
                  (* 10 (digit-cat (cdr digits)))))))
    (digit-cat (sort (digits n) p))))

एक ऋणात्मक संख्या के अंकों को ऋणात्मक मान के रूप में माना जाता है, और अंकों को कम से कम महत्वपूर्ण-प्रथम (यानी, छोटे-से-अंत वाले) क्रमबद्ध किया जाता है। उदाहरण:

CL-USER> (sorta 1234 #'<)
=> 4321
CL-USER> (sorta 12344321 #'<)
=> 44332211
CL-USER> (sorta 12344321 #'>)
=> 11223344
CL-USER> (sorta -12344321 #'>)
=> -44332211
CL-USER> (sorta 0 #'>)
=> 0
CL-USER> (sorta 8675309 #'<)
=> 9876530

गोल्फ संस्करण में व्हॉट्सएप सहित 136 अक्षर हैं। यह कोई तार और कोई सरणियों का उपयोग नहीं करता है, और नकारात्मक पूर्णांक सहित, मनमाना-सटीक पूर्णांक संभालता है। छंटाई एक द्विआधारी विधेय जिसमें पूर्णांकों पर कुल आदेश को परिभाषित करता है पर parameterized है [-9, 9], सहित, लेकिन तक सीमित नहीं <है और >:

CL-USER> (sorta 3546219870 (lambda (a b)
                             (cond ((and (evenp a)
                                         (oddp b))
                                    t)
                                   ((and (evenp b)
                                         (oddp a))
                                    nil)
                                   (t
                                    (< a b)))))
=> 9753186420

इससे स्कोर 126 हो गया।

Answer 24

जावास्क्रिप्ट 416/185

कोई Arrays, कोई स्ट्रिंग्स, कोई मनमाना लंबाई बाधा नहीं ...

लेकिन छँटाई / नीचे 10 से अधिक वर्णों का उपयोग किया जाता है ^ ^ लेकिन मैंने अंकों को गिनने और उन्हें दिलचस्प प्रिंट करने का विचार पाया - शायद कोई इस विचार का उपयोग गोल्फस्क्रिप्ट में कर सकता है और पुरस्कार जीत सकता है ;-)

var x=window.prompt(),y=0,z=0,a=0,b=0,c=0,d=0,e=0,f=0,g=0,h=0,i=0,j=0;
do
{
    z=x%10;
    x=(x-z)/10;
    if(!z)a++;
    if(z==1)b++;
    if(z==2)c++;
    if(z==3)d++;
    if(z==4)e++;
    if(z==5)f++;
    if(z==6)g++;
    if(z==7)h++;
    if(z==8)i++;
    if(z==9)j++;
}while(x);

while(a--)y=y*10;
while(b--)y=y*10+1;
while(c--)y=y*10+2;
while(d--)y=y*10+3;
while(e--)y=y*10+4;
while(f--)y=y*10+5;
while(g--)y=y*10+6;
while(h--)y=y*10+7;
while(i--)y=y*10+8;
while(j--)y=y*10+9;

alert(y);

एक ही कोड छोटा है, जो eval का उपयोग कर रहा है: (लेकिन संभवतः स्ट्रिंग का उपयोग करने पर विचार किया जाएगा ...)

var i = window.prompt(),o=0,i0=0,i1=0,i2=0,i3=0,i4=0,i5=0,i6=0,i7=0,i8=0,i9=0;
do
{
    eval("i"+i%10+"++");
    i = ~~(i/10);
} while (i > 0)

for(var j=0;j<10;j++) while (eval("i"+j+"--")>0) o = o*10+j;

alert(o);

Comments

आप iN के बजाय 1-वर्ण नामों का उपयोग करके 30 बाइट्स द्वारा लंबे संस्करण को छोटा कर सकते हैं।

— ग्लेन रैंडर्स-पीरसन

@ GlennRanders-Pehrson धन्यवाद :-)

— फाल्को

सभी अर्धविराम क्यों? और कौन इंडेंट करने की परवाह करता है?

— कैलक्यूलेटरफलाइन

Answer 25

सी (222)

static int a[10],r=1;o(n,c){while(n--)printf("%""i",c);}p(){int n;for(n=r<0?9:0;n>=0&&n<10;n+=r)o(a[n],n);}main(int _,char**v){char*s=v[1];if(*s=='-'){r=-1;++s;}do++a[*s-'0'];while(*++s);p();}

अंक:

• 192 (192 शुल्क)
• 40 (2 सारणियां: argv (v) और a)
• 0 (कोई बहु चार तार)
• 0 (यह n अंकों तक सीमित नहीं है)

• -10 (प्रकार रिवर्स यदि संख्या (argv [1]) नकारात्मक है)

  = 222 अंक

1000 संकलक चेतावनियों से छुटकारा पाने के लिए जरूरी झंडे: gcc -Wno-implicit-function-declaration -Wno-return-type -Wno-implicit-int -Wno-char-subscripts -o count2 counta2.c

"बेहतर" पठनीय:

static int a[10],r=1;
o(n,c){while(n--)printf("%""i",c);}
p(){int n;for(n=r<0?9:0;n>=0&&n<10;n+=r)o(a[n],n);}
main(int _,char**v){char*s=v[1];if(*s=='-'){r=-1;++s;}do++a[*s-'0'];while(*++s);p();}

कुछ हद तक असंयमी:

static int a[10],r=1;
o(n,c){
    while(n--) printf("%""i",c);
}
p(){
    int n;
    for(n=r<0?9:0;n>=0&&n<10;n+=r) o(a[n],n);
}
main(int _,char**v){
    char*s=v[1];
    if(*s=='-'){
        r=-1;
        ++s;
    }
    do ++a[*s-'0']; while(*++s);
    p();
}

Comments

के "%""i"बजाय का उपयोग क्यों करें "%i"? वे एक ही चीज को संकलित करते हैं, इसलिए आप केवल दो वर्णों को बर्बाद कर रहे हैं।

— गाबे

@Gabe हाँ मैं 2 चार्ज बर्बाद कर रहा हूँ, लेकिन "% i" एक "मल्टी चार स्ट्रिंग" (10 पॉइंट) है जहाँ "%" "i" नहीं है ... कम से कम लोगों ने यहाँ बहस की है ...

— मैक्स। हरिओम

Answer 26

वहाँ एक कारण है कि मैं इस समाधान पहले से ही नहीं देख रहा हूँ?

माणिक

pry(main)> 52146729.to_s.split("").sort.join.to_i
=> 12245679

यकीन नहीं है कि यह कैसे स्कोर किया जाए। बंटवारा एक सरणी उत्पन्न करेगा, लेकिन इससे परे निश्चित नहीं .. सरणियों के लिए 38 वर्ण + 2x20? या क्या इसमें सभी सरणियों को शामिल किया जाना चाहिए जो आंतरिक रूप से बना सकते हैं?

Answer 27

VBScript - 76 (96?)

x = "7892347684578892348025023389054859034234"

for i=0 to 9:n=n&string(len(x)-len(replace(x,i,"")),""&i):next:x=n

' x -> 00002222233333344444455556777888888889999

स्ट्रिंग के उपयोग के लिए ६६ वर्ण + १० n
(पता नहीं कि वर्ण x की मात्रा को रिटर्न करने वाले replaceफ़ंक्शन और stringफ़ंक्शन का उपयोग अतिरिक्त स्ट्रिंग के रूप में गिना जाता है)।

यह मूल स्ट्रिंग की लंबाई की तुलना उसी स्ट्रिंग के साथ मूल स्ट्रिंग की लंबाई के साथ करता है, जो कुछ अंकों को प्रतिस्थापित करता है। फिर यह उस राशि को n में संलग्न करता है।

Answer 28

पायथन 3 स्लीपसॉर्ट (168)

बिल्कुल कोई सूची या लूप के साथ, केवल जनरेटर।

import math, threading
n=input()
if any(threading.Timer(x,lambda x:print(x,end='',flush=1),(x,)).start()for x in(n//10**i%10for i in range(math.log10(n)//1+1))):pass

शायद सुधारा जा सकता था।

Answer 29

रैकेट 97

97 अंक (87 +20 दो तार के लिए, -10 छँटाई के लिए, कोई सरणियाँ)

(define(s n <)(string->number(list->string(sort(string->list(number->string n))<))))

यह चरों की सूचियों का उपयोग करता है, इसलिए आपको इसे एक तुलनात्मक कार्य की तरह देने की आवश्यकता है जैसे char<?या char>?। मुझे लगता है कि यह भी ungolfed के रूप में गुजरता है क्योंकि यह रिक्त स्थान जोड़ने और चर नाम बढ़ाने के लिए बहुत कुछ नहीं है। मेरा पुराना संस्करण शायद अधिक सम्मानजनक है :)

पुराने तार के बिना संस्करण:

110 अंक (120 बाइट्स (utf-8) - 10 प्रकार क्रम बदलने के लिए अनुमति देने के लिए। यह कोई तार और कोई सरणियों का उपयोग करता है)

(define(S d <)(foldl(λ(x a)(+(* a 10)x))0(sort(let L((l'())(
d d))(if(= d 0)l(L(cons(modulo d 10)l)(quotient d 10))))<)))

Ungolfed:

(define (number-digit-sort number <)
  (foldl (λ (x a) (+ (* a 10) x))
         0
         (sort (let loop ((acc '()) (number number))
                 (if (= number 0)
                     acc
                     (loop (cons (modulo number 10) acc)
                           (quotient number 10))))
               <)))

मैंने 1,00,000 वीं रिटेल संख्या के साथ इसका परीक्षण किया:

(number-digit-sort (fibonacci 100000) <)
;==> 1111... basically it's the digits:
; 1 2135 times
; 2 2149 times
; 3 2096 times
; 4 2023 times
; 5 2053 times
; 6 2051 times
; 7 2034 times
; 8 2131 times
; 9 2118 times

और विपरीत क्रम में समान:

(number-digit-sort (fibonacci 100000) >)
; ==> 999... and the digest is
; 9 2118 times
; 8 2131 times
; 7 2034 times
; 6 2051 times
; 5 2053 times
; 4 2023 times
; 3 2096 times
; 2 2149 times
; 1 2135 times
; 0 2109 times