एक सकारात्मक पूर्णांक को उलटने के लिए सबसे रचनात्मक तरीका [बंद]

Question

अहस्ताक्षरित पूर्णांक के रूप में एक इनपुट प्रदान किया:

13457

आपका फ़ंक्शन / सबरूटीन वापस आ जाना चाहिए:

75431

चूंकि यह एक लोकप्रियता प्रतियोगिता है, रचनात्मक हो। रचनात्मक समाधान दिए गए कार्य को पूरा करने के लिए असामान्य या चतुर तकनीकों का उपयोग करते हैं।

प्रतिबंध:

• आप सरणियों का उपयोग नहीं कर सकते।
• आप तार का उपयोग नहीं कर सकते।
• कोई RTL ओवरराइड ( &#8238)

ब्राउनी रचनात्मक अंकगणित का उपयोग करने के लिए इंगित करता है।

चूंकि यह एक लोकप्रियता प्रतियोगिता है, मैं सुझाव देता हूं कि %आपके कोड में मोडुलो ( ) ऑपरेटर का उपयोग न करें।

अग्रणी शून्य के बारे में:

यदि इनपुट है:

12340

फिर उत्पादन:

4321

स्वीकार्य होगा।

Comments

क्या यह codegolf.stackexchange.com/questions/2823/… का डुप्लिकेट है ?

— माइक्रोबियन

@microbian नहीं, वह एक कोड-गोल्फ था। यह एक लोकप्रियता-प्रतियोगिता है।

— विक्टर स्टैफुसा

यदि आप अब नियम बदलना शुरू करेंगे तो लोगों को गुदगुदी होगी। यह मुझे ठीक लग रहा है, बस अपनी अगली चुनौती को सैंडबॉक्स के माध्यम से पहले चलाएं

— होशे 250

यदि 1230इनपुट है तो क्या होगा ? क्या हमें आउटपुट की अनुमति है 321? (अन्यथा, स्ट्रिंग्स आवश्यक हैं)।

— जस्टिन

मैं इसे ऑफ-टॉपिक के रूप में बंद करने के लिए मतदान कर रहा हूं क्योंकि इसमें एक उद्देश्य वैधता मानदंड का अभाव है - "रचनात्मक होना" व्यक्तिपरक है।

— मेगो

Answer 1

गणितज्ञ, कोई मोडुलो नहीं!

n = 14627;
length = Ceiling[Log[10, n]];
img = Rasterize[n, RasterSize -> 400, ImageSize -> 400];
box = Rasterize[n, "BoundingBox", RasterSize -> 400, ImageSize -> 400];
width = box[[1]]; height = box[[3]];
ToExpression[
 TextRecognize[
  ImageAssemble[
   ImageTake[img, {1, height}, #] & /@ 
    NestList[# - width/length &, {width - width/length, width}, 
     length - 1]]]]

चलो इसे तोड़ दो।

पहले हम संख्या में कितने अंक हैं, यह पता लगाने के लिए कुछ "रचनात्मक अंकगणित" का उपयोग करते हैं: length = Ceiling[Log[10, n]];

अगला, हम एक अच्छी बड़ी छवि के लिए संख्या को व्यवस्थित करते हैं:

अब हम उस छवि के बाउंडिंग बॉक्स के लिए क्वेरी करते हैं, और चौड़ाई और ऊंचाई (वास्तव में छवि ऊंचाई के बजाय बेसलाइन ऑफसेट का उपयोग करके पॉप्युलेट करते हैं, क्योंकि एमएम छवि में आधार रेखा के नीचे कुछ व्हाट्सएप जोड़ता है)।

अगला, NestList एक के बाद एक करके इमेज के अंत से प्लकर के पात्रों को सक्षम करने के लिए स्ट्रिंग की लंबाई से विभाजित छवि की चौड़ाई को घटाता है, और वे इस इमेज के लिए इमेजएम्स् द्वारा पुनः एकत्रित किए जाते हैं:

फिर हम ऑप्टिकल कैरेक्टर रिकग्निशन के लिए TextRecognize फंक्शन पर पास होते हैं, जो इस इमेज साइज और रैस्टिरेशन क्वालिटी पर अंतिम आउटपुट को पहचान कर हमें पूर्णांक देने में सक्षम है:

72641

लॉगरिथम और ओसीआर - यह चॉकलेट और पीनट बटर की तरह है!

नया और बेहतर

यह संस्करण छोटी संख्या के साथ TextRecognize के अड़ियल व्यवहार से निपटने के लिए नंबर को पैड करता है, और फिर अंत में पैड को घटाता है। यह भी एकल अंकों की संख्या के लिए काम करता है!

हालाँकि, आप एक ही नंबर पर रिवर्स रूटीन क्यों चलाएंगे यह मेरे लिए एक रहस्य है। लेकिन सिर्फ पूर्णता के लिए, मैंने इसे शून्य और एक के इनपुट के लिए भी काम किया, जो सामान्य रूप से टूट जाएगा क्योंकि फ्लोर्ड लॉग उनके लिए 1 वापस नहीं करता है।

n = 1;
pad = 94949;
length = If[n == 1 || n == 0, 1, Ceiling[Log[10, n]]];
img = Rasterize[n + (pad*10^length), RasterSize -> 400, 
   ImageSize -> 400];
padlength = length + 5;
box = ImageDimensions[img];
width = box[[1]]; height = box[[2]];
reversed = 
  ImageResize[
   ImageAssemble[
    ImageTake[img, {1, height}, #] & /@ 
     NestList[# - width/padlength &, {width + 1 - width/padlength, 
       width}, padlength - 1]], 200];
recognized = ToExpression[TextRecognize[reversed]];
(recognized - pad)/10^5

Comments

मुझे इससे हराएं। आपको मेरा वोट मिल गया है !! [लेकिन मैं C # का उपयोग करने जा रहा था]

— HL-SDK

TextRegognizeछोटी संख्या के लिए काम नहीं कर रहा है। और आपके पास टाइपो है height = b[[3]];। कृपया मेरा उत्तर भी जांचें! :)

— बेंत की मार

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

— swish

टाइपो को हाजिर करने के लिए धन्यवाद ... मैं प्रस्तुत करने से पहले चर नामों को अधिक पाठक के अनुकूल बना रहा था और एक को याद किया। इसके अलावा लापता ToExpression में फेंक दिया। और मैंने एक संशोधन पोस्ट किया है जो छोटी संख्याओं के साथ एकल अंकों की समस्या को हल करता है।

— जोनाथन वान मैट्रे

वाह ... यह विस्तृत है!

— duci9y

Answer 2

पर्ल / LuaTeX / Tesseract

निम्न पर्ल स्क्रिप्ट संख्या को कमांड लाइन तर्क के रूप में पढ़ती है, जैसे:

    1234567890

निम्नलिखित पर्ल स्क्रिप्ट LuaTeX के माध्यम से संख्या को प्रिंट करती है। एक आभासी फ़ॉन्ट मक्खी पर बनाया जाता है जो क्षैतिज रूप से अंकों को प्रतिबिंबित करता है।

फिर पूरी संख्या फिर से क्षैतिज रूप से दिखाई देती है:

अंतिम छवि OCR (टेसरैक्ट) के माध्यम से फिर से तैयार की जाती है:

    0987654321

#!/usr/bin/env perl
use strict;
$^W=1;

# Get the number as program argument or use a fixed number with all digits.
$_ = shift // 1234567890;

$\="\n"; # append EOL, when printing

# Catch negative number
exit print "NaUI (Not an Unsigned Integer)" if $_ < 0;

# Catch number with one digit.
exit ! print if ($_ = $= = $_) < 10;

undef $\;

# Write TeX file for LuaTeX
open(OUT, '>', 'temp.tex') or die "!!! Error: Cannot write: $!\n";
print OUT<<"END_PRINT";
% Catcode setting for iniTeX (a TeX format is not needed)
\\catcode`\{=1
\\catcode`\}=2
\\def\\mynumber{$_}
END_PRINT
print OUT<<'END_PRINT';
\directlua{tex.enableprimitives('',tex.extraprimitives())}
\pdfoutput=1 % PDF output
% move origin to (0,0)
\pdfhorigin=0bp
\pdfvorigin=0bp
% magnify the result by 5
\mag=5000

% Create virtual font, where the digits are mirrored
\directlua{
  callback.register('define_font',
    function (name,size)
      if name == 'cmtt10-digits' then
        f = font.read_tfm('cmtt10',size)
        f.name = 'cmtt10-digits'
        f.type = 'virtual'
        f.fonts = {{ name = 'cmtt10', size = size }}
        for i,v in pairs(f.characters) do
          if (string.char(i)):find('[1234567890]') then
            v.commands = {
               {'right',f.characters[i].width},
               {'special','pdf: q -1 0 0 1 0 0 cm'},
               {'char',i},
               {'right',-f.characters[i].width},
               {'special','pdf: Q'},
            }
          else
            v.commands = {{'char',i}}
          end
        end
      else
        f = font.read_tfm(name,size)
      end
      return f
    end
  )
}

% Activate the new font
\font\myfont=cmtt10-digits\relax
\myfont

% Put the number in a box and add a margin (for tesseract)
\dimen0=5bp % margin
\setbox0=\hbox{\kern\dimen0 \mynumber\kern\dimen0}
\ht0=\dimexpr\ht0+\dimen0\relax
\dp0=\dimexpr\dp0+\dimen0\relax
\pdfpagewidth=\wd0
\pdfpageheight=\dimexpr\ht0+\dp0\relax

% For illustration only: Print the number with the reflected digits:
\shipout\copy0 % print the number with the reflected digits

% Final version on page 2: Print the box with the number, again mirrored
\shipout\hbox{%
  \kern\wd0
  \pdfliteral{q -1 0 0 1 0 0 cm}%
  \copy0
  \pdfliteral{Q}%
}

% End job, no matter, whether iniTeX, plain TeX or LaTeX
\csname @@end\endcsname\end
END_PRINT

system "luatex --ini temp.tex >/dev/null";
system qw[convert temp.pdf temp%d.png];
system "tesseract temp1.png temp >/dev/null 2>&1";

# debug versions with output on console
#system "luatex --ini temp.tex";
#system qw[convert temp.pdf temp%d.png];
#system "tesseract temp1.png temp";

# Output the result, remove empty lines
open(IN, '<', 'temp.txt') or die "!!! Error: Cannot open: $!\n";
chomp, print while <IN>;
print "\n";
close(IN);

__END__

Comments

TeX के लिए +1। हमें और अधिक TeX उत्तर चाहिए!

— जोनाथन वान मैट्रे

Answer 3

Brainfuck

असल में, यह सिर्फ एक इनपुट-रिवर्सिंग प्रोग्राम है।

,[>,]<[.<]

UPD: जैसा कि सिलवेस्टर ने टिप्पणी में बताया, शास्त्रीय ब्रेनफॉक दुभाषियों / संकलक (मेमोरी सरणी में शून्य बिंदु से बाएं जाने की संभावना के बिना) यह कार्यक्रम शुरुआत में '>' की अनुपस्थिति में काम नहीं करेगा, इसलिए अधिक स्थिर संस्करण है:

>,[>,]<[.<]

Comments

सबसे छोटा बीएफ प्रोग्राम मैंने कभी देखा है। इसके अलावा, वास्तव में साफ है।

— नित

>डेटा के पहले शून्य सेल बनाने के लिए शुरुआत में बिना यह कई दुभाषियों / संकलक में काम नहीं करेगा।

— सिल्वेस्टर

@Danek सच है, सभी कोशिकाओं को शून्य से शुरू किया जाता है और पहली बात यह है कि आप पहले अंक को पहले सेल में पढ़ें। [.<]इसकी वजह से रोकने के लिए कोई शून्य सेल नहीं है और विफल हो जाएगा। से त्रुटि bf -n rev1.bfहै Error: Out of range! Youwanted to '<' below the first cell.। यदि आप संकलित करते हैं तो आप segfaultशायद प्राप्त करते हैं ।

— सिल्वेस्टर

+1 भी, भले ही बीएफ सभी सरणियों के बारे में है, इसलिए मुझे यकीन नहीं है कि यह नियम फिट बैठता है सरणी का उपयोग न करें

— माइकल एम।

@ नोट इको बहुत कम है:,[.,]

— क्रंचर

Answer 4

हास्केल

reverseNumber :: Integer -> Integer
reverseNumber x = reverseNumberR x e 0
    where e = 10 ^ (floor . logBase 10 $ fromIntegral x)

reverseNumberR :: Integer -> Integer -> Integer -> Integer
reverseNumberR 0 _ _ = 0
reverseNumberR x e n = d * 10 ^ n + reverseNumberR (x - d * e) (e `div` 10) (n + 1)
    where d = x `div` e

कोई सरणियाँ, तार या मापांक नहीं।

इसके अलावा, मुझे पता है कि हम सूचियों या तार का उपयोग करने वाले नहीं हैं, लेकिन मुझे यह पसंद है कि जब आप ऐसा करते हैं तो यह कितना छोटा होता है:

reverseNumber :: Integer -> Integer
reverseNumber = read . reverse . show

Comments

साइट रेगुलर का एक गुच्छा दिन के लिए अपने मतदान को अधिकतम कर चुका था, इसलिए धैर्य रखें। :)

— जोनाथन वान मैट्रे

Answer 5

सी ++

/* 
A one-liner RECUrsive reveRSE function. Observe that the reverse of a 32-bit unsigned int
can overflow the type (eg recurse (4294967295) = 5927694924 > UINT_MAX), thus the 
return type of the function should be a 64-bit int. 

Usage: recurse(n)
*/

int64_t recurse(uint32_t n, int64_t reverse=0L)
{
    return n ? recurse(n/10, n - (n/10)*10 + reverse * 10) : reverse;
}

Comments

के साथ कूलर होगा?:

— mniip

@ मन्नीप अच्छा विचार

— अली अलावी

+ 1 शानदार। काश वहाँ और अधिक upvotes थे।

— duci9y

अतिप्रवाह मामले को पकड़ने के लिए यश।

— जोनाथन वान मैट्रे

Answer 6

मुझे लगता है किसी को partypooper होना चाहिए।

दे घुमा के

$ rev<<<[Input]

 

$ rev<<<321
123
$ rev<<<1234567890
0987654321

आकार सीमाएं आपके शेल पर निर्भर करती हैं, लेकिन आप कारण के भीतर ठीक रहेंगे।

Comments

अच्छा खेला सर। अच्छी तरह से खेला

— उपयोगकर्ता

यह कैसे एक स्ट्रिंग नहीं है?

— नहीं कि चार्ल्स

यह एक तार हो सकता है। क्या आपको यकीन है कि बैश संभव होने पर पूर्णांक के रूप में इनपुट लेता है?

— duci9y

बश में सब कुछ एक स्ट्रिंग है जब तक कि अन्यथा उदाहरण के लिए उपयोग न किया जाए declare -i। तुलना करें foo=089और declare -i foo=089(अमान्य अष्टक संख्या)।

— l0b0

@ L0b0 द्वारा टिप्पणी के अनुसार यह उत्तर अमान्य है।

— duci9y

Answer 7

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

EDIT : चूंकि %ऑपरेटर का उपयोग नहीं करने का सुझाव है , इसलिए मैं अब थोड़ी चाल का उपयोग करता हूं।

मुझे पता है कि यह एक कोड-गोल्फ नहीं है, लेकिन इसे लंबे समय तक बनाने का कोई कारण नहीं है।

function r(n){v=0;while(n)v=n+10*(v-(n=~~(n/10)));return v}

r(13457) रिटर्न 75431

इसके अलावा, यह स्ट्रिंग विधि की तुलना में बहुत तेज है ( n.toString().split('').reverse().join('')):

==> JSPerf रिपोर्ट <==

Comments

के ~~बजाय का उपयोग करने के बारे में क्या Math.floor?

— विक्टर स्टैफुसा

हाँ यह छोटा होगा, लेकिन कम समझ में आता है।

— माइकल एम।

क्या यह पाठ्यपुस्तक पूर्णांक-उत्क्रमण विधि नहीं है? मुझे लगता है कि मैंने इस एल्गोरिथम को होमवर्क के लिए लिखा है।

— user2357112

ऊपर की टिप्पणी के साथ, यह सिर्फ मानक पूर्णांक उत्क्रमण एल्गोरिथ्म है। जहां तक ​​मैं रचनात्मक भाग देख सकता हूं, ~~इसके बजाय सिर्फ Math.floor(@Victor द्वारा सुझाए गए परिवर्तन) का उपयोग है

— बर्टी

प्रदर्शन परीक्षण के लिए +1। सभी महान रचनात्मक दिमाग प्रदर्शन परीक्षण जल्दी और अक्सर करते हैं। : डी

— जोनाथन वान मैट्रे

Answer 8

अजगर

सुनिश्चित नहीं है कि यह कार्यान्वयन रचनात्मक गणित के लिए योग्य है

इसके अलावा% ऑपरेटर का उपयोग प्रति सेगमेंट में नहीं किया गया था, हालांकि कोई यह तर्क दे सकता है कि डिमॉड वही करता है, लेकिन फिर प्रश्न को फिर से परिभाषित करने की आवश्यकता है :-)

कार्यान्वयन

r=lambda n:divmod(n,10)[-1]*10**int(__import__("math").log10(n))+r(n /10)if n else 0

डेमो

>>> r(12345)
54321
>>> r(1)
1

यह कैसे काम करता है?

यह एक पुनरावर्ती divmod समाधान है * यह समाधान न्यूनतम महत्वपूर्ण अंक निर्धारित करता है और फिर इसे संख्या के अंत तक धकेलता है। *

फिर भी एक और पायथन कार्यान्वयन

def reverse(n):
    def mod(n, m):
        return n - n / m * m
    _len = int(log10(n))
    return n/10**_len + mod(n, 10)*10**_len + reverse(mod(n, 10**_len)/10)*10 if n and _len else n

यह कैसे काम करता है?

यह एक पुनरावर्ती समाधान है जो संख्या से चरम अंकों को स्वैप करता है

Reverse(n) = Swap_extreme(n) + Reverse(n % 10**int(log10(n)) / 10) 
             ; n % 10**log10(n) / n is the number without the extreme digits
             ; int(log10(n)) is the number of digits - 1
             ; n % 10**int(log10(n)) drops the most significant digit
             ; n / 10 drops the least significant digit

Swap_extreme(n) = n/10**int(log10(n)) + n%10*10**int(log10(n))
             ; n%10 is the least significant digit
             ; n/10**int(log10(n)) is the most significant digit

उदाहरण रन

reverse(123456) = 123456/10^5 + 123456 % 10 * 10^5 + reverse(123456 % 10 ^ 5 / 10)
                = 1           + 6 * 10 ^ 5 + reverse(23456/10)
                = 1           + 600000     + reverse(2345)
                = 600001 + reverse(2345)
reverse(2345)   = 2345/10^3 + 2345 % 10 * 10^3 + reverse(2345 % 10 ^ 3 / 10)
                = 2         + 5 * 10^3 + reverse(345 / 10)
                = 2         + 5000     + reverse(34)
                = 5002                 + reverse(34)
reverse(34)     = 34/10^1 + 34 % 10 * 10^1 + reverse(34 % 10 ^ 1 / 10)
                = 3       + 40             + reverse(0)
                = 43 + reverse(0)
reverse(0)      = 0

Thus

reverse(123456) = 600001 + reverse(2345)
                = 600001 + 5002 + reverse(34)
                = 600001 + 5002 + 43 + reverse(0)
                = 600001 + 5002 + 43 + 0
                = 654321

Comments

ऐसा होता है। +5 ब्राउनी अंक ।

— duci9y 19

@downvoter: क्या आप जवाब दे सकते हैं कि इस उत्तर में क्या गलत है?

— अभिजीत

तुम, श्रीमान, मेरे अंगूठे के लायक हो ...

— kmonsoor

Answer 9

बस इसके विपरीत, modulo ऑपरेटर का एक अति प्रयोग:

unsigned int reverse(unsigned int n)
    {return n*110000%1099999999%109999990%10999900%1099000%100000;}

ध्यान दें कि यह हमेशा 5 अंकों को उलट देता है, और 32 बिट पूर्णांक 39045 से अधिक इनपुट मूल्यों के लिए अतिप्रवाह होगा।

Answer 10

सी#

यहां एक तरीका है बिना मापुलस ( %) ऑपरेटर और सिर्फ साधारण अंकगणित के।

int x = 12356;
int inv = 0;
while (x > 0)
{
    inv = inv * 10 + (x - (x / 10) * 10);
    x = x / 10;
}
return inv;

Comments

आपके पास मापांक है, आपने इसे स्वयं परिभाषित किया है।

— बेंजामिन ग्रुएनबाम

हाँ मुझे पता है। हम सिर्फ %ऑपरेटर का उपयोग करने वाले नहीं हैं । :) मैं देख रहा हूं कि आपका क्या मतलब है, मेरा पाठ थोड़ा भ्रामक था।

— davidsbro

Answer 11

दे घुमा के

> fold -w1 <<<12345 | tac | tr -d '\n'
54321

Answer 12

सी

#include <stdio.h>

int main(void) {
    int r = 0, x;
    scanf("%d", &x);
    while (x > 0) {
        int y = x;
        x = 0;
        while (y >= 10) { y -= 10; ++x; }
        r = r*10 + y;
    }
    printf("%d\n", r);
}

कोई तार, सरणियाँ, मापांक या विभाजन। इसके बजाय, बार-बार घटाव द्वारा विभाजन।

Answer 13

मेथेमेटिका

संख्या से बाहर एक छवि बनाना, इसे प्रतिबिंबित करना, इसे अंकों में विभाजित करना। फिर दो विकल्प हैं:

1. पहले से तैयार छवियों के साथ परिलक्षित अंक की प्रत्येक छवि की तुलना करें, इसे संबंधित अंक के साथ बदलें और इसमें से संख्या का निर्माण करें।

2. हर अंक को अलग से प्रतिबिंबित करें, एक नई छवि का निर्माण करें, और इसे छवि मान्यता समारोह में पास करें।

मैंने दोनों किया

reflectNumber[n_?IntegerQ] := 
 ImageCrop[
  ImageReflect[
   Image@Graphics[
     Style[Text@NumberForm[n, NumberSeparator -> {".", ""}], 
      FontFamily -> "Monospace", FontSize -> 72]], 
   Left -> Right], {Max[44 Floor[Log10[n] + 1], 44], 60}]
reflectedDigits = reflectNumber /@ Range[0, 9];
reverse[0] := 0
reverse[n_?IntegerQ /; n > 0] := 
 Module[{digits}, 
  digits = ImagePartition[reflectNumber[1000 n], {44, 60}];
  {FromDigits[
    digits[[1]] /. (d_ :> # /; d == reflectedDigits[[# + 1]] & /@ 
       Range[0, 9])],
   ToExpression@
    TextRecognize[
     ImageAssemble[
      Map[ImageReflect[#, Left -> Right] &, digits, {2}]]]}]
reverse[14257893]
> {39875241, 39875241}

संपादित करें : तीन शून्य का पैडिंग जोड़ा गया, क्योंकि TextRecogniseपूर्णांक> 999 के साथ ही सही ढंग से काम करता है।

Comments

डबल प्रतिबिंब के लिए यश। हर अच्छे प्रोग्रामर को जब भी संभव हो प्रतिबिंब का उपयोग करना चाहिए। ;-) हालाँकि, आपका पहला तरीका MM9 में मेरे सिस्टम पर आपके उदाहरण के लिए काम नहीं करता है।

— जोनाथन वान मैट्रे

अब वह रचनात्मक है।

— डेविड सैंडर्स

मुझे अपने पैड में 9 और 4 को वैकल्पिक करने के लिए सबसे अच्छा परिणाम मिला (सभी 9s या सभी 1s को कभी-कभी ओसीआर ग्लिच देने के लिए मिलाया जाता है), लेकिन यह शायद फोंट में अंतर के नीचे है।

— जोनाथन वान मैट्रे

Answer 14

लुआ

function assemble(n,...)
    if ... then
        return 10*assemble(...)+n
    end
    return 0
end
function disassemble(n,...)
    if n>0 then
        return disassemble(math.floor(n/10),n%10,...)
    end
    return ...
end
function reverse(n)
    return assemble(disassemble(n))
end

कोई सरणियों या तार का इस्तेमाल नहीं किया। संख्या को अंकों में विभाजित किया गया है और तर्कों की सूची का उपयोग करके फिर से जोड़ा गया है।

Comments

लुआ वैसे भी सरणियाँ नहीं है। तालिकाओं है: पी अन्यथा varargs सरणियों हैं

— Nowayz

@ नोवेज़ इसमें सारणी के सदृश टेबल होते हैं। यही कारण है कि मुझे उनका उपयोग करने की अनुमति नहीं है। और varargs सरणियाँ नहीं हैं: P

— mniip

लेकिन आप उपयोग कर रहे हैं %! : पी

— ntoskrnl

Answer 15

को Python2

मान लें कि "अहस्ताक्षरित पूर्णांक" 32-बिट है

import math
import sys
a=input()
p=int(math.log(a, 10))
b=a
while b%10==0:
    sys.stdout.write('0') # if 1-char string is not allowed, use chr(48) instead
    b=b/10

if p==0:
    print a
elif p==1:
    print a%10*10+a/10
elif p==2:
    print a%10*100+a%100/10*10+a/100
elif p==3:
    print a%10*1000+a%100/10*100+a%1000/100*10+a/1000
elif p==4:
    print a%10*10000+a%100/10*1000+a%1000/100*100+a%10000/1000*10+a/10000
elif p==5:
    print a%10*100000+a%100/10*10000+a%1000/100*1000+a%10000/1000*100+a%100000/10000*10+a/100000
elif p==6:
    print a%10*1000000+a%100/10*100000+a%1000/100*10000+a%10000/1000*1000+a%100000/10000*100+a%1000000/100000*10+a/1000000
elif p==7:
    print a%10*10000000+a%100/10*1000000+a%1000/100*100000+a%10000/1000*10000+a%100000/10000*1000+a%1000000/100000*100+a%10000000/1000000*10+a/10000000
elif p==8:
    print a%10*100000000+a%100/10*10000000+a%1000/100*1000000+a%10000/1000*100000+a%100000/10000*10000+a%1000000/100000*1000+a%10000000/1000000*100+a%100000000/10000000*10+a/100000000
elif p==9:
    print a%10*1000000000+a%100/10*100000000+a%1000/100*10000000+a%10000/1000*1000000+a%100000/10000*100000+a%1000000/100000*10000+a%10000000/1000000*1000+a%100000000/10000000*100+a%1000000000/100000000*10+a/1000000000

जब इनपुट दिया जाता है 1230, तो यह आउटपुट करता है 0321।

Comments

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

— ace_HongKongInd डिपेंडेंस

मुझे नहीं लगता कि आपको इसे हटा देना चाहिए, क्योंकि यह इसका उपयोग न करने का सुझाव है, नियम नहीं:"Since this is a popularity contest, I suggest not using the modulus (%) operator in your code."

— ProgramFOX

इसके अलावा विशाल अगर बयान व्यावहारिक रूप से ASCII कला है।

— जोनाथन वान मैट्रे

Answer 16

परिशिष्ट भाग

/rev{0 exch{dup 10 mod 3 -1 roll 10 mul add exch 10 idiv dup 0 eq{pop exit}if}loop}def

कोई सरणियाँ, कोई तार नहीं, कोई चर नहीं।

gs -q -dBATCH -c '/rev{0 exch{dup 10 mod 3 -1 roll 10 mul add exch 10 idiv dup 0 eq{pop exit}if}loop}def 897251 rev ='
152798

उसी के बिना mod(जो सिर्फ एक शॉर्टकट है, इसलिए कोई बड़ा अंतर नहीं है):

/rev {
    0 exch {
        dup
        10 idiv dup
        3 1 roll 10 mul sub
        3 -1 roll 10 mul add exch 
        dup 0 eq {pop exit} if
    } loop
} def

Answer 17

सी#

यह बिना तार या सरणियों का उपयोग करता है, लेकिन .NET Stack<T>प्रकार (EDIT: मूल रूप से उपयोग किए गए मापांक ऑपरेटर; अब हटा दिया गया) का उपयोग करता है

public class IntegerReverser
{
    public int Reverse(int input)
    {
        var digits = new System.Collections.Generic.Stack<int>();
        int working = input;
        while (working / 10 > 0)
        {
            digits.Push(working - ((working / 10) * 10));
            working = working / 10;
        }
        digits.Push(working);
        int result = 0;
        int mult = 1;
        while (digits.Count > 0)
        {
            result += digits.Pop() * mult;
            mult *= 10;
        }
        return result;
    }
}

Answer 18

सी

इसमें स्पष्ट समाधान को कुछ अन्य भाषाओं में दर्शाया गया है, सी में भी इसे पोस्ट कर सकते हैं।

golfed:

r;main(n){scanf("%d",&n);for(;n;n/=10)r=r*10+n%10;printf("%d",r);}

Ungolfed:

#include <stdio.h>

int main()
{
     int n, r = 0;
     scanf("%d", &n);
     for(;n;n/=10)
     { 
          r = r * 10 + n % 10;
     }
     printf("%d", r);
}

संपादित करें: बस मापांक संपादित देखा।

गोल्फ (कोई मापांक नहीं):

r;main(n){scanf("%d",&n);for(;n;n/=10)r=r*10+(n-10*(n/10));printf("%d",r);}

अघोषित (कोई मापांक नहीं):

#include <stdio.h>

int main()
{
     int n, r, m = 0;
     scanf("%d", &n);
     for(;n;n/=10)
     { 
          r=r*10+(n-10*(n/10));
     }
     printf("%d", r);
}

Answer 19

जावा

यह मैं इस के साथ आया हूँ, कोई तार, कोई सरणियाँ ... चर भी नहीं (जावा में मैं तुम्हें बुरा लगता है):

public static int reverse(int n) {
    return n/10>0?(int)(modulo(n,10)*Math.pow(10, count(n)))+reverse(n/10):(int)(modulo(n,10)*Math.pow(10,count(n)));
}

public static int count(int i) {
    return (i = i/10)>0?count(i)+1:0;
}

public static int modulo(int i,int j) {
    return (i-j)>=0?modulo(i-j, j):i;
}

संपादित करें एक अधिक पठनीय संस्करण

/** Method to reverse an integer, without the use of String, Array (List), and %-operator */
public static int reverse(int n) {
    // Find first int to display
    int newInt = modulo(n,10);
    // Find it's position
    int intPos = (int) Math.pow(10, count(n));
    // The actual value
    newInt = newInt*intPos;
    // Either add newInt to the recursive call (next integer), or return the found
    return (n/10>0) ? newInt+reverse(n/10) : newInt;
}

/** Use the stack, with a recursive call, to count the integer position */
public static int count(int i) {
    return (i = i/10)>0?count(i)+1:0;
}

/** A replacement for the modulo operator */
public static int modulo(int i,int j) {
    return (i-j)>=0?modulo(i-j, j):i;
}

Comments

कृपया अपने कोड को अधिक पठनीय बनाएं, यह कोड गोल्फ नहीं है। धन्यवाद।

— duci9y

यह मेरा पहला प्रयास है, मुझे आशा है कि अद्यतन संस्करण बेहतर है :-)

— oiZo

हाँ यही है। धन्यवाद। कोड गोल्फ में आपका स्वागत है। मैं भी नया हूँ। :)

— duci9y

Answer 20

शक्ति कोशिका

PowerShell में एक त्वरित समाधान। या तो स्पष्ट रूप से या स्पष्ट रूप से उपयोग किए गए कोई सरणियाँ या तार नहीं।

function rev([int]$n) {
    $x = 0
    while ($n -gt 0) {
        $x = $x * 10
        $x += $n % 10
        $n = [int][math]::Floor($n / 10)
    }
    $x
}

परिक्षण:

PS > rev(13457)
75431

PS > rev(rev(13457))
13457

Answer 21

अजगर (आसानी से विधानसभा में किया जाता है)

एक बाइट के बिट्स को उलट देता है। हर किसी के लिए सटीक एक ही बात नहीं करने के लिए अंक?

x = int(input("byte: "), 2)
x = ((x * 8623620610) & 1136090292240) % 1023
print("{0:b}".format(x).zfill(8))

उदाहरण

byte: 10101010
01010101

Comments

क्या यह नमूना इनपुट का उत्पादन नमूना उत्पादन के लिए काम करेगा?

— duci9y

Answer 22

सी ++

#include<iostream>
#include<conio.h>
#include<fstream>
using namespace std;
int main()
{
    int i,size;
    float num;
    char ch;
    cout<<"enter the number \t: ";
    cin>>num;
    ofstream outf("tmp.tmp");
    outf<<num;
    outf.close();
    ifstream inf("tmp.tmp");
    inf.seekg(0,ios::end);
    size=inf.tellg();
    inf.seekg(-1,ios::cur);
    cout<<"Reverse of it\t\t: ";
    for(i=0;i<size;i++)
    {
        inf>>ch;
        if(ch!='0'||i!=0)
        cout<<ch;
        inf.seekg(-2,ios::cur);
    }
    inf.close();
            remove("tmp.tmp");
    getch();
    return 0;
}  

आउटपुट

तीन सैंपल चले

शून्य के साथ परीक्षण करें

यह भी चल संख्या उलट !!!

यदि आप इस कोड को चलाना चाहते हैं तो इसे अपने कंप्यूटर पर चलाएं क्योंकि यह रन-टाइम के दौरान एक अस्थायी फ़ाइल बनाता है और मुझे यकीन नहीं है कि ऑनलाइन कंपाइलर आपके कंप्यूटर पर एक अस्थायी फ़ाइल बनाएंगे

Comments

यह एक स्ट्रिंग बना एक फ़ाइल के लिए नहीं लिख रहा है?

— duci9y

स्ट्रिंग अंत में एक अशक्त चरित्र के साथ चरित्र का एक संयोजन है, इसलिए यह एक स्ट्रिंग नहीं है, बल्कि केवल पात्रों का एक संयोजन है

— मुकुल कुमार

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

— duci9y

स्ट्रिंग्स के लिए आपकी परिभाषा गलत है कृपया इस वेबसाइट ( cs.stmarys.ca/~porter/csc/ref/c_cpp_strings.html ) पर जाएं और अंतिम पैराग्राफ़ को ध्यान से पढ़ें। स्ट्रिंग वर्णों का एक संयोजन है जो A \ 0 'के साथ समाप्त होता है

— मुकुल कुमार

मुझे क्षमा करें, आप C स्ट्रिंग्स के बारे में बात कर रहे हैं। मैं सामान्य रूप से तार के बारे में बात कर रहा हूँ। आपका जवाब योग्य नहीं है।

— duci9y

Answer 23

ECMAScript 6

reverse=x=>{
    var k=-(l=(Math.log10(x)|0)),
        p=x=>Math.pow(10,x),
        s=x*p(l);
    for(;k;k++) s-=99*(x*p(k)|0)*p(l+k);
    return s
}

फिर:

• reverse(12345) आउटपुट 54321
• reverse(3240) आउटपुट 423
• reverse(6342975) आउटपुट 5792436

Answer 24

विखंडन

$SX/
\S?L
K\O

यह प्रोग्राम इनपुट को उलट देता है।

$ echo -n '12345' | fsn tac.fsn
54321

Comments

आप सवाल पूछने से पहले "क्या प्रोग्रामिंग भाषा मौजूद थी?" इस पर परीक्षण करें। विखंडन इसोलंग दुनिया में एक शांत प्रविष्टि की तरह दिखता है - "कण कणों की किताबों से भरा शेल्फ के साथ एसिड पर Befunge।" अच्छा!

— जोनाथन वान मैट्रे

Answer 25

उल्लिखित

मुझे लगता है कि यह लोकप्रिय के विपरीत है ... लेकिन फोर्थ का उपयोग करना हमेशा रचनात्मक होता है ...

एक नया शब्द बनाते हैं

: REV 
  BEGIN
    S->D 10 U/
    SWAP 1 .R
  DUP 0= UNTIL 
CR ;

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

12345 REV 54321
ok

Comments

मुझे वह एमुलेटर कहां मिलेगा?

— बिल्ली

स्पेक्ट्रम की दुनिया के बहुत सारे एमुलेटर यहां सूचीबद्ध हैं worldofspectrum.org/emulators.html

— मैटस्टील

Answer 26

ट्यूरिंग मशीन कोड

यहाँ से वाक्य रचना का उपयोग करना ।

0 * * l 0
0 _ # r 2
2 # # r 2
2 0 # l A
2 1 # l B
2 2 # l C
2 3 # l D
2 4 # l E
2 5 # l F
2 6 # l G
2 7 # l H
2 8 # l I
2 9 # l J
2 _ _ l Z
A * * l A
A _ 0 l Q 
B * * l B
B _ 1 l Q 
C * * l C
C _ 2 l Q
D * * l D
D _ 3 l Q
E * * l E
E _ 4 l Q
F * * l F
F _ 5 l Q
G * * l G
G _ 6 l Q
H * * l H
H _ 7 l Q
I * * l I
I _ 8 l Q
J * * l J
J _ 9 l Q
Q # # r 2
Q * * r Q
Z # _ l Z
Z * * l ZZ
ZZ _ * r ZZZ
ZZ * * l ZZ
ZZZ 0 _ r ZZZ
ZZZ * * * halt

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

Answer 27

अजगर

import itertools

def rev(n):
    l = next(m for m in itertools.count() if n/10**m == 0)
    return sum((n-n/10**(i+1)*10**(i+1))/10**i*10**(l-i-1) for i in range(l))

Comments

rev(1230)देता है 321। मुझे लगता है कि यह वास्तव में देना चाहिए 0321?

— ace_HongKongInd डिपेंडेंस

क्या वह गलत है? यदि हम केवल संख्याओं के साथ काम कर रहे हैं, तार नहीं, तो 0321 और 321 बराबर हैं?

— जयंत कौशिक

मेरी समझ में यह 321 होना चाहिए। सवाल तार का उपयोग करना बंद कर दिया। तो यह 321 होना चाहिए।

— माइक्रोबियन

मुझे नहीं पता ... ओपी के जवाब का इंतजार है। मैं सिर्फ यह कह रहा हूं, यह गलत नहीं है। गलतफहमी के लिए खेद है।

— ace_HongKongInd डिपेंडेंस

मैंने सवाल अपडेट किया।

— द्विवेदी

Answer 28

सी

#include <stdio.h>

int c(int n) {
    return !n ? 0 : 1+c(n/10);
}

int p(int n) {
    return !n ? 1 : 10*p(n-1);
}

int r(int n) {
    return !n ? 0 : n%10*p(c(n/10))+r(n/10);
}

int main() {
    printf("%d\n", r(13457));

    return 0;
}

Answer 29

जत्था

तार का उपयोग नहीं करने के बारे में हिस्सा याद किया - ओह अच्छी तरह से।

@echo off
setLocal enableDelayedExpansion enableExtensions
for /f %%a in ('copy /Z "%~dpf0" nul') do set "ASCII_13=%%a"
set num=%~1
set cnum=%num%
set len=0
:c
if defined num set num=%num:~1%&set /a len+=1&goto :c
set /a len-=1
for /L %%a in (%len%,-1,0) do set /p "=!ASCII_13!!cnum:~%%a,1!"<nul

Answer 30

अजगर २

import math

def reverseNumber(num):
    length = int(math.ceil(math.log10(num)))
    reversed = 0

    for i in range(0, length):
        temp = num // math.pow(10, length - i - 1)
        num -= temp * math.pow(10, length - i - 1)
        reversed += int(temp * math.pow(10, i))

    return reversed

print reverseNumber(12345)