हॉलिडे गिफ्ट एक्सचेंज

11

हमारे आंतरिक गोल्फ से एक और समस्या ... पिछले साल छुट्टियों के आसपास यह एक।

मुसीबत

एंडी, बार, कार्ल, दीदी, अर्ल और फ्रान एक दूसरे के लिए उपहार खरीद रहे हैं। एक उपहार विनिमय के लिए नाम बनाएँ।

  1. प्रत्येक व्यक्ति एक उपहार खरीदता है और एक उपहार प्राप्त करता है।
  2. कोई भी अपना उपहार नहीं खरीदता है।
  3. समाधान को कई बार चलाने से अलग-अलग परिणाम प्राप्त होने चाहिए (दाता-रिसीवर जोड़ी को रन से रन के लिए अनुमानित या समान नहीं होना चाहिए)।

इनपुट

कोई नहीं।

आउटपुट

इस उदाहरण में वर्णित है:

एंडी बार बार के लिए
खरीदता है, कार्ल
कार्ल के लिए खरीदता है, कार्ल के लिए दीदी
दीदी के लिए खरीदता है, अर्ल
अर्ल के लिए, फ्रेंक के
लिए खरीदता है एंडी के लिए

code-golf 
— स्टीव
स्रोत
क्या आउटपुट को नाम से क्रमबद्ध किया जाना चाहिए?
— 15
@ बारह नग, आवश्यक नहीं।
— स्टीव
1
यह आज एक प्रश्न द्वारा दोहराया गया था और मैंने जो कीवर्ड खोजा था, उसने इसे चालू नहीं किया, इसलिए भविष्य की खोजों के लिए: अपमानजनक।
— पीटर टेलर

जवाबों:

4

जे, ५

(,.' buys for ',"1|.)(?~6){6 4$'AndyBarbCarlDidiEarlFran'

जैसे

   (,.' buys for ',"1|.)(?~6){6 4$'AndyBarbCarlDidiEarlFran'
Carl buys for Earl
Andy buys for Barb
Fran buys for Didi
Didi buys for Fran
Barb buys for Andy
Earl buys for Carl
— Eelvex
स्रोत
मुझे नहीं पता [जे], लेकिन अगर यह नाम अलग-अलग लंबाई के साथ होता है तो क्या यह काम करेगा?
— zx8754
नहीं। कोड इस तथ्य का फायदा उठाता है कि सभी नाम 4 वर्ण लंबे हैं। यह बहुत कम परिवर्तनों के साथ अलग-अलग लंबाई के लिए काम करेगा।
— बारहवीं
इससे यह भी पता चलता है कि लोगों की संख्या समान है। ध्यान दें कि यदि X Y को देता है, Y हमेशा X को भी देगा।
— Adám
3

c99 - 252 अक्षर

#include <stdio.h>
#define G for(i=0;i<6;i++)
char*n="Andy\0Barb\0Carl\0Didi\0Earl\0Fran",*p[7];int i,j;int main()
{FILE*r=fopen("/dev/random","r");G p[i]=n+5*i;G{j=fgetc(r)%6;p[7]=p[j]
;p[j]=p[i];p[i]=p[7];}G printf("%s buys for %s\n",p[i],p[(i+1)%6]);}

क्रमचय की परिपत्र प्रकृति का लाभ उठाकर थोड़ा सुधार। यह संस्करण हमेशा एक लूप जैसी खरीद की रणनीति बनाता है, इसलिए यह पिछले (271 वर्ण) संस्करण की तुलना में कम यादृच्छिक है, लेकिन मेरा मानना ​​है कि यह अभी भी कल्पना को पूरा करता है।

एक प्लेटफॉर्म की आवश्यकता है जिसमें एक काम हो /dev/random। मुझे \0बड़ी स्ट्रिंग में एस को छोड़ने से लगभग 8 बंद करने में सक्षम होना चाहिए , लेकिन मेरा लीवर %4sप्रिंट निर्दिष्ट के साथ काम नहीं कर रहा है जिस तरह से मैन पेज कहता है।

फेरबदल बुरा है, लेकिन इसे इस तरह से करना मुझे "फू के लिए फू खरीदता है" स्थितियों पर जांच करने से रोकता है ।

पठनीय:

#include <stdio.h>

char *n="Andy\0Barb\0Carl\0Didi\0Earl\0Fran",
  *p[7]; /* 7th cell for temp */
int i,j;

int main(){
  FILE*r=fopen("/dev/random","r");
  for(i=0;i<6;i++)
    p[i]=n+5*i;   /* Initialize the pointers */
  for(i=0;i<6;i++){
    j=fgetc(r)%6; /* Poor numeric properties. Cest le Code Golf */
    p[7]=p[j];
    p[j]=p[i];
    p[i]=p[7];
  }
  for(i=0;i<6;i++)
    printf("%s buys for %s\n",p[i],p[(i+1)%6]);
}
— dmckee --- पूर्व-मध्यस्थ बिल्ली का बच्चा
स्रोत
3

विंडोज पॉवरशेल, 83

$i=random 5
($n=-split'Andy Barb Carl Didi Earl Fran')|%{"$_ buys for "+$n[++$i%6]}

इतिहास:

  • 2011-02-11 22:01 (136) - पहला प्रयास।
  • 2011-02-11 22:05 (130) - कुछ बातों को रेखांकित किया। अब नामों को फेरबदल करना, अनुक्रमित नहीं।
  • 2011-02-13 16:13 (128) - मुझे मापांक की जरूरत नहीं है क्योंकि $iहर बार इसे फिर से बनाया जाएगा।
  • 2011-02-13 16:20    (87) - एनॉन से विचार उधार लिया । का सी # समाधान । बस एक यादृच्छिक ऑफसेट उत्पन्न करें और फिर उन्हें मंडलियों में उपहार दें।
  • 2011-02-13 16:26    (83) - यादृच्छिक संख्या में परिवर्तन और अनुक्रमण। $_को बचाने के लिए स्ट्रिंग में खींचा गया +।
— एक छोटा सा सिक्का
स्रोत
3

हास्केल, 241 189 वर्ण

import Data.List
import Random
main=randomRIO(0,719)>>=mapM_ putStrLn.f
f n=map(\(x,y)->x++" buys for "++y).zip(l n).tail$cycle$l n
l=(permutations(words"Andy Barb Carl Didi Earl Fran")!!)

पूरी तरह से यादृच्छिक आउटपुट (जो अभी भी कल्पना को संतुष्ट करता है)।

यह नामों की सूची के सभी क्रमचय उत्पन्न करता है, एक को यादृच्छिक पर चुनता है (मुझे लगता है कि यह हास्केल में सबसे छोटा तरीका है एक सूची में फेरबदल करने के लिए - अगर किसी के पास कुछ भी छोटा है, तो मैं इसकी सराहना करूँगा), और फिर प्रत्येक व्यक्ति तब खरीदता है सूची में अगले व्यक्ति के लिए मौजूद है।

— Anon।
स्रोत
मैंने इस एड-हॉक की कोशिश की, मैं श्योर
— FUZxxl
@ तोप: permutations$words"Andy Barb Carl Didi Earl Fran"और कुछ अन्य चालें मैंने अपने बेहतर संस्करण में आजमाई । मैं भूल गया, कि permutations98 में शामिल नहीं है List, इसलिए आपको लंबे नाम का उपयोग करना होगा। इस पर एक नज़र डालो।
— FUZxxl
और अपने विशेष उद्देश्य के लिए r=tail.cycle:। और इनलाइन से।
— FUZxxl
इसे 202 चार्ट तक नीचे लाया गया। एक नज़र डालें: paste.ubuntuusers.de/399799
— FUZxxl
1
और 189 वर्णों के लिए, मेरे उदाहरण में तीसरी पंक्ति को प्रतिस्थापित करें:main=randomRIO(0,719)>>=mapM_ putStrLn.f
— FUZxxl
3

गोल्फस्क्रिप्ट: 72 64 57 वर्ण

"AndyBarbCarlDidiEarlFran"4/{;9rand}${.n+\' buys for '}%(

टेस्ट

$ golfscript codegolf-838.gs 
Fran buys for Carl
Carl buys for Andy
Andy buys for Barb
Barb buys for Didi
Didi buys for Earl
Earl buys for Fran

$ golfscript codegolf-838.gs 
Didi buys for Earl
Earl buys for Andy
Andy buys for Barb
Barb buys for Carl
Carl buys for Fran
Fran buys for Didi
  • धन्यवाद gnibbler के लिए "AndyBarbCarlDidiEarlFran"4/, अद्यतन और 7 चार्ट कम मिला
  • 57 चार्ट समाधान मूल रूप से नायब: डी द्वारा दिया गया है, और यह भी देखा कि ;9randमेरे से अधिक यादृच्छिक है6rand*
— आप
स्रोत
1
"AndyBarbCarlDidiEarlFran"4/
— सूक्ति
आह हा, शुक्रिया @gnibbler, कूल, इसे अद्यतन करने के लिए जा रहा है।
— आप
सुनिश्चित नहीं हैं कि आप क्यों उपयोग कर रहे हैं 6rand*- 0=randया शायद ;9randबेहतर है। पाश के लिए, {.n+\' buys for '}%(छोटा है ..
— नाब
हे; J के साथ समान वर्ण हो गए: अब D और धन्यवाद @Nabb, मैंने उपयोग किया 6rand*क्योंकि मुझे लगा कि यह 6 आइटम सरणी को समान रूप से यादृच्छिक कर देगा (मुझे लगता है कि मैं गलत था, क्योंकि ;9randवास्तव में मेरी तुलना में यादृच्छिक दिखता है)
— You
3

जाप-आर, 41 बाइट्स

`AÌ)B¼C¤E¤FÎÂDi¹`qe ö¬ê1 ò mq` ¿ys f

-2 बाइट्स @ @ ओलिवर को धन्यवाद!

कोशिश करो!

यह वह दृष्टिकोण है जो मैंने उच्च स्तर पर लिया था:

  • प्रतिभागियों के नामों वाली एक स्ट्रिंग को अनप्लग करें
  • एक सरणी में स्ट्रिंग विभाजित करें
  • इसे फेर दो
  • प्रत्येक व्यक्ति को अगले उच्चतम सूचकांक वाले व्यक्ति को असाइन करें
  • सरणी में अंतिम व्यक्ति पहले को सौंपा गया है

इस समस्या के साथ मेरा थोड़ा इतिहास है क्योंकि मैंने वर्षों पहले अपने काम के लिए एक "गुप्त संता" कार्यक्रम बनाया था। हमने कुछ नौकरी आवेदकों से इसके माध्यम से काम करने के लिए कहा :)

— दाना
स्रोत
@ ओलिवर - सुझावों के लिए धन्यवाद! ऐसा लगता है कि यह ãउस जोड़ी को वापस नहीं कर रहा है जो पहले को अंतिम तत्व से जोड़ता है। मैं इसे प्राप्त करने के लिए एक तरह से काम कर रहा हूं, लेकिन सोचा कि मैं आपको बता दूंगा। हालांकि फिर से धन्यवाद! ethproductions.github.io/japt/…
— dana
43 ?
— दाना
1
आह, तुम सही हो। मुझे लगता है कि यह ४२
— ओलिवर
1
— ओलिवर
प्रतीक्षा करें कि डू "q"में .ö("q")क्या है
— ASCII-only
2

अजगर - 118 वर्ण

from random import*;L="Andy Barb Carl Didi Earl Fran".split()
for i in sample(range(6),6):print L[i-1],"buys for",L[i]

अजगर - 120 वर्ण

import random as R;L="Andy Barb Carl Didi Earl Fran".split();R.shuffle(L)
for i in range(6):print L[i-1],"buys for",L[i]
— gnibbler
स्रोत
1

पायथन - 154 वर्ण

import random as R;L="Andy Barb Carl Didi Earl Fran".split();M=L[:]
while any(map(str.__eq__,L,M)):R.shuffle(M) 
for i in zip(L,M):print"%s buys for %s"%i
— gnibbler
स्रोत
क्षमा याचना, मेरे पायथन में बहुत कमी है ... जब तक कि मूल रूप से लूपिंग नहीं होती है, जब तक कि यह एक समाधान नहीं ढूंढता है जो "एक्स एक्स के लिए खरीदता है"?
— स्टीव
@Steve: यह बहुत ज्यादा यह क्या करता है। एल और एम में संगत मूल्यों के प्रत्येक जोड़े पर mapकॉल str.__eq__करता है, और लूप तब तक चलता रहता है जब तक कि उनमें से कोई भी सच न हो।
— आनन।
@ सच, ​​हां। हालांकि यह शायद 1 से 5 तक यादृच्छिक राशि द्वारा रिकॉर्ड्स को शिफ्ट करने के लिए छोटा है, मुझे लगता है कि यह सवाल की भावना में नहीं है
— gnibbler
जब मैंने पहली बार प्रश्न को काम पर रखा, तो आप बिल्कुल सही हैं। मेरे सहकर्मियों ने जल्दी से कहा कि मेरी परिभाषाओं से इनकार नहीं किया गया था ... इसलिए मैंने इसे तब छोड़ दिया जब यहाँ पोस्टिंग थी।
— स्टीव
1

D: 233 वर्ण

import std.random,std.stdio;void main(){auto p=["Andy","Barb","Carl","Didi","Earl","Fran"];auto q=p.dup;o:while(1){for(int i;i<6;++i)if(p[i]==q[i]){randomShuffle(q);continue o;}break;}foreach(i,a;p)writefln("%s buys for %s",a,q[i]);}

अधिक कानूनी रूप से:

import std.random, std.stdio;

void main()
{
    auto p = ["Andy", "Barb", "Carl", "Didi", "Earl", "Fran"];
    auto q = p.dup;

    o:while(1)
    {
        for(int i; i < 6; ++i)
            if(p[i] == q[i])
            {
                randomShuffle(q);
                continue o;
            }

        break;
    }

    foreach(i, a; p)
        writefln("%s buys for %s", a, q[i]);
}
— जोनाथन एम डेविस
स्रोत
1

पायथन (175)

import random as r
n=['Andy','Barb','Carl','Didi','Earl','Fran']
m=n[:]
r.shuffle(m)
b=' buys for '
for i in n:
 h=m.pop()
 while h==i:
  m.append(h)
  h=m.pop()
 print(i+b+h)
— जॉन
स्रोत
1

स्कीम, 173

दो में से एक समाधान देता है।

(define(m lst)
    (printf"~v buys for ~v~n"(car lst)(cadr lst))
    (if(eq?(cadr lst)'Andy)0(m(cdr lst)))
)
(m((if(odd?(random 2))reverse values)'(Andy Barb Carl Didi Earl Fran Andy)))
1

सी #, 210 183 अक्षर

using System;class a{static void Main(){var n="Andy Barb Carl Didi Earl Fran".Split();var c=0,i=new Random().Next(1,6);for(;c<6;c++)Console.WriteLine(n[c]+" buys for "+n[(c+i)%6]);}}

बॉयलरप्लेट का ढेर :(

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

— Anon।
स्रोत
यही वह व्याख्या है जिसका मैं इरादा कर रहा था (और मूल रूप से इसका हल हम भी उतरा था)।
— स्टीव
210 होना चाहिए। क्या आप फ़ाइल के अंत में नई रेखा की गिनती कर रहे हैं?
— gnibbler
@gnibbler: मैं शायद था। मैं सिर्फ wc में फ़ाइल catted, मैं वास्तव में हाथ से गिनती नहीं जा रहा हूँ।
— आनन।
1
किस बारे में var n="Andy Barb Carl Didi Earl Fran".Split()? 16 बाइट बचाता है। आप तर्क को छोड़ सकते हैं Main(), जो एक और 9 बाइट्स बचाता है। और आप की घोषणा को जोड़ सकते हैं cऔर i: int c,i=...;for(c=0;...जो एक और दो बचाता है।
— जॉय
@ जॉय: आपके सुझावों के अनुसार, इसे धन्यवाद दिया।
— आनन।
0

रूबी - 89 वर्ण

(a=%w(Andy Barb Carl Didi Earl Fran).shuffle).zip(a.reverse).each{|e|puts e*' buys for '}

आउटपुट:

Andy buys for Didi
Barb buys for Earl
Fran buys for Carl
Carl buys for Fran
Earl buys for Barb
Didi buys for Andy
— steenslag
स्रोत
1
आप उपयोग कर सकते हैं mapके बजाय each।
— डॉगबर्ट
1
इस समाधान के साथ समस्या यह है कि आप लोगों के एक विषम संख्या मध्य व्यक्ति इच्छा उपहार है, तो खुद को अर्ल के लिए फ्रान मार्क खरीदता के लिए बार्ब एंडी खरीदता के लिए दीदी कार्ल खरीदता के लिए कार्ल दीदी खरीदता के लिए एंडी बार्ब खरीदता के लिए मार्क फ्रान खरीदता के लिए अर्ल खरीदता
— स्टडलीज
0

MathGolf , 41 बाइट्स

"δ%è╘+µ√♂JÇ"2/$╦╕ää▐δáw_╪" buys for "+m+n

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

व्याख्या

यह प्रत्येक मामले को समान संभावना के साथ उत्पादन करने की गारंटी नहीं है, लेकिन यह प्रत्येक रन के अलग-अलग परिणाम उत्पन्न करता है। यदि मेरे पास एक फेरबदल ऑपरेटर होता, तो एक बाइट को हटाया जा सकता था, लेकिन यह एक और दिन के लिए है।

"δ%è╘+µ√♂JÇ"                                push the string "δ%è╘+µ√♂JÇ"
            2/                              split into segments of two characters
              $                             transform to ordinals using base 256
               ╦                            fetch dictionary words (['Andy', 'barb', 'Carl', 'Earl', 'Fran'])
                ╕ää                         Push "didi"
                   ▐                        append to end of list
                    δ                       capitalize all strings in list
                     áw                     sort by random character in each string (shuffle)
                       _                    duplicate TOS
                        ╪                   right-rotate bits in int, list, str
                         " buys for "       push the string " buys for "
                                     +      Add to all strings in list
                                      m+    zip add the two arrays
                                        n   join array with newline
— maxb
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.