घूर्णी औसत

Question

एक इनपुट पूर्णांक को देखते हुए n >= 10, पूर्णांक के सभी घटाए गए रोटेशन का औसत आउटपुट करता है।

उदाहरण के लिए, इनपुट के लिए, 123घुमाव 123(कोई रोटेशन नहीं), 231(एक रोटेशन) और 312(दो घुमाव) हैं। उन का औसत (123 + 231 + 312) / 3या है 222।

एक अन्य उदाहरण के रूप में लें 4928। रोटेशन हैं 4928, 9284, 2849, और 8492। उन चार संख्याओं का औसत लेना बराबर है 6388.25।

एक और उदाहरण के लिए, निवेश के लिए 445445, deduplicated रोटेशन हैं 445445, 454454, और 544544, इसलिए उत्पादन होता है 481481।

इनपुट के लिए 777, केवल एक कटे हुए घुमाव है, इसलिए आउटपुट है 777।

नियम

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

Comments

क्या हम इनपुट को अंकों की सूची के रूप में ले सकते हैं?

— डेनिस

@ डेनिस श्योर, यह ठीक है। कुछ बाइट्स बचाओ। : p

— AdmBorkBork

क्या आपके पास एक उदाहरण है जहां कटौती वास्तव में आउटपुट को बदल देती है? आपके 445445 उदाहरण में, प्रत्येक 3 अद्वितीय घुमाव दो बार होता है, इसलिए उन्हें छोड़ने से आउटपुट में बदलाव नहीं होता है।

— कलडो

@ बाल्डो नहीं, मैं (मैन्युअल रूप से) एक के साथ आने में सक्षम नहीं था, लेकिन इसका मतलब यह नहीं है कि कोई मौजूद नहीं है, इसलिए मैंने जगह में कटौती के नियमों को छोड़ दिया।

— AdmBorkBork

@Kaldo Let d के अंकों की संख्या हो n और k ऐसी है कि घूर्णन पूर्णांक छोटी से छोटी सकारात्मक n कश्मीर बाईं reproduces ओर अंकों एन । लो क्ष और 0 ≤ r <कश्मीर ऐसी है कि d = qk + r । घूर्णन n दोनों घ और qk बाईं ओर अंक उपज चाहिए n , तो आर = 0 । इसका मतलब यह है कि प्रत्येक अद्वितीय रोटेशन q बार होता है, इसलिए घुमावों को कम करने के लिए औसत की गणना करने की आवश्यकता नहीं होती है।

— डेनिस

Answer 1

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

lambda*n:10**len(n)//9*sum(n)/len(n)

अंकों को अलग-अलग तर्कों के रूप में लेता है। पायथन 3 का सुझाव देने के लिए @Rod का धन्यवाद, 2 बाइट्स की बचत।

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

Comments

एक अतिरिक्त बाइट को पायथन 2 पर वापस स्विच करके और फ़्लोट्स की एक सरणी लेकर बचाया जा सकता है।

— डेनिस

आपको अलग-अलग तर्कों के रूप में अंकों को लेने की आवश्यकता नहीं है, एक नियमित पुरानी सूची ठीक काम करती है

— Asone Tuhid

Answer 2

एपीएल (डायलॉग) , 9 बाइट्स

10⊥≢⍴+/÷≢

तर्क के रूप में अंकों का एक वेक्टर लेने वाला एक विवादास्पद कार्य।

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

मैं अंकों का औसत लेता हूं +/÷≢, फिर इसे इनपुट की लंबाई तक दोहराता हूं≢⍴ , और अंत में आधार 10 से परिवर्तित करता ।

वैचारिक रूप से, मैं रोटेशन (बिना ले जाने) का योग ले रहा हूं:

 4  2  9  8
 2  9  8  4
 9  8  4  2
+8  4  2  9
 -----------
 23 23 23 23

यह सिर्फ 4+2+9+84 बार दोहराया जाता है । फिर आधार से परिवर्तित करना 10(जो मेरे लिए वहन करता है) और लंबाई से विभाजित होता है। हालाँकि मैं पहले लंबाई से विभाजित करता हूँ क्योंकि यह समतुल्य है और बाइट्स बचाता है।

Comments

वह जीनियल है: D

— Leo

@LI FWIW जवाब है कि एक प्रतिनिधि अंक द्वारा औसत गुणा करने के लिए अनिवार्य रूप से एक ही काम कर रहे हैं

— H.PWiz

Answer 3

जावा 10, 163 137 76 72 बाइट्स

n->(Math.pow(10,n.size())-1)/9*n.stream().mapToInt(i->i).sum()/n.size()

-36 के लिए धन्यवाद बाइट्स @Nevay ।
-61 बाइट्स @ @ डेनिस 'पायथन 3 जवाब का पोर्ट बनाकर @ ओलिवियरग्रेयर को धन्यवाद ।
स्ट्रिंग के बजाय अंकों की सूची के रूप में इनपुट लेकर -1 बाइट्स।

स्पष्टीकरण:

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

n->                                 // Method with String parameter and double return-type
  (Math.pow(10,n.size())-1)/9       //  Repunits the same length as the input-size
  *n.stream().mapToInt(i->i).sum()  //  multiplied by the sum of digits
  /n.size()                         //  divided by the input-size

Comments

151 बाइट्स: n->{var s=new java.util.HashSet();var r=0d;for(int l=n.length(),x;l-->0;)if(s.add(x=new Integer(n=n.substring(1)+n.charAt(0))))r+=x;return r/s.size();}137 बाइट्स के साथ स्ट्रीम अप्रोच:n->java.util.stream.IntStream.range(0,n.length()).map(i->new Integer(n.substring(i)+n.substring(0,i))).distinct().average().getAsDouble()

— नेवले

के orElse(0)बजाय का उपयोग करें getAsDouble()।

— ओलिवियर ग्रेगोइरे

69 बाइट्स , दूसरों के समाधान के आधार पर। (int)5 mote बाइट के लिए राउंड का उपयोग , यदि आवश्यक हो।

— ओलिवियर ग्रेगोइरे

आपको एक डबल के रूप में कास्ट करने की आवश्यकता नहीं है: Math.powपहले से ही इसका ख्याल रखता है। इससे आपको 3 बाइट्स मिलेंगे।

— ओलिवियर ग्रेगोइरे

@ OlivierGrégoire अगर मैं ऐसा करता हूं तो यह गलत परिणाम देगा। इंट टू कास्ट का उपयोग किया जाता है, ताकि हम 9 तक पूर्णांक और अंकों के योग से गुणा कर सकें । इसके बाद ही औसत प्राप्त करने के लिए इसे दोगुना होना चाहिए। यदि मैं दोनों को निकालता हूं (int)और *.1यह इनपुट के 6388.888...बजाय उदाहरण के आउटपुट के 6388.25लिए होगा 4928। और अगर मैं पूरी चीज या सिर्फ .powएक के intबजाय, यह उत्पादन होगा 6388।

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

Answer 4

भूसी , 5 बाइट्स

d´MKA

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

व्याख्या

d´MKA
    A  Take the average of the digits
 ´MK   Replace each element of the original list with the average
d      Join the list to get a number

---

भूसी , 7 बाइट्स

A§modṙŀ

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

व्याख्या

A§modṙŀ
      ŀ  Take the range [1..length(input)]
 §m  ṙ   Rotate the input by each element of the range
   od    Convert each list of digits to a number
A        Take the average of the list

Comments

एक पहेली के लिए, कम से कम एक 5बाइट समाधान है

— H.PWiz

@ H.PWiz मैं इसे समझ नहीं सकता, क्या आप एक संकेत दे सकते हैं? : पी

— सिंह

@ लियो कोई है ṙया नहीं ŀ, और पहला चरित्र (बाईं ओर) नहीं हैA

— एच.पाइविज़

Answer 5

आर , 84 73 64 बाइट्स

function(D,K=sum(D|1))mean(array(D,K+1:0)[1:K,1:K]%*%10^(K:1-1))

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

अंकों की सूची के रूप में इनपुट।

11 बाइट्स से शेविंग करने के लिए मिकी का धन्यवाद! 8 बाइट्स डेनिस के प्रमाण से मुग्ध है कि समर्पण अनावश्यक है।

Comments

73 के लिए

— मिकी टीटी

@MickyT रिसाइकिलिंग का आल्हा चालाक उपयोग!

— गिउसेप्पे

@ मिक्सी एक बाइट array(D,K+1:0)से छोटी है matrix(D,K+1,K)।

— ग्यूसेप

Answer 6

05AB1E , 9 बाइट्स

vÀD}\OIg/

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

Comments

vनहीं y, दिलचस्प है।

— मैजिक ऑक्टोपस Urn

gFÀD})¨Osg/मैं कहाँ सोच रहा था

— मैजिक ऑक्टोपस Urn

क्या आप जानते हैं कि .æ = pop a compute permutations by function, usage: .æ<FUNC>}कमांड का उपयोग कैसे करें ? मैं या तो नहीं है, लेकिन यह इस के लिए फिट लगता है।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn v बिना वाई सबसे छोटा समाधान है जिसे मैं रोटेशन जी (इनपुट) बार प्रदर्शन करने के लिए पा सकता हूं। मैं। F की जाँच कर रहा हूँ, ऐसा नहीं लगता कि यह <FUNC>}

— कालडो

Answer 7

स्टैक्स , 6 बाइट्स

ñJä⌠╤►

इसे चलाएं और डीबग करें

यह कार्यक्रम इनपुट के रूप में एक उद्धरण-सीमांकित स्ट्रिंग लेता है, और औसत को कम अंश के रूप में व्यक्त करता है। जैसे777/1 । घुमावों को डी-डुप्लिकेट करना आवश्यक नहीं है। यह कभी परिणाम नहीं बदलता है।

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह ऐसा दिखता है।

:)  get all character rotations
{em convert strings back to integers
:V  mean - integer inputs means result will be rational

इसको चलाओ

Answer 8

पर्ल 6 , 15 बाइट्स

{.sum/$_*1 x$_}

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

औसत प्रत्येक दशमलव स्थिति पर लागू औसत अंक है, इसलिए अंक औसत 111 बार .... 1 x $_1s का एक स्ट्रिंग पैदा करता है जो गुणा द्वारा तार के लिए मजबूर हो जाता है।

इनपुट के रूप में अंकों की एक सूची लेता है। एक अनुक्रम में राशि से पहले एक कैश की आवश्यकता होती है, और एक नंबर या स्ट्रिंग इनपुट के लिए .comb की आवश्यकता होती है।

Answer 9

वोल्फ्राम भाषा (गणितज्ञ) , 22 बाइट्स

FromDigits[0#+Mean@#]&

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

Answer 10

जावास्क्रिप्ट (Node.js) , 43 बाइट्स

x=>eval(x.join`+`)*'1'.repeat(n=x.length)/n

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

क्या हम इनपुट को अंकों की सूची के रूप में ले सकते हैं? - डेनिस D 7 मिनट पहले

@ डेनिस श्योर, यह ठीक है। कुछ बाइट्स बचाओ। : p - AdmBorkBork 3 मिनट पहले

Answer 11

जेली , 6 5 बाइट्स

ṙJḌÆm

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

यह काम किस प्रकार करता है

ṙJḌÆm  Main link. Argument: A (digit array)

 J     Yield the indices of A, i.e., [1, ..., len(A)].
ṙ      Rotate A 1, ..., and len(A) units to the left, yielding a 2D array.
  Ḍ    Convert each rotation from decimal to integer.
   Æm  Take the arithmetic mean.

Answer 12

Japt , 8 बाइट्स

एकल अंकों के तार की एक सरणी के रूप में इनपुट लेता है।

xpUÊ)÷UÊ

कोशिश करो

---

व्याख्या

             :Implicit input of array U
 pUÊ         :Repeat each string length of U times
x   )        :Reduce by addition
     ÷UÊ     :Divide by the length of U

Answer 13

एपीएल (डायलॉग यूनिकोड) , 21 14 बाइट्स ^{एसबीसीएस}

+/≢÷⍨⍳∘≢(⍎⌽)¨⊂

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

टैसिट उपसर्ग फ़ंक्शन। एक स्ट्रिंग के रूप में इनपुट लेता है।

प्रबुद्ध 7 बाइट बचाने के लिए Adám को धन्यवाद ।

कैसे?

+/≢÷⍨⍳∘≢(⍎⌽)¨⊂ ⍝ Main fn, example argument '123'
              ⊂ ⍝ Enclose the argument (turns it into a scalar)
             ¨  ⍝ Use each of the left arguments to
         ( ⌽)   ⍝ Rotate, then
          ⍎     ⍝ Convert strings into numbers
      ⍳∘≢       ⍝ Tally (≢) the argument, then index (⍳) from 1. 
                ⍝ Returns 1 2 3 for a 3 digit argument, and rotates the argument 1, 2, then 3 times.
     ⍨          ⍝ Use the result as left argument for
    ÷           ⍝ Divide
   ≢            ⍝ By the number of rotations
+/              ⍝ And sum the results

Comments

: | अभी भी APL टिप्पणियों के लिए इस्तेमाल नहीं किया जा सकता है

— केवल

Answer 14

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

def f(a):b={int(`a`[i:]+`a`[:i])for i in range(len(`a`))};print sum(b)/len(b)

संपादित करें: -6 @ बाइट्स के लिए धन्यवाद बाइट्स

Comments

35, डेनिस समाधान , 38, डेनिस समाधान नहीं

— केवल

Answer 15

चारकोल , 11 बाइट्स

Ｉ∕×ΣθＩ⭆θ1Ｌθ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

    θ  θ  θ Input as a string
   Σ        Sum of digits
      ⭆ 1   Replace each character with the literal `1`
     Ｉ      Cast to integer
  ×         Multiply
         Ｌ  Length
 ∕          Divide
Ｉ           Cast to string
            Implicitly print

Answer 16

जे , 10 बाइट्स

10#.#$+/%#

यह H.PWiz के महान APL समाधान J का एक पोर्ट है।

एक तर्क के रूप में अंकों की एक सूची लेता है।

स्पष्टीकरण:

+/%#अंकों का औसत ( %अंकों की संख्या +/को उनकी संख्या से विभाजित करें #)

#$अंकों की संख्या के अनुसार औसत की प्रतियों की एक सूची बनाता है

10#. प्रपत्र 10 का रूपांतर करें

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

Answer 17

पर्ल 5 -lpF , 24 22 बाइट्स

#!/usr/bin/perl -lpF
$_=1x@F/s/./+$&/g*eval

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

अंकों की सूची के रूप में इसे करना केवल 1 बाइट छोटा है और धोखा देने जैसा लगता है:

#!/usr/bin/perl -p
$;+=$_}{$_=1x$./$.*$

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

Comments

क्या है usrt? : P

— केवल

@ ASCII- केवल प्रतीक्षा करें, आपके पास /usrtनिर्देशिका में अपने निष्पादनयोग्य नहीं हैं ? वैसे भी, तय। धन्यवाद

— टन Hospel

Answer 18

रूबी , 60 बाइट्स

->n{a=b=c=0.0;a,b,c,n=a+n%10,b*10+1,c+1,n/10while n>0;a*b/c}

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

Answer 19

परी / जीपी , 34 बाइट्स

अंकों की सूची के रूप में इनपुट लेता है।

n->fromdigits([vecsum(n)|x<-n])/#n

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

Answer 20

रूबी , 33 बाइट्स

->n{10**(k=n.size)/9*n.sum*1.0/k}

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

का एक बंदरगाह डेनिस के पायथन 3 उत्तर का

यहाँ मेरा लंगड़ा प्रयास (74 बाइट्स) है

->s{a=(1..s.size).map{|i|s.chars.rotate(i).join.to_i}|[];a.sum*1.0/a.size}

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

Answer 21

सी ++, 218 208 बाइट्स

-10 बाइट्स Zacharý को धन्यवाद

#include<set>
#include<cmath>
float a(int m){std::set<int>a;int n=m,t,c=0;for(;n>0;n/=10)++c;for(;n<c;++n){a.insert(m);t=m%10;m=m/10+std::pow(10.f,c-1)*t;}int s=0;for(int v:a){s+=v;}return float(s)/a.size();}

और, परीक्षण करने के लिए:

int main() {
    printf("%f\n%f\n%f\n%f\n",a(123),a(4928),a(445445),a(777));
}

Comments

आप के बीच रिक्त स्थान की आवश्यकता नहीं है #includeऔर <है, और आप निकाल सकते हैं {}चारों ओर दोनों ++c;और s+=v;। आप int s=0अपने अन्य चरों के साथ शुरुआत में जाने में सक्षम हो सकते हैं ।

— ज़ाचरी

इसके अलावा, मुझे नहीं लगता कि आपको n=0लूप के लिए दूसरे की जरूरत है , क्योंकि यह 0तब तक पहुंच जाना चाहिए था । m/=10;m+=std::pow(10.f,c-1)*t;=> m=m/10+std::pow(10.f,c-1)*t। और काम के intबजाय का उपयोग नहीं करेगा auto?

— ज़ाचारि

आप अभी भी int s=0;अपने अन्य चर के साथ आगे बढ़ सकते हैं , और क्या आपको आसपास ब्रेसिज़ की आवश्यकता है s+=v;?

— ज़ाचरी

168 बाइट्स

— सीलिंगकैट

n>0=> nकाम कर सकते हैं।

— ज़ाचरी

Answer 22

पायथ, 12 बाइट्स

csms.<zdlzlz

शायद कामचलाऊ है।

c         lz     Divide by the length of the input:
 s               Reduce by +
  m     lz       Map over d = [0 ... the length of the input]:
   s.<zd         Shift the input d characters to the left and cast to int

यहाँ कोशिश करो!

Comments

एक अंतर्निहित औसत फ़ंक्शन है o। यदि आप ऐसा करते हैं और अंकों की सूची के रूप में I / O करते हैं, तो आप इसे 8 बाइट्स तक प्राप्त कर सकते हैं ।

आह, मैं ले रहा था "यदि लागू हो, तो आप मान सकते हैं कि इनपुट / आउटपुट आपकी भाषा के देशी पूर्णांक प्रकार में फिट होगा।" इसका मतलब है कि अगर यह एक पूर्णांक के रूप में लिया जाना था Q।

— आर.के.

Answer 23

जे, 23 बाइट्स

(+/%#)".~.(|."0 1~i.@#)

एक स्ट्रिंग के रूप में इनपुट लेता है

व्याख्या

          (|."0 1~i.@#)  | All rotations
        ~.               | Deduplicate
      ".                 | Convert each to int
(+/%#)                   | Average

Answer 24

मतलाब, 65 बाइट्स

c=num2str(n);l=nnz(c);mean(str2num(c(mod((1:l)+(0:l-1)'-1,l)+1)))

इस पर काम करते हैं, बहुत यकीन है कि यह बेहतर किया जा सकता है।

Answer 25

क्लोजर, 139 बाइट्स

#(let[n(count %)G(set(apply map list(for[i(range n)](take n(drop i(cycle %))))))](/(apply +(for[g G](read-string(apply str g))))(count G)))

वर्णों के पूर्णांक को पूर्णांकों में परिवर्तित करने के लिए पर्याप्त उप-इष्टतम भाषा सुविधाएँ।

Answer 26

डीसी, 37 बाइट्स

यह एक पूर्ण कार्यक्रम है, इनपुट पढ़ना और आउटपुट प्रिंट करना:

?1sd[O~rzsadO<x+ldO*1+sd]dsxxOkld*la/p

यह संख्या को उसके अंकों में अलग करके काम करता है, और अंकों की औसत लंबाई को पुनरीक्षित करता है (जो dहम जाते हैं)।

?                               # read input
 1sd                            # initialize d=1
    [                   ]dsxx   # define and execute recursive macro x:
     O~r                        #   remainder and quotient of /10
        zsa                     #   a = number of digits
           dO<x                 #   recurse if needed
               +ldO*1+sd        #   increment repdigit d
                             Ok         # after executing x, set precision 
                               ld*la/   # multiply by repdigit; divide by a
                                     p  # print the result