अजीब उद्देश्य के लिए अजीब बात है मशीन

Question

गुड इवनिंग गोल्फर्स!

आपकी चुनौती संख्याओं की एक श्रृंखला को पूरी तरह से रद्द करना है।

इनपुट

आपके कार्यक्रम में बिल्कुल 100 पूर्णांक दिए जाएंगे। आपका प्रोग्राम इनपुट को फ़ाइल के रूप में, या स्टड के माध्यम से स्वीकार कर सकता है। प्रत्येक पूर्णांक को एक नए वर्ण द्वारा अलग किया जाएगा।

वे 100 पूर्णांक आपके चुने हुए भाषा में एक हस्ताक्षरित पूर्णांक के अधिकतम मान से न्यूनतम तक होंगे।

कोई डुप्लिकेट मान नहीं होगा। मूल्यों का आदेश दिया जा सकता है, अनियंत्रित या आंशिक रूप से आदेश दिया जा सकता है - आपका कार्यक्रम प्रत्येक मामले को संभालने में सक्षम होना चाहिए।

उत्पादन

आउटपुट 100 पूर्णांकों में से प्रत्येक होना चाहिए, पूरी तरह से अनसर्टेड, प्रत्येक को एक नया वर्ण द्वारा अलग किया गया। आउटपुट स्टडआउट या फ़ाइल के माध्यम से हो सकता है।

पूरी तरह से अनसर्टेड का मतलब है कि कोई भी मूल्य किसी भी मूल्य के निकट नहीं है, जो कि सूची क्रमबद्ध क्रम में पूरी तरह से छांटे जाने पर आसन्न होगा।

स्कोर

प्रति अंक 1 अंक, और सबसे कम स्कोर जीतता है। कोई अंतर्निहित या लाइब्रेरी सॉर्टिंग फ़ंक्शन का उपयोग करके किसी भी समाधान के लिए -100 का बोनस है। यादृच्छिक संख्या कार्यों में निर्मित नहीं का उपयोग कर किसी भी समाधान के लिए -20 का बोनस है।

मैंने इस सवाल को पूरी तरह से परिभाषित करने की कोशिश की है। अगर आपके पास कोई प्रश्न हैं, तो कृपया पूछिए। यदि आपके पास अगली बार बेहतर करने के लिए कोई टिप्पणी है, तो कृपया मुझे बताएं।

फोर!

Comments

वास्तव में 100 पूर्णांक इनपुट हैं, और कोई डुप्लिकेट मान नहीं हैं ("इनपुट" के तहत देखें)

— lochok

सही तुम हो, कि हाजिर नहीं है।

— स्ट्राइगोइड्स

यह इस तरह से एक डुप्लिकेट नहीं है, लेकिन यह codegolf.stackexchange.com/questions/6487/… के

— पीटर टेलर

इतनी सारी चतुर प्रतिक्रियाएँ! मैं 31 अक्टूबर को 8: 10-ज़ुलु

— लोटोक

Answer 1

गोल्फस्क्रिप्ट (स्कोर 27 - 120 = -93)

~].,{{.2$<{\}*}*]}*.(;+2%n*

नोट: यह $स्टैक पर एक तत्व को संदर्भित कर रहा है। छँटाई है, लेकिन यह मैन्युअल रूप से कोडित बबल सॉर्ट के साथ किया जाता है।

हॉवर्ड के लिए धन्यवाद, -90 => -92 के लिए; और इलमारी, जिन्होंने प्रेरित किया -92 => -93।

Comments

इस तरह के संक्षिप्त जवाब के लिए क्रेडिट, लेकिन (मुझे माफ कर दीजिए, क्योंकि मैं गोल्फस्क्रिप्ट नहीं बोलता या समझता हूं) - ^ क्या यह -100 बोनस से अयोग्य नहीं होगा?

— लोटोक

@lochok, अंतर्निहित सॉर्ट फ़ंक्शन है $- इसलिए मैंने उल्लेख किया है कि $प्रोग्राम में सॉर्ट नहीं हैं (यह संदर्भ-निर्भर है)। अधिकांश कार्यक्रम (42 अक्षरों में से 28) फ़ंक्शन को परिभाषित करते हैं ^; पहला संस्करण, बिल्ट-इन सॉर्ट का उपयोग करते हुए, केवल 14 अक्षर था।

— पीटर टेलर

आह - ठीक है। स्पष्टीकरण के लिए धन्यवाद!

— लोटोक

आप निम्न आउटपुट लूप के साथ दो चार्ट बचा सकते हैं 2/{~p}%n*:।

— हावर्ड

2/zip~+n*और .);\+2%n*@ हॉवर्ड के संस्करण के समान वर्णों की चाल भी करें। काश, मैं अभी तक कुछ भी कम खोजने में कामयाब नहीं हुआ।

— इल्मरी करोनें

Answer 2

अजगर -26

(94-120): नया, क्रूड दृष्टिकोण। तत्वों को छाँटने के लिए सबसे कम तत्वों को नई सूची में रखें, फिर इसे पुन: व्यवस्थित करें:

t=l=[]
i=N=100
exec't=t+[input()];'*N+'l+=[t.pop(t.index(min(t)))];'*N+'print l[i%N];i+=3;'*N

पायथन -13

(१० First-१२०): पहला दृष्टिकोण: एक बार में चार सबसे कम तत्वों को निकालता है, फिर इन चारों को दूसरे क्रम में प्रिंट करता है:

exec'l=[]'+'+[input()]'*100
while l:
 a,b,c,d=eval('l.pop(l.index(min(l))),'*4)
 for e in[b,d,a,c]:print e

Comments

t=l=[]और exec't+=[input()];'*100आप को बचाने के कुछ

— आकर्षण

इसके अलावा, आप एक execसे अधिक लूप के लिए एक कथन का उपयोग कर सकते हैं ।

— क्वासिमोडो

@quasimodo मैंने ऐसा कुछ करने की कोशिश की, लेकिन t=l=[]टी और एल के साथ एक ही वस्तु को इंगित करता है और यह काम नहीं करता है। कोष्ठक पर लंघन execहालांकि अच्छा है।

— डेनियरो

आप उपयोग कर सकते हैं t=t+[input()];, यह हर बार एक नई वस्तु बनाता है। और आप निष्पादन विवरण में प्रिंट लूप भी कर सकते हैं ';i+=1;print l[i*3%100]'*100:।

— क्वासिमोडो

तुम फिर से सही हो। धन्यवाद! साथ ही कुछ अन्य गोल्फिंग को भी जोड़ा गया जैसे कि हटाना %3और पुनरावृत्ति से बचना 100।

— डेनिएरो

Answer 3

C: 11 (131 - 120)

प्रोग्रामम स्टड से पढ़ता है और एक साधारण इंसर्ट सॉर्ट करता है, इसके बाद यह n को 50 वें नंबर के साथ एक साथ प्रिंट करता है, जैसे कि अन्य समाधान।

main(){int*i,a[101],*j=a;while(scanf("%d",a)>0)for(i=++j;i-->a;)i[1]=*i>=*a?*i:*(i=a);while(a<(i=j-50))printf("%d\n%d\n",*i,*j--);}

Answer 4

गणितज्ञ -56 44 4 (95-120) = -25

संपादित करें :

यह संस्करण न तो बिल्ट-इन फ़ंक्शंस के लिए, न ही रैंडमाइज़ेशन फ़ंक्शंस पर निर्भर करता है।

Riffle[RotateLeft[#[[All, 2]], 2], #[[All, 1]]] &
[Partition[l //. {x___, a_, b_, y___} /; b < a :> {x, b, a, y}, 2]]

Comments

है Sortएक अंतर्निहित नहीं प्रकार समारोह?

— पीटर टेलर

तुम सही हो! मैं तरह के बारे में बाधा याद किया।

— DavidC

मैंने हैंड-रोल सॉर्ट किया।

— डेविड

Answer 5

जे, -63 (57-120) अक्षर

चूंकि हर कोई स्वयं-लिखित सॉर्ट मार्ग से नीचे जा रहा है ...

,50(}.,.{.)($:@([-.m),~m=.]#~]=<./)^:(0<#),".[;._2[1!:1[3

किसी भी यादृच्छिक संख्या फ़ंक्शन का उपयोग नहीं करता है, और न ही किसी प्रकार का अंतर्निहित।

इनपुट को सॉर्ट करने के लिए एक सरल पुनरावर्ती चयन प्रकार का उपयोग करता है।

Answer 6

रूबी 1.9, -59

(61-120)

प्रत्यावर्तन! यह वास्तव में मेरे पिछले रूबी प्रयासों के विपरीत है, सूची को उनके मूल आदेश की परवाह किए बिना अनसुना कर दें।

p *(f=->l{l[1]&&f[l-m=l.minmax]+m||[]})[$<.map &:to_i].rotate

पिछले प्रयास

प्यारा वन-लाइनर, अब ठीक से काम करने के लिए बिलिन प्रकार का उपयोग कर रहा है:

$<.map(&:to_i).sort.each_slice(4){|a,b,c,d|p b,d,a,c}

पहले एक - जरूरी नहीं कि पिछले 4 मानों को अनसर्ट करें:

l=$<.map &:to_i
48.times{l-=p *l.minmax}
a,b,c,d=l
p b,d,a,c

Comments

आपका -72 समाधान मानता है कि सूची क्रमबद्ध हो गई है, जो कि नहीं है।

— हिस्टोक्रैट

उफ़। लगता है कि जब मैंने इस पर दोबारा गौर किया तो मैंने सवाल को अच्छी तरह से नहीं पढ़ा। किसी और चीज के साथ आने की कोशिश करेंगे।

— डानिएरो

@ हिस्टोक्रेट जो इसे करना चाहिए।

— दानिएरो

Answer 7

पायथन 2: 90 चार

n=100
s=sorted(int(raw_input())for i in range(n))
for i in range(n):print s[(4*i+4*i/n)%n]

आलसी प्रयास लेकिन सिर्फ शुरुआत के लिए

Answer 8

पायथन 48 = (148 - 100)

from random import*
x=[input()for i in range(100)]
while any(abs(x[i]-x[i+1])>1 for i in range(99)):n=randint(1,99);x=x[n:]+x[:n]
for j in x:print j

इसका परीक्षण नहीं किया गया है क्योंकि यह किसी भी उचित समय में चलने की गारंटी नहीं है (या संभावना नहीं है), लेकिन इसे अनंत समय के सिद्धांत पर काम करना चाहिए।

Comments

x=map(input,['']*100)

— बदसूरत

और मुझे नहीं लगता कि आपको अतिरिक्त []एस की भी जरूरत है , बस किसी भी एक चरित्र स्ट्रिंग।

— नौकरी

Answer 9

पायथन 27 (147 - 100 - 20)

R=range
def S(L):
 for i in R(len(L)-1):
    if L[i]>L[i+1]:L[i:i+2]=[L[i+1],L[i]];S(L)
a=map(input,['']*100);S(a)
for i in R(100):print a[i/2+i%2*50]

नोट: पहले रिक्त स्थान if L[i]>...एक टैब होना चाहिए, लेकिन स्पष्ट रूप से एक कोड ब्लॉक में रिक्त स्थान के रूप में दिखाई देगा।

Comments

R=rangeआप के साथ 5 अक्षर बचा सकता है।

— स्केलेवर

a=map(input,['']*100)

— बदसूरत

Answer 10

पर्ल 5: 95 - 120 = -25 चार्ट

निम्नलिखित कमांड लाइन की गणना:

perl -ne '$n=$_;splice@n,(grep{$n[$_]>$n}0..@n),0,$n}{print for map{@n[$_,$#n/2+$_+1]}0..$#n/2'

Answer 11

रूबी: -50 (70 वर्ण - 120)

मैंने कई अन्य उत्तरों के समान ही किया: पुनरावृत्त इनपुट सूची से अधिकतम और न्यूनतम निकालते हैं और उन्हें आउटपुट में जोड़ते हैं। हालांकि, मुझे एहसास हुआ कि यदि मध्यिका के दोनों ओर 2 संख्याएं स्वयं लगातार हैं, तो आउटपुट गलत होगा (क्योंकि उन 2 लगातार संख्याएं आउटपुट के अंत में एक साथ दिखाई देंगी)। इसे ठीक करने के लिए, मैं "एलीट" सूची को 1 तत्व से घुमाता हूं:

n=$*.map &:to_i;u=[];50.times{u+=n.minmax;n-=u.last 2};p *u.rotate(-1)

या, मनमाने ढंग से कई इनपुट के साथ काम करने के लिए (केवल 4 और वर्णों का उपयोग करके):

n=$*.map &:to_i;u=[];(u+=n.minmax;n-=u.last 2)while n.any?;p *u.rotate(-1)

नोट: कुछ कम-चार रूबी उत्तरों को पहले ही पोस्ट किया जा चुका है, लेकिन उन समाधानों ने माध्यिका मुद्दे को संबोधित नहीं किया (और / या एक सॉर्ट की गई इनपुट सूची मान ली गई)।

Answer 12

जे 37 - 100 = -63

({~?~@#)^:(+./@(1=|)@(2&(-/\))@/:)^:_

किसी प्रकार का उपयोग नहीं करता (हालांकि रैंक का उपयोग करता है) यादृच्छिक संख्याओं का उपयोग करता है।

स्पष्टीकरण:

({~?~@#)             NB. Randomizes the array
^: foobar ^:_        NB. as long as
foo =: +./@(1 = |)   NB. as any 1 == absolute value of
bar =: (2&(-/\))@/:  NB. differences between adjacent ranks
foobar =: foo@bar

Answer 13

ब्रेकीलॉग , 22 बाइट्स - 120 = -98

ṇịᵐpX¬{p≤₁s₂.&s₂p}∧Xẉᵐ

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

TIO लिंक में केवल एक सौ के बजाय आठ पूर्णांकों का इनपुट है, क्योंकि यह इतना भयानक रूप से धीमा है कि यह 60 सेकंड में किसी भी अधिक को संभाल नहीं सकता है। इसका कारण यह है कि, अन्य बातों के अलावा, अनिवार्य बोनस के लिए कुछ सरल लेकिन सामान्य सॉर्टिंग एल्गोरिदम को लागू करने के बजाय, मैं संक्षिप्तता के लिए उपयोग करता हूं कि एक नियतात्मक बोगोसॉर्ट के लिए क्या मात्राएं हैं:p≤₁ इनपुट के हर क्रमपरिवर्तन के माध्यम से पीछे जब तक यह एक नहीं पाता है। जो घटता नहीं है। हालांकि एक बड़ा कारण शायद यह होगा कि यह आउटपुट खोजने के लिए समान बल की एक समान डिग्री को नियोजित करता है, और यह कि यह हर बार सॉर्ट किए गए संस्करण को फिर से तैयार करता है ... मैंने इसे आकार 100 के वास्तविक इनपुट पर परीक्षण करने का प्रयास किया, लेकिन मैं निश्चित नहीं कि इसमें कितने दिन लगेंगे।

एक बेहतर संस्करण:

ब्रेकीलॉग , 14 बाइट्स - 20 = -6

p.¬{os₂.&s₂p}∧

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

यह संक्षिप्तता के लिए पुरातनपंथी I / O आवश्यकताओं की उपेक्षा करता है, और -100 बोनस लेने के लिए उपेक्षा करता है, इसलिए इसे संभवतः सुपर कंप्यूटर के बिना परीक्षण किया जा सकता है (हालांकि इसे लिखने के रूप में, मैंने इसे कई मिनटों के लिए केवल 20 आइटमों पर चलाया है और यह अभी भी मुझे कुछ नहीं दिया है)।

 .                The output is
p                 a permutation of
                  the input
  ¬{        }∧    such that it cannot be proven that
         s₂       a pair of adjacent values in
        &         the output
       .   p      is a permutation of
     s₂           a pair of adjacent values in
    o             the output sorted.

Comments

हालांकि यह बिल्कुल व्यावहारिक उत्तर नहीं है, लेकिन इसका उपयोग अन्य कार्यक्रमों से आउटपुट को मान्य करने के लिए किया जा सकता है, क्योंकि इसमें से अधिकांश केवल आउटपुट पर लगाए गए अवरोध का वर्णन कर रहे हैं।

— असंबद्ध स्ट्रिंग

Answer 14

फोर्थ (gforth) , 79 - 120 = -21 बाइट्स

: f 100 0 do dup i 2 mod 4 * 2 - i + i 99 = i 0 = - 3 * + cells + @ . cr loop ;

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

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

व्याख्या

0 से 99 तक सभी नंबरों के माध्यम से लूप। प्रत्येक नंबर के लिए (n):

• यदि n 0 है:
  • सरणी पते + 1 पर मान को आउटपुट करें
• और यदि n 99 है:
  • सरणी पते + 98 पर मूल्य को आउटपुट करें
• और यदि n विषम है:
  • सरणी पते + (n + 2) पर मान का उत्पादन

• एल्स (n सम है):

  • सरणी पते + (n - 2) पर मान का उत्पादन

• आउटपुट एक नई रेखा

कोड स्पष्टीकरण

: f               \ start new word definition
  100 0 do        \ loop from 0 to 99
    dup           \ duplicate the array address
    i             \ place the loop index on the stack
    2 mod 4 * 2 - \ convert to 2 if it's odd and -2 if it's even
    i +           \ add the result to the the loop index
    i 99 =        \ if i = 99 place -1 on top of the stack, else place a 0
    i 0 =         \ i i = 0 place -1 on top of the stack, else place 0
    - 3 *         \ subtract previous two results from each other and multiply by 3
\ the above line is used to avoid writing if/then by instead using math to get 98 and 1
    +             \ add result to existing result from above
    cells         \ multiply by the size of a single integer in memory
    +             \ add to the array's starting address
    @ . cr        \ get the value at the calculated address, print it, then print a newline
  loop            \ end the loop
;                 \ end the word definition