31

सकारात्मक पूर्णांकों की एक सरणी और दो अलग-अलग वैध सूचकांकों को देखते हुए, दो सूचकांकों की अदला-बदली के लिए दो तत्वों के साथ सरणी लौटाएं।

आप 0-इंडेक्सिंग या 1-इंडेक्सिंग का उपयोग करना चुन सकते हैं, लेकिन नीचे दिए गए टेस्टकेस 0-इंडेक्स किए जाएंगे।

array        m n output
[1,2,3,4]    0 1 [2,1,3,4]
[5,8,9]      0 2 [9,8,5]
[11,13,15,3] 1 2 [11,15,13,3]
[11,13,15,3] 2 1 [11,15,13,3]
[11,15,15,3] 2 1 [11,15,15,3]

यह कोड-गोल्फ है । बाइट्स जीत में सबसे छोटा जवाब। मानक खामियां लागू होती हैं।

code-golf array-manipulation

— लीक नन
स्रोत

संबंधित , संबंधित ।

— लीक नून

1

हुह, यह अच्छी तरह से एक कार्य हो सकता है कि कई गोल्फ भाषाओं के साथ कठिन समय होता है लेकिन अधिकांश व्यावहारिक भाषाएं आसान लगती हैं। (उत्परिवर्तित तत्वों की सूची गोल्फिंग भाषाओं के लिए एक सामान्य बात नहीं है।) अगर ऐसा है, तो यह काफी दिलचस्प होगा। (गोल्फिंग भाषाएं शायद अभी भी जीतेंगी, क्योंकि वे बहुत अधिक तनाव में हैं क्योंकि वे एक अधिक जटिल एल्गोरिथ्म के साथ दूर हो सकते हैं।)

7

हैरानी की बात यह है कि शायद यह एक धोखा नहीं है, लेकिन यह चुनौती वास्तव में रचनात्मक है, क्योंकि यह कई गोल्फ भाषाओं के लिए एक वास्तविक चुनौती है।

— आउटगोल्फ

@LeakyNun मुझे अतीत में (और यहां तक कि वोटों को हटाने के लिए) मिला है, इसके बारे में बहुत ज्यादा चिंता न करें ...

— द आउटगॉल्फ

कर सकते हैं mऔर nएक सरणी के रूप में लिया जा सकता है?

— ओकेक्स

17

सी/ C ++, 53 50 39 बाइट्स

f(a,m,n)int*a;{a[m]^=a[n]^=a[m]^=a[n];}

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

@Dennis के लिए धन्यवाद 11 बाइट्स सहेजे गए

— Ra8
स्रोत

10

ऑपरेशन फ्लैशपॉइंट स्क्रिप्टिंग भाषा, 98 95 बाइट्स

f={t=_this;a=t select 0;b=+a;m=t select 1;n=t select 2;a set[m,b select n];a set[n,b select m]}

सरणी को सीधे संशोधित करता है।

स्पष्टीकरण:

t=_this;                   // Give a shorter name for the array of arguments.

a=t select 0;              // Let 'a' be a pointer to the array that we modify.
                           // (The language doesn't have a concept of pointers really,
                           // yet its array variables are pointers to the actual array.)

b=+a;                      // Make a copy of the original array and save a pointer to it
                           // in the variable 'b'. This saves a few bytes later.

m=t select 1;              // Read the index arguments from the input array and save them
n=t select 2;              // to their respective variables.

a set[m,b select n];       // Do the swapping by reading the values from the copy and
a set[n,b select m]        // writing them to the original array. The last semicolon can
                           // be omitted because there are no more statements following 
                           // the last statement.

के साथ बुलाना:

array = [1,2,3,4];
str = format["%1", array];
[array, 0, 1] call f;
hint format["%1\n%2", str, array];

आउटपुट:

— Steadybox
स्रोत

7

जावास्क्रिप्ट ईएस 6, 36 32 बाइट्स

देखो, मा, कोई अस्थायी चर!

(a,m,n)=>[a[m],a[n]]=[a[n],a[m]]

4 बाइट्स ने नील को धन्यवाद दिया और इस सहमति को मेरे ध्यान में लाया।

कोशिश करो

& के aलिए 2 पूर्णांकों के तत्वों की अल्पविराम से अलग सूची दर्ज करें ।mn

f=
(a,m,n)=>[a[m],a[n]]=[a[n],a[m]]
oninput=_=>o.innerText=(f(b=i.value.split`,`,+j.value,+k.value),b);o.innerText=(f(b=(i.value="5,8,9").split`,`,j.value=0,k.value=2),b)

*{font-family:sans-serif}input{margin:0 5px 0 0;width:100px;}#j,#k{width:50px;}

<label for=i>a: </label><input id=i><label for=j>m: </label><input id=j type=number><label for=k>n: </label><input id=k type=number><pre id=o>

स्निपेट का विस्तार करें

— झबरा
स्रोत

2

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

— नील

@ नील: आप सिर्फ उपयोग करने के लिए कह रहे हैं (a,m,n)=>[a[m],a[n]]=[a[n],a[m]]? बाकी सरणी के बिना केवल 2 स्वैप किए गए तत्वों को आउटपुट करेगा (जैसे, [5,8,9],0,2-> [9,5])।

— शैगी

@ नील: सही है, यही कारण है कि हम की जरूरत है a हमें पूर्ण, संशोधित सरणी देने के लिए अंत में हमारी आवश्यकता है। या मैं पूरी तरह से याद कर रहा हूं कि आप क्या कहना चाह रहे हैं?

— शैगी

@ नील: हम्म ... ठीक है, मुझे लगता है कि मैं देख रहा हूँ कि अब क्या मिल रहा है (क्षमा करें, आज एक ही समय में बहुत सारे काम करने की कोशिश कर रहा है)। पारितोषिक के लिए धन्यवाद। क्या उस पर आम सहमति है और यदि ऐसा है, तो क्या इससे पहले कि मैं स्वयं इसकी खोज करूँ, क्या आपके पास कोई लिंक है?

— शैगी

1

codegolf.meta.stackexchange.com/a/4942/48934

— नील

5

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

-9 बाइट्स @ नॉटजगन को धन्यवाद

def f(a,m,n):a[m],a[n]=a[n],a[m]

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

इसके तर्क को संशोधित करता है, जो एक मान्य आउटपुट प्रारूप है ।

— OVS
स्रोत

3

यह अजीब है कि यह कैसे भी नहीं है कि बहुत मुहावरेदार अजगर कोड की तुलना है।

— कसज़ रोजाल्स्की

5

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

Ṛ,ḷyJ}ị

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

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

Ṛ,ḷyJ}ị  Main link. Left argument: [i, j]. Right argument: A (array)

Ṛ        Reverse; yield [j, i].
  ḷ      Left; yield [i, j].
 ,       Pair; yield [[j, i], [i, j]].
    J}   Indices right; yield all indices of A.
   y     Transliterate; replace j with i and i with j.
      ị  Index into A.

— डेनिस
स्रोत

आवरण के रूप में लगभग कार्यक्रम के रूप में लंबे समय तक है ...

— लीक नून

मैं कभी नहीं जानता था किy

— लीक नून

मैं इसके बारे में जानता था y, लेकिन इसका उपयोग करने के बारे में नहीं सोचा था। यह एक बहुत ही चतुर जवाब है।

यह मुझे सोच रहा है ... Jellyवैध जेली कोड है?

— M.Herzkamp

@ M.Herzkamp है। मुझे इसके असाधारण रूप से उपयोगी होने पर संदेह है।

— डेनिस

4

जाप , 17 16 बाइट्स

hV(A=UgV UgW¹hWA

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

ETHproductions के लिए एक बाइट धन्यवाद सहेजा गया

— टॉम
स्रोत

2

अच्छा लगा। आपको नहीं लगता कि आपको अल्पविराम की आवश्यकता है।

— ETHproductions

@ETHproductions धन्यवाद, आप सही हैं।

— टॉम

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

— शैगी

2

15 बाइट्स

— ETHproductions

4

MATL , 7 6 बाइट्स

yyP)w(

संकेत 1-आधारित हैं।

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

व्याख्या

आदानों पर विचार करें [11 13 15 3], [2 3]।

yy   % Take two inputs implicitly. Duplicate them
     % STACK: [11 13 15 3], [2 3], [11 13 15 3], [2 3]
P    % Flip
     % STACK: [11 13 15 3], [2 3], [11 13 15 3], [3 2]
)    % Reference indexing (pick indexed entries)
     % STACK: [11 13 15 3], [2 3], [15 13]
w    % Swap
     % STACK: [11 13 15 3], [15 13], [2 3]
(    % Assignment indexing (write values into indexed entries). Implicitly display
     % STACK: [11 15 13 3]

— लुइस मेंडो
स्रोत

4

सी # (.NET कोर) , 48 43 31 बाइट्स

(a,m,n)=>a[m]+=a[n]-(a[n]=a[m])

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

मूल सरणी में संख्याओं को स्वैप करता है, कोई अस्थायी चर का उपयोग नहीं करता है। फिर भी मैं इस उत्तर का श्रेय नहीं ले सकता क्योंकि यह नील का विचार है ।

— चार्ली
स्रोत

@ लीक यह काम करने के लिए नहीं लगता है, क्योंकि यह

— चार्ली

(a,m,n)=>a[m]+=a[n]-(a[n]=a[m])हालांकि काम करने लगता है।

— नील

(ये जवाब सभी ES6 जावास्क्रिप्ट में भी मान्य हैं, नहीं?)

— नील

4

आम लिस्प , 42 बाइट्स

-2 बाइट्स @coredump को धन्यवाद ।

(lambda(a i j)(rotatef(elt a i)(elt a j)))

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

काफी आगे सीधे, क्योंकि स्वैप करने के लिए एक आम लिस्प मैक्रो है rotatef:।

— बापू
स्रोत

आप आरिफ के बजाय ईएलटी इस्तेमाल कर सकते हैं

— coredump

1

@ कोर्डम्प राइट, धन्यवाद!

— दादा

3

जावास्क्रिप्ट ईएस 6, 36 34 बाइट्स

(a,m,n)=>(x=a[m],a[m]=a[n],a[n]=x)

-2 बाइट्स क्योंकि फ़ंक्शन एरे को बदल रहा है। सरणी वापस करने की कोई आवश्यकता नहीं है। @Neil को धन्यवाद

डेमो

कोड स्निपेट दिखाएं

f=

(a,m,n)=>(x=a[m],a[m]=a[n],a[n]=x)

let a1=[1,2,3,4], a2=[5,8,9], a3=[11,13,15,3]

f(a1,0,1);
f(a2,0,2);
f(a3,1,2);

console.log(JSON.stringify(a1)); //[2,1,3,4]
console.log(JSON.stringify(a2)); //[9,8,5]
console.log(JSON.stringify(a3)); //[11,15,13,3]

Expand snippet

— Weedoze
स्रोत

1

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

— नील

3

CJam , 4 बाइट्स

{e\}

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

— डेनिस
स्रोत

2

Java 8, 48 bytes

(a,b,c)->{int t=a[b];a[b]=a[c];a[c]=t;return a;}

Input:

int[] a
int b
int c

— Okx
स्रोत

जावा में तीन तर्कों के साथ लैम्ब्डा कैसे करते हैं?

— लीक नून

1

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

— नील

1

@LeakyNun मैं नहीं कर रहा हूँ Okx , लेकिन यहाँ एक है इसे अभी आज़माएं उदाहरण के साथ Okx की वर्तमान जवाब और कस्टम इंटरफेस।

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

1

और कार्लोस अलेजो के अद्भुत सी # उत्तर (@ नील की मदद के साथ) के आधार पर , आप अस्थायी चर से छुटकारा पाकर इसे और भी छोटा बना सकते हैं: (a,b,c)->a[b]+=a[c]-(a[c]=a[b])( 31 बाइट्स )

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

1

खांसी खांसी Collections::swap है 17 बाइट्स ... कम से कम यह सोचते हैं इस इस चुनौती के लिए रखती है ...

— सुकरात फीनिक्स

2

05AB1E , 10 बाइट्स

D²è³ǝ¹³è²ǝ

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

— Okx
स्रोत

2

ऑक्टेव , 28 बाइट्स

@(a,n){a(n)=a(flip(n)),a}{2}

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

यह वास्तव में एक के साथ संतुष्ट :)

प्रपत्र पर इनपुट लेता है:, f([1,2,3,4],[1,2])1-अनुक्रमित।

स्पष्टीकरण:

@(a,n)                         % Anonymous function that takes two 1-dimensional
                               % arrays as input
      {               , }      % Create a cell with two elements
       a(n)=a(flip(n))         % One element are the two number at indices given by
                               % the second input array. This will be a 1x2 array
      {a(n)=a(flip(n)),a}      % Place those two in a cell together with the entire array a
                               % a is now updated, thanks to Octave's inline assignment
      {a(n)=a(flip(n)),a}{2}   % Return the second element

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

2

जेलिफ़िश , 7 बाइट्स

p
ZRi
i

एक सूची और सूचकांक की एक जोड़ी लेता है। इसे ऑनलाइन आज़माएं!

व्याख्या

जेलीफ़िश के पास "सूचकांकों में आइटम संशोधित करें" फ़ंक्शन Zहोता है, जो कि वास्तव में हमारी ज़रूरत है। दोनों iने एसटीडीआईएन से इनपुट हासिल किए। Zदूसरे इनपुट के तर्क के रूप में लेता है, उलटा कार्य Rऔर सूची। फिर Zसंशोधन करता है, और pपरिणाम प्रिंट करता है।

— ज़गरब
स्रोत

2

आर, 38 बाइट्स

function(x,a,b){x[c(a,b)]=x[c(b,a)];x}

बल्कि लंबे समय से लगता है, लेकिन मैं इसे बहुत छोटा नहीं कर सकता। अफसोस की बात यह है कि यह स्पष्ट रूप से लौटने की xआवश्यकता {}है, फ़ंक्शन बॉडी के चारों ओर की आवश्यकता होती है। फ़ंक्शन तर्क के रूप pryr::f()में आवश्यकता की पहचान नहीं करता xहै इसलिए काम नहीं करता है: /।

— जद
स्रोत

मुझे लगता है कि function(x,i)replace(x,i,rev(i))प्रायर सिंटैक्स के साथ भी काम करेगा।

— ग्यूसेप

@Giuseppe आह, मैं स्वैप करने के लिए एक सुविधाजनक कार्य की तलाश कर रहा था, लेकिन गलत शब्दों के साथ खोज कर रहा था। बेझिझक पोस्ट करें कि खुद के जवाब के रूप में।

— JAD

@Giuseppe मुझे लगता है कि आपको करने की आवश्यकता है replace(x,i,x[rev(i)]), अन्यथा आप उनके मूल्यों के बजाय सूचकांकों को जगह देंगे।

— JAD

2

शेन्ज़ेन I / O, 735 बाइट्स

23 Power, 810 पॉवर, कोड की 48 लाइन्स

[traces] 
......................
......................
......................
......................
......................
......................
.14.14.14.............
.94.14.14.............
.A........1C..........
.3554..95556..........
.9554.16..............
.A....................
.2....................
......................

[chip] 
[type] UC6
[x] 4
[y] 2
[code] 
  slx x0
  mov x1 acc
  mov x1 dat
  mov acc x3
  mov dat x3
  mov acc x3
  mov dat x3

[chip] 
[type] UC6
[x] 8
[y] 5
[code] 
  slx x2
  mov x2 x1
  mov x0 dat
  mov x2 x1
  mov x0 acc
  mov x2 x1
  mov dat 

[chip] 
[type] UC4X
[x] 2
[y] 6
[code] 
  slx x0
  mov 0 x3
j:  mov x0 acc
  mov acc x2
  teq acc 0
- jmp j
  mov -999 x1

[chip] 
[type] RAM
[x] 5
[y] 6

अस्वीकरण: एरर्स इसमें 0-टर्मिनेटेड हैं। शेन्ज़ेन में I / O के साथ काम करने के लिए Arrays में दर्द होता है।

मैंने वास्तव में इस खेल के लिए एक भाप स्तर बनाया। आप इसे यहाँ खेल सकते हैं।

संपादित करें: Aaand मुझे सिर्फ एहसास हुआ कि मैंने कहा कि सरणी का आदेश दिया गया था। ओह।

— जंक मेल
स्रोत

साइट पर आपका स्वागत है यह वास्तव में अच्छा है! क्या आपको लगता है कि आप फ़ाइल में से कुछ व्हाट्सएप को हटाने में सक्षम हो सकते हैं और अभी भी शेन्ज़ेन IO फाइल को स्वीकार कर सकते हैं? मुझे नहीं पता कि आपने इसके साथ कितना फ़िड किया है, लेकिन आपको यह देखना चाहिए कि प्रारूप कितना लचीला है।

— गेहूं जादूगर

मैं इसके साथ नहीं खेला है! दूसरी ओर, मैं पहेली के लिए हेडर को कुल्हाड़ी मार रहा हूं जिसमें पहेली का नाम और समाधान का नाम है, इसलिए मुझे परेशान होने पर मुझे पता नहीं चलेगा।

— जंकमेल

1

स्विफ्ट, 111 65 बाइट्स (0-अनुक्रमित)

स्विफ्ट सबसे खराब कोड-गोल्फ भाषाओं में से एक होने के लिए पहले से ही कुख्यात है, लेकिन यहां एक फ़ंक्शन है ~~जो टर्नरी अभिव्यक्तियों का उपयोग करता है~~ :

func t(l:[Int],m:Int,n:Int){var r=l;r[m]=l[n];r[n]=l[m];print(r)}

इसकी जांच - पड़ताल करें! - उपयोग t(l:[1,2,3],m:0,n:1) :।

— मिस्टर एक्सकोडर
स्रोत

R के लिए एक डिफ़ॉल्ट परम का उपयोग करना आपको बाइट्स को बचाएगा और आप केवल पास किए गए सरणी को म्यूट कर सकते हैं (AFAIK स्विफ्ट सरणी को पास से पास करें)

— अधोगति

स्विफ्ट में डिफ़ॉल्ट पैरामीटर? मैं उसे कैसे कर सकता हूँ?

— श्री एक्सकोडर

और पैरामीटर स्विफ्ट @Downgoat में

— मिस्टर हैं

1

के ( कोना ), 13 बाइट्स

{x[y]:x@|y;x}

सुंदर बुनियादी, लेकिन यह काम करता है। उदाहरण के लिए:

k){x[y]:x@|y;x}[1 2 3 4; 0 1]
2 1 3 4

— साइमन मेजर
स्रोत

1

पर्ल 5 , 32 बाइट्स

-3 बाइट्स @ धन्यवाद हेस्टिंग्स !

कोड + -paझंडे के 30 बाइट्स ।

@F[pop@p,@p]=@F[@p=<>];$_="@F"

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

सरणी स्लाइस का उपयोग करते हुए सीधे आगे।

— बापू
स्रोत

हे हे, यह एक छोटे से tinkered और 3 बाइट्स को बचाने में कामयाब रहे! @F[pop@p,@p]=@F[@p=<>];$_="@F"।

— डोम हेस्टिंग्स

@DomHastings हम्म, अच्छा, हमेशा की तरह! धन्यवाद :)

— दादा

1

गणितज्ञ, 32 बाइट्स

(a=#;a[[{##2}]]=a[[{#3,#2}]];a)&

— alephalpha
स्रोत

3

a[[{##2}]]==a[[{#3,#2}]]होना चाहिए a[[{##2}]]=a[[{#3,#2}]](का उपयोग करते हुए Set, नहीं Equals)

— जंगवान मिन

1

सी, 42 बाइट्स

एक अस्थायी मान के साथ सरणी को संशोधित करें।

f(r,m,n){int*a=r;r=a[m];a[m]=a[n];a[n]=r;}

सी, 60 58 बाइट्स

थोड़ा और दिलचस्प, किसी भी अस्थायी मूल्य का उपयोग नहीं ...

f(a,m,n)int*a;{a[m]+=a[n];a[n]-=a[m];a[n]*=-1;a[m]-=a[n];}

सी, 49 बाइट्स

XOR का उपयोग करना

f(a,m,n)int*a;{a[m]^=a[n];a[n]^=a[m];a[m]^=a[n];}

— cleblanc
स्रोत

हे, मैं पोस्ट करने वाला था f(x,i,j,t)int*x;{t=x[i];x[i]=x[j];x[j]=t;}।

— डेनिस

@ डेनिस आपने मुझे दूसरे घोल पर दो बाइट्स बचा कर दिए, धन्यवाद!

— क्लेब्लांक

क्या दूसरा समाधान छोटा (और सुरक्षित) नहीं होगा ^?

— डेनिस

XOR संस्करण के लिए -1 एक फ़ंक्शन के बजाय एक परिभाषित का उपयोग करते हुए#define X(x,y,z)x[y]^=x[z],x[z]^=x[y],x[y]^=x[z]

— जियाको गारबेलो

f(r,m,n){int*a=r;r=a[m];a[m]=a[n];a[n]=r;}टूट गया है: SIGSEGV

— बोडो थेइसेन

1

पायथ , 17 8 बाइट्स

बची हुई 9 बाइट्स लीकी नॉम की बदौलत।

@LQ.rUQE

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

यह 0-अनुक्रमित है, और सूचकांक एक टपल के रूप में प्रदान किए जाते हैं (n, m):।

स्पष्टीकरण

@LQ.rUQE

     UQ     # Generate [0, 1, 2, ..., len(input)]
       E    # Get the indices as the tuple (1, 2)
   .r       # Translate each element of UQ to its cyclic successor in E
            # Now the indices are permuted (e.g. [0, 2, 1, ..., len(input)]
@LQ         # For each index, get it's value. Implicit print

— जिम
स्रोत

8 बाइट्स:@LQ.rUQE

— लीक नून

@ लीक यह इतना अलग है कि मुझे लगता है कि आप इसे अपने लिए पोस्ट कर सकते हैं!

— जिम

मैं ओपी हूं; मैं अपनी चुनौती नहीं देता।

— लीक नन

1

गणितज्ञ, 20 बाइट्स

#~Permute~Cycles@#2&

निम्नलिखित 1-अनुक्रमित (और संभवतः अपमानजनक) प्रारूप में दो तर्क लेने वाला शुद्ध कार्य: दूसरा परीक्षण मामला [5,8,9]; 0 2; [9,8,5]कहा जाएगा

#~Permute~Cycles@#2& [ {5,8,9} , {{1,3}} ]

(रिक्त स्थान बाहरी और बस दृश्य पार्सिंग के लिए हैं)। Permuteबिलिन फ़ंक्शन एक सूची में एक क्रमपरिवर्तन लागू करता है, और Cycles[{{a,b}}]उस आदान-प्रदान का प्रतिनिधित्व करता है जो एक्सचेंज करता हैa वें और bवें तत्वों का करता है और बाकी की उपेक्षा करता है।

— ग्रेग मार्टिन
स्रोत

क्या करते ~हो?

— साइओस

~एक बाइनरी फ़ंक्शन के लिए मैथेमेटिका का इन्फिक्स अंकन है: x~f~yइसका मतलब उसी चीज़ के रूप में है f[x,y]।

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

1

x86 मशीन कोड, 10 बाइट्स

8B 04 8B 87 04 93 89 04 8B C3

यह 32-बिट x86 मशीन कोड में लिखा गया एक फ़ंक्शन है जो किसी दिए गए सरणी में निर्दिष्ट सूचकांकों पर मूल्यों को स्वैप करता है। सरणी है जगह में संशोधित किया गया है , और फ़ंक्शन एक मान नहीं लौटाता है।

एक कस्टम कॉलिंग कन्वेंशन का उपयोग किया जाता है, जिसके लिए फ़ंक्शन के मापदंडों की आवश्यकता होती है रजिस्टरों में पारित करना आवश्यक है :

सरणी का पता (इसके पहले तत्व के सूचक) EBXरजिस्टर में पारित किया गया है ।
तत्व ए का शून्य-आधारित सूचकांक में पारित किया गया है ECX रजिस्टर ।
_{(मान्य सूचकांक माना जाता है।)}
तत्व बी का शून्य-आधारित सूचकांक EDXरजिस्टर में पारित किया गया है ।
_{(मान्य सूचकांक माना जाता है।)}

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

Ungolfed:

8B 04 8B     mov  eax, DWORD PTR [ebx+ecx*4]   ; get value of element A
87 04 93     xchg eax, DWORD PTR [ebx+edx*4]   ; swap element A and element B
89 04 8B     mov  DWORD PTR [ebx+ecx*4], eax   ; store new value for element A
C3           ret                               ; return, with array modified in-place

— कोडी ग्रे
स्रोत

1

आर, 34 बाइट्स

pryr::f(`[<-`(a,c(m,n),a[c(n,m)]))

— स्वेन होहेंस्टीन
स्रोत

1

जावा 8 + व्युत्क्रम , 27 बाइट्स

java.util.Collections::swap

बस स्वैप फ़ंक्शन को कॉल करता है ... यह एक विधि का प्रकार है Consumer3<List, Integer, Integer>।

इसे ऑनलाइन आज़माएं! (बायलरप्लेट और Consumer3इंटरफ़ेस की प्रतिलिपि के लिए हेडर और पाद लेख )

— सोक्रेटिक फीनिक्स
स्रोत

आपको "+ व्युत्क्रम" जोड़ने की आवश्यकता नहीं है। यह वैनिला जावा 8 में मान्य है।

— ओलिवियर ग्रेजायर

1

जावास्क्रिप्ट (ES2015), 66 57 49 बाइट्स

पिछले जावास्क्रिप्ट उत्तरों की तुलना में एक अलग (और अधिक लंबा) दृष्टिकोण

(s,h,o,w=s.splice.bind(s))=>w(h,1,...w(o,1,s[h]))

स्रोत

const swap = (arr, a, b, splice) => {
  splice(a, 1, ...splice(arr[b], 1, arr[a]))
}

— sshow
स्रोत

1

(s,h,o,w=s.splice.bind(s))=>w(h,1,...w(o,1,s[h]))49 बाइट्स

— पैट्रिक रॉबर्ट्स

उनके बारे में भूल चूक आ गई। धन्यवाद!

— sshow

0

awk, 31 बाइट्स

{c=$a;$a=$b;$b=c;a=$1;b=$2}NR>1

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

प्रारूप में इनपुट लेता है

1 2
1 2 3 4

और आउटपुट के रूप में

2 1 3 4

(1 अनुक्रमित)।

व्याख्या

संपूर्ण प्रोग्राम एक लापता पैटर्न है जिसमें एक एक्शन होता है और उसके बाद एक मिसिंग एक्शन होता है।

चूंकि एक लापता पैटर्न प्रत्येक पंक्ति पर चलता है, ब्रेसिज़ के अंदर का कोड दोनों इनपुट लाइनों के लिए चलता है। c=$a;$a=$b;$b=c;भाग सूचकांकों में दो मानों स्वैप aऔर b(अस्थायी चर के माध्यम से c)। यह केवल दूसरी पंक्ति पर प्रभाव डालता है, क्योंकि पहली पंक्ति पर aऔर bअभी तक परिभाषित नहीं किया गया है। a=$1;b=$2भाग परिभाषित करता है aपहले क्षेत्र होने के लिए औरb दूसरा क्षेत्र है, जो दूसरी पंक्ति पर चलाने के लिए पहले भाग के लिए उपयुक्त मान सेट किया जाना है।

चूंकि एक लापता कार्रवाई के बराबर है {print}, पैटर्न प्रत्येक पंक्ति को प्रिंट करता है जो इसे मेल खाता है। विशेष रूप से यह पैटर्न है NR>1: अर्थात, जब भी लाइन संख्या 1 से अधिक हो, प्रिंट करें, जो कि लाइन 2 होती है। मानों की अदला-बदली के बाद यह चलता है, इस प्रकार कार्य पूरा होता है।

— Doorknob
स्रोत

0

क्यू / केडीबी +, १tes बाइट्स

समाधान:

{@[x;(|)y;:;x y]}

उदाहरण:

q){@[x;(|)y;:;x y]}[1 2 3 4;0 1]
2 1 3 4

स्पष्टीकरण:

शमौन द्वारा कश्मीर उत्तर का एक q संस्करण। :सूचकांकों पर x से असाइन किए गए फ़ंक्शन को y पर अनुक्रमित x के मान के साथ रिवर्स-वाई पर लागू करें । टूट गया आप और अधिक स्पष्ट रूप से देख सकते हैं:

q)x:1 2 3 4
q)y:0 1
q)x y
1 2
q)(|)y
1 0
q)x(|)y
2 1
q)@[x;(|)y;:;x y]
2 1 3 4

— streetster
स्रोत

दिए गए दो सूचकांकों को स्वैप करें

सी/ C ++, 53 50 39 बाइट्स

ऑपरेशन फ्लैशपॉइंट स्क्रिप्टिंग भाषा, 98 95 बाइट्स

जावास्क्रिप्ट ईएस 6, 36 32 बाइट्स

कोशिश करो

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

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

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

जाप , 17 16 बाइट्स

MATL , 7 6 बाइट्स

व्याख्या

सी # (.NET कोर) , 48 43 31 बाइट्स

आम लिस्प , 42 बाइट्स

जावास्क्रिप्ट ईएस 6, 36 34 बाइट्स

डेमो

CJam , 4 बाइट्स

Java 8, 48 bytes

05AB1E , 10 बाइट्स

ऑक्टेव , 28 बाइट्स

जेलिफ़िश , 7 बाइट्स

व्याख्या

आर, 38 बाइट्स

शेन्ज़ेन I / O, 735 बाइट्स

स्विफ्ट, 111 65 बाइट्स (0-अनुक्रमित)

के ( कोना ), 13 बाइट्स

पर्ल 5 , 32 बाइट्स

गणितज्ञ, 32 बाइट्स

सी, 42 बाइट्स

सी, 60 58 बाइट्स

सी, 49 बाइट्स

पायथ , 17 8 बाइट्स

गणितज्ञ, 20 बाइट्स

x86 मशीन कोड, 10 बाइट्स

आर, 34 बाइट्स

जावा 8 + व्युत्क्रम , 27 बाइट्स

जावास्क्रिप्ट (ES2015), 66 57 49 बाइट्स

awk, 31 बाइट्स

व्याख्या

क्यू / केडीबी +, १tes बाइट्स