4, 8, 15, 16, 23, 42 [बंद]

Question

4, 8, 15, 16, 23, 42

एक प्रोग्राम लिखें जो संख्याओं के इस क्रम को असीम रूप से आउटपुट करता है। हालाँकि, नंबर आपके स्रोत कोड में कहीं भी दिखाई नहीं देना चाहिए।

निम्नलिखित संख्याओं को आउटपुट करने के लिए एक मान्य जावा प्रोग्राम नहीं है क्योंकि नंबर अपने स्रोत कोड में दिखाई देते हैं:

class TheNumbers {
    public static void main(String[] args) {
        for(int n = 0;;) System.out.println(
            n == 4 ? n = 8 :
            n == 8 ? n = 15 :
            n == 15 ? n = 16 :
            n == 16 ? n = 23 :
            n == 23 ? n = 42 : (n = 4)
        );
    }
}

"संख्या आपके स्रोत कोड में प्रकट नहीं होनी चाहिए" की परिभाषा इस प्रकार है:

• आपको अंक 4 का उपयोग नहीं करना चाहिए।
• आपको अंक 8 का उपयोग नहीं करना चाहिए।
• आपको अंक 5 के बाद अंक 1 का उपयोग नहीं करना चाहिए।
• आपको अंक 6 के बाद अंक 1 का उपयोग नहीं करना चाहिए।
• आपको अंक 3 के बाद अंक 2 का उपयोग नहीं करना चाहिए।

यदि आपकी भाषा कुछ वर्णों को अनदेखा करती है, जिन्हें अंकों के बीच रखा जा सकता है, तो यह एक वैध प्रतिस्थापन नहीं है। इसलिए उदाहरण के लिए यदि आपकी भाषा शाब्दिक 1_5रूप से व्याख्या करती है 15, तो यह अंक 1 के रूप में गिना जाएगा और उसके बाद अंक 5 होगा।

वैकल्पिक आधार प्रतिबंध में शामिल हैं, इसलिए उदाहरण के लिए:

• बाइनरी 100 को 4 के विकल्प के रूप में इस्तेमाल नहीं किया जा सकता है।
• ऑक्टल 10 को 8 के विकल्प के रूप में इस्तेमाल नहीं किया जा सकता है।
• हेक्साडेसिमल एफ को 15 के विकल्प के रूप में इस्तेमाल नहीं किया जा सकता है।

इसलिए, निम्नलिखित संख्याओं के आउटपुट के लिए एक मान्य (लेकिन बहुत प्रेरित नहीं) जावा प्रोग्राम है क्योंकि नंबर अपने स्रोत कोड में प्रकट नहीं होते हैं:

class TheNumbers {
    public static void main(String[] args) {
        for(int n = '*';;) {
            System.out.println(n -= '&');
            System.out.println(n *= 2);
            System.out.println(n += 7);
            System.out.println(++n);
            System.out.println(n += 7);
            System.out.println(n += 19);
        }
    }
}

ध्यान दें कि उस कार्यक्रम में, '*'और '&'पूर्णांक 42 और 38 के लिए प्रतिस्थापित किया गया है, क्योंकि अन्यथा अंक 4 और 8 इसके स्रोत कोड में दिखाई देंगे।

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

कुडोस यदि आप किसी तरह से अनुक्रम उत्पन्न करने में सक्षम हैं जो मूल रूप से प्रत्येक संख्या में हार्ड-कोडिंग नहीं है।

• इसे एक सूत्र में बांटना। मेरी धारणा है कि कोई एक नहीं है, लेकिन हो सकता है कि यह नकली हो।
• अनुक्रम को वापस करने के लिए एक छद्म यादृच्छिक जनरेटर को ठीक करना।

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

Comments

मैं 6

— डाउनवोट

@ वीरोस, "यह एक बेवकूफ सवाल है" बहुत रचनात्मक नहीं है, यही कारण है कि कोई भी इसे एक टिप्पणी के रूप में पोस्ट नहीं कर सकता है।

— पीटर टेलर

इस दुनिया में 11 प्रकार के लोग हैं: वे जो लॉस्ट को देखते थे , वे जो नहीं करते थे, और वे जो बाइनरी को नहीं समझते हैं।

— स्क्वीश ओस्फ़रेज

@PeterTaylor यकीन के लिए, लेकिन नए लोगों को ज्यादातर यह नहीं मिलेगा और अपने भविष्य के सवालों को सुधारने की कोशिश करने के बजाय साइट छोड़ दें। मुझे लगता है कि This isn't an interesting question, IMHO, since the solution is pretty trivial. Please post in the sandbox next time.इससे बेहतर तरीका होगा This is a stupid question., लेकिन यह सिर्फ मेरी निजी राय है।

— वीरोस

मैंने देखा कि प्रश्न अन्य नंबरों के आउटपुट पर प्रतिबंध नहीं लगाता है । तो कम से कम अनंत-बंदर-सिद्धांत के अनुसार एक अनैच्छिक छद्म यादृच्छिक संख्या जनरेटर को चाल करना चाहिए।

— कोजिरो

Answer 1

जावा

मैंने एक और प्रविष्टि जोड़ने का फैसला किया क्योंकि यह मेरे पहले वाले से पूरी तरह से अलग है (जो एक उदाहरण की तरह था)।

यह प्रोग्राम उपयोगकर्ता द्वारा दर्ज की गई सरणी के औसत की गणना करता है ...

import java.util.Scanner;

public class Numbers {
    public static double getSum(int[] nums) {
        double sum = 0;
        if(nums.length > 0) {
            for(int i = 0; i <= nums.length; i++) {
                sum += nums[i];
            }
        }

        return sum;
    }

    public static double getAverage(int[] nums) { return getSum(nums) / nums.length; }
    public static long roundAverage(int[] nums) { return Math.round(getAverage(nums)); }

    private static void beginLoop(int[] nums) {
        if(nums == null) {
            return;
        }

        long avg = roundAverage(nums);
        System.out.println("enter nums for average");
        System.out.println("example:");
        System.out.print("array is " + nums[0]);
        for(int i = 1; i <= nums.length; i++) {
            System.out.print(", " + nums[i]);
        }

        System.out.println();
        System.out.println("avg is " + avg);
    }

    private static int[] example = { 1, 2, 7, 9, };

    public static void main(String[] args) {
        boolean done = false;
        while(!done) {
            try {
                int[] nums = example;
                beginLoop(nums);

                nums = getInput();
                if(nums == null) {
                    done = true;
                } else {
                    System.out.println("avg is " + getAverage(nums));
                }
            } catch(Exception e) {
                e.printStackTrace();
            }
        }
    }

    static int[] getInput() {
        Scanner in = new Scanner(System.in);
        System.out.print("enter length of array to average or 0 to exit: ");
        int length = in.nextInt();
        if(length == 0) {
            return null;

        } else {
            int[] nums = new int[length];
            for(int i = 0; i <= nums.length; i++) {
                System.out.print("enter number for index " + i + ": ");
                nums[i] = in.nextInt();
            }
            return nums;
        }
    }
}

... या करता है?

java.lang.ArrayIndexOutOfBoundsException: 4
    नंबर पर ।getSum (नंबर.java:8)
    नंबर पर। लाभ (नंबर। java: 15)
    नंबर पर। आसपास का लाभ (नंबर.जवा:16)
    नंबर पर .beginLoop (नंबर.जवा:23)
    नंबर पर ।.main (नंबर.जवा:42)
java.lang.ArrayIndexOutOfBoundsException: 4
    नंबर पर ।getSum (नंबर.java:8)
    नंबर पर। लाभ (नंबर। java: 15)
    नंबर पर। आसपास का लाभ (नंबर.जवा:16)
    नंबर पर .beginLoop (नंबर.जवा:23)
    नंबर पर ।.main (नंबर.जवा:42)
java.lang.ArrayIndexOutOfBoundsException: 4
    नंबर पर ।getSum (नंबर.java:8)
    ...

Comments

यह भी खूब रही! मैंने ऐसा कुछ नहीं सोचा होगा।

— जोर्डन बियोनडो

वाह सुंदर ! महान विचार;)

— पियरे अरलाउड

प्रतिभाशाली! हालांकि आउटपुट थोड़ा वर्बोज़ है, लेकिन मुझे लगता है कि आपके द्वारा यहां चुनी गई भाषा के साथ क्या करना है। ;)

— पीटर विटोवेट

जब मैंने सोचा कि पायथन "लिज़्ट = लॉस्ट प्लॉट" एक टॉप नहीं किया जा सकता है ...

— डेव

@ अन्याय यह वास्तव में मुझे लगता है कि यह थोड़ी देर के लिए शीर्ष जवाब था। मेरे अपने सवाल को जीतने का कोई मज़ा नहीं है।

— रेडियोडफ

Answer 2

अजगर

#!/usr/bin/python
lizt = ["SPOI",
        "LERS: Lo",
        "st begins with ",
        "a plane crash on",
        "a desert island and end",
        "s with its viewers stuck in limbo forever."
        ]

while True:
    for item in lizt:
        print len(item)

संपादित करें: nneonneo के सुझाव के अनुसार, स्क्रिप्ट में अब कोई अंक शामिल नहीं हैं।

Comments

इतना सरल, और फिर भी इतना अच्छा।

— कोनराड बोरोस्की

इस प्रश्न के उत्तर पर मेरा वोट पूरी तरह से निर्भर करता है या नहीं: क्या "लिज़्ट" की वर्तनी "आर्टेक्स" है? संपादित करें: मैं किससे मजाक कर रहा हूं, यह किसी भी तरह मेरा वोट बन जाता है।

— प्लूटोर

मैं लिखूंगा while True:ताकि आपके उत्तर में कोई अंक न हो।

— nneonneo

while True:अधिक सामान्य है।

— मार्टिन यूडिंग

क्या यह "कोई वैकल्पिक आधार" नियम को खराब नहीं करता है? मूल रूप से, यह बस आधार नंबर की एक सरणी है :-)

— डैनियल

Answer 3

पर्ल

सोर्स कोड में कुछ भी छिपा नहीं है। नहीं। यदि कोड काम नहीं करता है, तो use re "eval";इससे पहले टाइप करें (पर्ल 5.18 में आवश्यक)।

''=~('('.'?'.('{').(
'`'|'%').('['^'-').(
"\`"| '!').('`'|',')
.'"'. '\\' .'@'.('`'
|'.') .'=' .'('.('^'
^('`'       |"\*")).
','.("\:"& '=').','.
('^'^('`'| ('/'))).(
'^'^("\`"| '+')).','
.('^'^('`'|('/'))).(
'^'^('`'|'(')).','.(
'^'^('`'|',')).('^'^
("\`"|     '-')).','
.('^' ^('`' |'*')).(
'^'^( "\`"| (','))).
(')').     ';'.('['^
','). ('`'| ('(')).(
"\`"| ')'). ('`'|','
).('`'     |'%').'('
.'\\'.'$'.'|'."\=".(
'^'^('`'|'/'))."\)".
'\\'.'{'.'\\'."\$".(
"\["^ '/')       .((
'=')  ).+( '^'^('`'|
'.' ) ).(( (';'))).(
"\`"| '&').     ('`'
|'/') .('['^')') .((
'(')) .''. '\\'. '@'
.+(     '`'     |'.'
).')'.'\\'.'{'.('['^
'(').('`'|',').('`'|
'%').('`'|'%').('['^
'+'). '\\'.     '$'.
'_'.  '-'. '\\'. '$'
.+( ( '[') ^'/').';'
.'\\' .'$'      .''.
('['^ '/') .'='. (((
'\\') )).+ "\$". '_'
.((     ';'     )).+
'\\'.'$'.'_'.'='.'='
.('^'^('`'|'*')).'|'
.'|'.('['^'+').('['^
')'     ).(     '`'|
(( ')')) ) .('`' |((
'.'))).( '['^'/' ).+
(((     (((     '\\'
)) )))).'"'.('{' ^((
(( '[')))) ).''. (((
((       ((     '\\'
))))))).'"'.';'.('['
^'+').('['^')').('`'
|')').('`'|'.').('['
^+ '/').''.     '\\'
.+ '}'. +( "\["^ '+'
). ('[' ^"\)").( '`'
|+       ((     ')')
)).('`' |+ '.').('['
^'/').( (( '{'))^'['
).'\\'. ((       '"'
)).('!'^'+').('\\').
'"'.'\\'.'}'.(('!')^
'+').'"'.'}'.')');$:
='.'#madebyxfix#'.'=
^'~';$~='@'|"\(";#;#

स्पॉइलर में स्पष्टीकरण।

यह एक सरल पर्ल प्रोग्राम है जो कई बिटवाइज़ ऑपरेशंस का उपयोग करता है, और = ~ ऑपरेटर का उपयोग करके नियमित अभिव्यक्ति का मूल्यांकन करता है । रेगेक्स (({के साथ समाप्त होता है )) से शुरू होता है । पर्ल में, यह नियमित अभिव्यक्ति का मूल्यांकन करते हुए कोड चलाता है - यह मुझे वास्तव में इसका उपयोग किए बिना eval का उपयोग करने देता है। आम तौर पर, हालांकि, सुरक्षा कारणों से , पुन: "eval" की आवश्यकता होती है, जब स्ट्रिंग्स से नियमित अभिव्यक्ति का मूल्यांकन करते हैं (कुछ पुराने प्रोग्राम वास्तव में उपयोगकर्ता से नियमित अभिव्यक्ति लेते हैं) - लेकिन यह पता चलता है कि पर्ल 5.18 से पहले एक बग था जो लगातार मुड़े हुए भाव पैदा करता था इस प्रैग्म के बिना भी काम करने के लिए - यदि आप पर्ल 5.18 का उपयोग कर रहे हैं, तो टाइप करें re "eval";कोड से पहले यह काम करने के लिए। इसके अलावा, इस कोड के लिए बहुत कुछ नहीं है।

Comments

मैं इस तरह दिखना शुरू कर रहा हूं, लेकिन मैं अभी भी इसे नहीं देख रहा हूं ..

— rururand

@xfix "यह एक सरल पर्ल प्रोग्राम है" - यदि यह मामला है, तो मुझे एक जटिल देखने से नफरत होगी।

— माइकइलियार

अरे देखो, यह एक schooner है।

— रोजी

@ अरोपी हाहा, तुम गूंगे कमीने। यह एक schooner नहीं है, यह एक SAILBOAT है!

— माइकइलियार

Protip: Notepad ++ पर कॉपी / पेस्ट करें और सभी तरह से ज़ूम आउट करें।

— माइकइलियार

Answer 4

Brainfuck

मैं ASCII कला में बहुत बुरा हूँ!

++        ++++++++    +[>+>++    ++>++++
+<        <<-]>++>    >-           --<
<<        +[    >>    >.<.>++      ++.
<.        >-    --    ----.++      ++.
<.>---    -.+++++.         <.      >--
-/-./+    .<.>+.-/    -.++<<.      </]

इसे यहाँ टेस्ट करें: http://ideone.com/kh3DYI

Comments

यह एक बहुत अच्छा समाधान है :)

— gilbertohasnofb

Answer 5

यूनिक्स सी

संख्यात्मक स्थिरांक खोजने के लिए बहुत सारे स्थान हैं।

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <errno.h>
#include <limits.h>
#include <signal.h>
#include <fcntl.h>
#include <pwd.h>
#include <netdb.h>

int main(void)
{
  int thenumbers[] = {
    S_IRGRP|S_IXGRP|S_IWOTH,
    ntohs(getservbyname("telnet", "tcp")->s_port),
    exp(M_E)-cos(M_PI),
    SIGTERM,
    CHAR_BIT,
    strlen(getpwuid(EXIT_SUCCESS)->pw_name)
  }, i=sizeof(thenumbers)/sizeof(*thenumbers);
  while(i--)
    printf("%d\n", thenumbers[i]);
  return main();
}

Comments

यहाँ सरल स्थानापन्न होने के लिए मोटापा बहुत सर्वोच्च है।

— रेडियोडफ

क्या यह रिकर्सन के कारण स्टैक ओवरफ्लो में नहीं चलता है?

— स्की

@Skirmantas मुझे लगता है कि सभी संकलक इसके लिए पूंछ-पुनरावृत्ति का उपयोग करेंगे (उदाहरण के लिए कॉल को मुख्य के साथ एक जंप के साथ बदलें)।

— टायिलो

Answer 6

सी#

फॉर्मूला "चोरी" https://oeis.org/A130826 से : (n) सबसे छोटी संख्या है, जैसे कि (a (n) -n) / 3 के विभाजकों की संख्या पहले में n-th शब्द देती है फ़्लेवियस-जोसेफस चलनी द्वारा निर्मित अनुक्रम के अंतर।

using System;
using System.Collections.Generic;
using System.Linq;

public static class LostNumberCalculator
{
    public static int GetNumber(int i)
    {
        int a = GetPairwiseDifferences(GetFlaviusJosephusSieveUpTo(100)).ElementAt(i);
        int b = FindSmallestNumberWithNDivisors(a / 2);
        return b * 3 + i + 1;
    }

    public static IEnumerable<int> GetFlaviusJosephusSieveUpTo(int max)
    {
        List<int> numbers = Enumerable.Range(1, max).ToList();

        for (int d = 2; d < max; d++)
        {
            List<int> newNumbers = new List<int>();
            for (int i = 0; i < numbers.Count; i++)
            {
                bool deleteNumber = (i + 1) % d == 0;
                if (!deleteNumber)
                {
                    newNumbers.Add(numbers[i]);
                }
            }
            numbers = newNumbers;
        }

        return numbers;
    }

    public static IEnumerable<int> GetPairwiseDifferences(IEnumerable<int> numbers)
    {
        var list = numbers.ToList();
        for (int i = 0; i < list.Count - 1; i++)
        {
            yield return list[i + 1] - list[i];
        }
    }

    public static int FindSmallestNumberWithNDivisors(int n)
    {
        for (int i = 1; i <= int.MaxValue; i++)
        {
            if (CountDivisors(i) == n)
            {
                return i;
            }
        }
        throw new ArgumentException("n is too large");
    }

    public static int CountDivisors(int number)
    {
        int divisors = 0;
        for (int i = 1; i <= number; i++)
        {
            if (number % i == 0)
            {
                divisors++;
            }
        }
        return divisors;
    }
}

class Program
{
    static void Main(string[] args)
    {
        while (true)
        {
            for (int i = 0; i < 6; i++)
            {
                int n = LostNumberCalculator.GetNumber(i);
                Console.WriteLine(n);
            }
        }
    }
}

Comments

+1 किसी ऐसे व्यक्ति के लिए जो वास्तव में oeis.org पर गया था जो अनुक्रम को फिट करने वाले सूत्र पर शोध करने के लिए :)

— MrPaulch

a(i)=a(i-1)+a(i-3)+a(i-5)वास्तव में एक आसान समाधान की तरह लगता है

— क्रंचर

@ क्रंचर वह सूत्र आपको पहले 5 शब्दों (4, 8 और 15 सहित) को पूर्वनिर्धारित करने की आवश्यकता है, जो उबाऊ और नियमों के विरुद्ध है।

— सेबेस्टियन नेग्रास्ज़स

Answer 7

सी#

इस तथ्य का उपयोग करते हुए कि एन तत्वों के किसी भी अनुक्रम को एन -1 बहुपद द्वारा उत्पन्न किया जा सकता है और संख्याओं में प्रवेश करने से बहुत सारे बीप और बूम शामिल होते हैं। संदर्भ के लिए, बहुपद I व्युत्पन्न है

( -9(X^5) +125(X^4) -585(X^3) +1075(X^2) -446(X) +160 ) / 40

मैंने कारकों को संख्याओं के लिए नामित सादगी के लिए नामित किया है;)

पहला संस्करण:

int BEEP,
// Magic numbers, do not touch.
four = -9,
eight = 125,
fifteen = -117*5, 
sixteen = 1075,
twenty_three = (-1-1337) /3,
forty_two = 320/2;


for(BEEP=0;;BEEP=++BEEP%6)
{
    Console.WriteLine( 0.025* (
        four *BEEP*BEEP*BEEP*BEEP*BEEP+ 
        eight *BEEP*BEEP*BEEP*BEEP+ 
        fifteen *BEEP*BEEP*BEEP+
        sixteen *BEEP*BEEP+
        twenty_three *BEEP+ 
        forty_two ));
}

मुझे बढ़ते तनाव के निहितार्थ पसंद थे क्योंकि प्रत्येक संख्या के बाद बीईईपी की संख्या घट जाती है।

तब मुझे लगा कि मैं बीप और बूप्स का उपयोग करते हुए कारकों की गणना कर सकता हूं:

int BEEEP=0, BEEP=++BEEEP ,BOOP=++BEEP,BLEEP=++BOOP+BEEP,

four = BOOP*-BOOP,
eight = BLEEP*BLEEP*BLEEP,
fifteen = BOOP*-(BOOP+(BEEP*BLEEP))*BLEEP*BOOP,
sixteen = BLEEP*BLEEP*(BOOP+(BLEEP*BEEP*BEEP*BEEP)),
twenty_three = BEEP*-((BLEEP*BOOP*BLEEP*BOOP)-BEEP),
forty_two = BEEP*BEEP*BEEP*BEEP*BEEP*BLEEP;

उसके बाद एक छोटा सा ओवरबोर्ड चला गया ...

int BEEEP=default(int), BEEP=++BEEEP ,BOOP=++BEEP,BLEEP=++BOOP+BEEP;

for(--BEEEP;;BEEEP=++BEEEP%(BEEP*BOOP))
{
    Console.WriteLine(

    BOOP*(                       (BOOP*-BOOP)*BEEEP    *BEEEP*BEEEP*BEEEP    *BEEEP+(BLEEP*BLEEP*
    BLEEP)                       *BEEEP*      BEEEP*    BEEEP*                     BEEEP+
    (BOOP*                       -(BOOP+      (BEEP*    BLEEP)                    )*BLEEP
    *BOOP)                       *BEEEP*      BEEEP*    BEEEP+(BLEEP*BLEEP        *(BOOP+
    (BLEEP*                       BEEP*        BEEP*                 BEEP)))       *BEEEP*
    BEEEP+                       (BEEP*-(     (BLEEP                 *BOOP*         BLEEP
    *BOOP)                       -BEEP))      *BEEEP+                (BEEP*         BEEP*
    BEEP*BEEP*BEEP*BLEEP))/     (BEEP*((BEEP*BEEP*BEEP  *BEEP*BEEP*BEEP)-(        BEEP+BEEP))));
}

मान प्रकारों के लिए C # में डिफ़ॉल्ट ऑपरेटर का उपयोग करने से BEEEP को शून्य करने की अनुमति मिलती है। इस तरह कोड में कोई संख्यात्मक शाब्दिक का उपयोग नहीं किया जाता है। मूल एल्गोरिथ्म समान है। लेकिन कारकों की गणना इनलाइन से की जाती है।

Comments

सुझाए गए संपादन के लिए @ kódfodrász धन्यवाद!

— ऋक

मुझे वहां एक अंक 8 दिखाई देता है, आप बुरे व्यक्ति आप

— Thebluefish

@ Thebluefish मुझे शर्म आती है।

— रिक

Answer 8

डी

मेरे कोड में 4, 8, 15, 16, 23, या 42 नंबर का उपयोग करने की अनुमति नहीं है? कोई समस्या नहीं है, तो मैं संख्या का उपयोग नहीं करेंगे!

import std.stdio;

void main()
{
    while( true )
    {
        ( ',' - '('  ).writeln;
        ( '/' - '\'' ).writeln;
        ( '/' - ' '  ).writeln;
        ( '_' - 'O'  ).writeln;
        ( '^' - 'G'  ).writeln;
        ( '~' - 'T'  ).writeln;
    }
}

Comments

ASCII अंकगणित सबसे अच्छा अंकगणित है।

— फराप

तो सी के बाद, डी नामक एक भाषा आई?

— सीगप्रकाश

@cegprakash और C के पहले B था

— SirPython

Answer 9

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

विरोधी गोल्फ!

<!DOCTYPE html>
<html>
<head>
</head>
<body>
<pre>
/*hereIsTheDataPart~                    Es="5030000307000022
E2000000100000010000                    E5370000507000022200
E0010100001110000005                    E0337001010000102220
E0100010010111005033                    E7001010000102220010
E1010010111~33079900                    E1000111102221000001
E1110111~03037910100                    E0111102220010100001
E0111".replace(/~/g,                    E5);Zfillfillfillfil
Eqw=21;fq=2;fz=fq*2;                    Efl=fz*2;fm=fl*2;fw=
Efm+2; M=Math;functi                    Eon r(n,i,z){return 
Efunction(){l=i||'';                    E;for(m=0;m!=n;m++)l
E+=String.fromCharCo                    Ede(97+M.floor(M.ran
Edom()*26));return l                    E+(z||'')}};kb=r(fm,
E'/*','*'+'/');kc=r(                    Efw,'//');kd=r(20);Z
Eke=r(fw,'/*');kf=r(                    E20);kg=r(fw,'','*'+
E'/');kh=kf;ki=new Z                    EArray(21).join(' ')
E;x=[];for(n=35*ix;n                    E!=s.length;++n){x.Z
Epush(parseInt(s[n])                    E)};oo=function(){oZ
E+=z==1?kb():z==9?kc                    E():z==3?(ee.shift()
E||kd()):z==5?(y==0?                    Eke():(ee.shift()||Z
Ekf())):z==7?(y==(yl                    E-1)?kg():(ee.shift(
E)||kh())):z==0?ki:Z                    Epl.shift();}Ze=mc^2
EZthis=does*nothing;                    EZnor*does+this-haha
EZawkw0rd+space+fi11                    EZrunn1ng/out+of=stf
EZfjsddfkuhkarekhkhk                    777777777777777777*/
0;ix=typeof ix=="number"?(ix+1)%6:1;s=text();ee=[];pl=[];//2
0;q=function(n,m){return s.substr(n,m)};evl="";xl=20;yl=12//
0;while(s.length){c=s[0];m=1;if(c=='\n'){s=q(1);continue;}//
0;if(c=='E'){ev=q(0,xl);i=ev.indexOf('Z');ee.push(ev);//sd//
0;evl+=i==-1?ev.substr(1):ev.substr(1, i-1);}if(c=='0'){//sd
0;pl.push(q(0,xl*3),'','');m=3};s=q(xl*m);}eval(evl);o="";//
0;for(r=0;r!=5;++r){for(y=0;y!=yl;++y){for(n=0;n!=7;++n){//s
0;z=x[n+r*7];oo()}o+="\n"}}setTimeout(function(){text(o);//z
0;(function(){var space=' ____ ',garbage='asfdasr#@%$sdfgk';
0;var filler=space+garbage+space+garbage+space+garbage;//s//
0;})("test",1199119919191,new Date(),"xyz",30/11/1)//asdfsaf
0;eval(text());},1000);//askfdjlkasjhr,kajberksbhfsdmhbkjygk
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
</pre>
<script>
window.onload = function () {
setTimeout(function() {
    text = function (txt) { 
        pre = document.getElementsByTagName('pre')[0];
        if(!txt) {
            return pre.innerText;
        }
        pre.innerText = txt;
    }
    eval(text());
}, 1000);
}
</script>
</body>
</html>

<pre>तत्व अनुक्रम में एक संख्या दर्शाता है। इसमें अनुक्रम में अगले नंबर पर आने के लिए आवश्यक सभी कोड भी शामिल हैं। तो यह <pre>स्पष्ट है, जिसके परिणामस्वरूप <pre>अनुक्रम में अगले नंबर से मिलता जुलता अपडेट किया जा रहा है। यह प्रक्रिया अंतहीन रूप से दोहराती है।

यहाँ यह कार्रवाई में है!

Comments

सरलता के लिए प्लस एक। PPCG में आपका स्वागत है!

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

Answer 10

सी

:-) पर अपने स्क्वीटिंग चश्मे प्राप्त करें

main(         i){char*s     ="*)2;,5p   7ii*dpi*t1p+"
"={pi       7,i)?1!'p)(a! (ii(**+)(o(,( '(p-7rr)=pp="
"/(('       (^r9e   n%){1 !ii):   a;pin     7,p+"
"{*sp       ;'*p*   op=p) in,**             i+)s"
"pf/=       (t=2/   *,'i% f+)0f7i=*%a       (rpn"
"p(p;       )ri=}   niipp   +}(ipi%*ti(     !{pi"
"+)sa       tp;}*   s;}+%         *n;==     cw-}"
"9{ii       i*(ai   a5n(a +fs;i   *1'7",    *p=s-
1;while(p=('T'^i)?++p:s){ for(i=1;55!=*     p;p++
)i+=(' '!=*   p);printf     ("%d ",i/       2);}}

Comments

जैसा कि यह हो सकता है, मैं वहाँ तीन 4s और दो 8s गिनता हूँ ।

— जियोबिट्स

@Geobits मुझे स्पष्ट रूप से काले चश्मे की एक नई जोड़ी की आवश्यकता है! अभी तय किया है।

— स्क्विश ossifrage

Answer 11

हास्केल, 1 एलओसी

import Data.Char; main = putStr $ unwords $ map (show . (+)(-ord 'D') . ord) $ cycle "HLST[n" 

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

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

Comments

मुझे हास्केल और इस तरह की कार्यात्मक प्रोग्रामिंग करना पसंद है: D

— Jwosty

fromEnumसे अच्छा लग रहा है Data.Char.ord, और कुछ हद तक कम है

— mnip

Whuh ... कैसे? क्या आप समझाएँगे?

— प्यूरफेरेट

मैंने बस अंत में सहज पात्रों को देखा। मुझे लगता है कि इसके साथ कुछ करना है?

— प्यूरफेरेट

आह। हाँ, वास्तव में, वे करते हैं।

— जॉन ड्वोरक

Answer 12

मेथेमेटिका

हम नीचे दिखाए गए आवधिक जारी अंश के दोहराए गए आंशिक विभाजनों पर ध्यान केंद्रित करके प्रश्न का उत्तर दे सकते हैं। वे वही हैं जो हमें चाहिए।

आखिरकार, वे गैर-समाप्ति वाले अनुक्रम को शामिल करते हैं जो हम उत्पादन करने की कोशिश कर रहे हैं: 4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 42 ...

---

मैथेमेटिका में, व्यक्ति आवधिक जारी अंश के अनुरूप द्विघात अपरिमेय प्राप्त करता है

FromContinuedFraction[{0, {4, 8, 15, 16, 23, 42}}]

जहाँ 0 का तात्पर्य अंतर्निहित पूर्णांक भाग से है।

हम ऑपरेशन को इन्वर्ट करके देख सकते हैं:

{, {४,,, १५, १६, २३, ४२}}

---

4 के और 8 चुनौती के नियमों में से एक का उल्लंघन करते हैं। प्रतिस्थापन 15एक अतिरिक्त उल्लंघन है। हम नियमों को पूरा करने के लिए द्विघात अपरिमेय को पुन: व्यवस्थित कर सकते हैं।

{, {४,,, १५, १६, २३, ४२}}

---

अब हम ब्याज के क्रम को पकड़ लेते हैं:

Last[c]

{4, 8, 15, 16, 23, 42}

और सूची को हमेशा के लिए प्रिंट करें…

While[True, Print@Row[ContinuedFraction[(-3220235/5+Sqrt[(10611930613350/25)])/(61630/2)],"\t"]]

Comments

खैर, यह एक अच्छा गणित समाधान है। मुझे वास्तव में यह पसंद है

— C5H8NNaO4

@ C5H8NNOO4, धन्यवाद, एमएसजी। यह पता लगाने के लिए मजेदार था।

— डेविड

+1 जब आप 16इसके बारे में एक टिप्पणी टाइप कर रहे थे, तो आप अंश में छुटकारा पाने के लिए संपादित हुए।

— जियोबिट्स

@Geobits। उस बारे में मजेदार है। मैंने सोचा कि मैं जाँच करूँगा कि क्या मैंने नियमों को पूरा किया है; कई उल्लंघन थे जो मैंने तय किए थे।

— डेविड 3

Answer 13

C / C ++

केवल वर्णों का उपयोग करना L, O, Sऔर Tइसी क्रम में बार-बार:

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

    'L'-     'O'*'S'    &'T','L'  &'O'+'S'*
    'T',    'L'^  'O'  |'S'*        'T'&
    'L',    'O'*  'S'    &'T'/      'L'+
    'O',    'S'^  'T'      &'L',    'O'*
    'S'&'T'   +'L'+    'O'^'S'+     'T')   ;}

Answer 14

जावा

मैं उस क्रम में एक पैटर्न नहीं ढूँढ सकता। यदि कोई पहचानने योग्य पैटर्न नहीं है, तो हम साथ ही छोटे-छोटे अपराधों का एक गुच्छा फेंक सकते हैं, उन्हें जावा के अंतर्निहित आरएनजी में रटना कर सकते हैं और इसे एक दिन कह सकते हैं। मैं नहीं देखता कि कैसे संभवतः गलत हो सकता है, लेकिन फिर, मैं एक आशावादी हूं :)

import java.util.Random;
public class LostNumbers {
    public static void main(String[] args) {
        long nut=2*((2*5*7)+1)*((2*2*3*((2*2*2*2*11)+3))+5)*
                   ((3*5*((2*3*3)+1)*((2*2*2*2*2*3)+1))+2L);
        int burner=2*2*2*5;
        while(true){
            Random dice = new Random(nut);
            for(int i=0;i<6;i++)
                System.out.print((dice.nextInt(burner)+3) + " "); // cross your fingers!
            System.out.println();
        }
    }
}

Comments

माइनस while(true): ideone.com/1xaPdO

— टिम एस।

एक पैटर्न है, लेकिन यह बहुत स्पष्ट नहीं है ... oeis.org/A130826 :)

— सेबस्टियन नेग्रैज़स

Answer 15

बैश वन-लाइनर

yes `curl -s "https://oeis.org/search?q=id:A$((130726+100))&fmt=text" |
grep %S | cut -d " " -f 3 | cut -d "," -f 1-6`

पठनीयता के लिए लाइन ब्रेक जोड़ा गया। यह (ab) इस तथ्य का उपयोग करता है कि ये OEIS अनुक्रम A130826 के पहले छह नंबर हैं ।

Comments

तुम भी पाइप कर सकते हैं awk -F"[ ,]" '/%S/ {for (i=3;i<=9;i++) printf $i" "}'करने के लिए curl।

— फेडोरक्वि

आप के साथ पूरी तरह पाश को हटा सकते हैं yesऔर करने के लिए पुन: निर्देशन ड्रॉप /dev/nullके साथ curl -s। कुछ इस तरहyes $(curl -s "https://oeis.org/search?q=id:A$((130726+100))&t=text" | awk -F"[ ,]" '/%S/ {for (i=3;i<9;i++) printf $i" "}')

— डिजिटल ट्रामा

@DigitalTrauma: धन्यवाद, मुझे इसके बारे में पता नहीं था yesऔर curl -s- मैंने बेशर्मी से इसे मेरे जवाब में जोड़ दिया। :-)

— हेंजी

Answer 16

C सभी संख्याओं का उपयोग करता है और कोई वर्ण मान नहीं

s(int x) { return x+x; }
p(int x) { return printf("%d ",x); }
main()
{
    for(;;){
    int a = s(p(s((s==s)+(p==p))));
    int b = a+s(a+p(a+a));
    putchar(b-s(p(b*a-b-s(p(s(s(p(b-(s==s))+p(b)))-(p==p))))));
    }
}

Answer 17

मुझे अनुक्रम का उपयोग करने का विचार पसंद है

a[n+5] = a[n] + a[n+2] + a[n+4]

के रूप में इस सवाल का जवाब । इसे अनुक्रम A122115 के रूप में OEIS खोज के माध्यम से मिला ।

यदि हम रिवर्स में अनुक्रम से गुजरते हैं तो हमें एक उपयुक्त इनिशियलाइज़ेशन क्विंटअप मिलेगा जिसमें 4, 8, 15, 16 या 23 नहीं होते हैं।

python3:

l = [3053, 937, -1396, -1757, -73]
while l[-1] != 66:
    l.append(l[-5] + l[-3] + l[-1])
while True:
    print(l[-6:-1])

Comments

बहुत चालाक! अच्छा लगा।

— डेविड

Answer 18

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

कोई भी संख्या अच्छी नहीं है। लेकिन अनुक्रम को लूप के माध्यम से प्रति बार एक बार प्रिंट करने के बजाय, केवल एक बार प्रति पास प्रिंट करें।

t = "....A...B......CD......E..................FEDCBA";
b = k = --t.length;
do {
    console.log(p = t.indexOf(t[k]));
} while (k-=!!(p-k)||(k-b));

स्ट्रिंग का निचला भाग प्रिंट करने के लिए संख्याओं को कोड करता है और स्ट्रिंग का ऊपरी भाग अगले वर्ण को खोजने के लिए कोड करता है। जहां दो भाग मिलते हैं (एकल F) कोड चक्र को रीसेट करते हैं।

Answer 19

अजगर

b=a=True;b<<=a;c=b<<a;d=c<<a;e=d<<a;f=e<<a
while a: print c,d,e-a,e,e+d-a,f+d+b

बिटवाइज़ ऑपरेटर और कुछ सरल गणित।

Answer 20

माणिक

समान रूप से रहस्यमय अनुक्रम 0, 9, 9, 0, 36, 6, 6, 63 को एम्बेड करके संख्या उत्पन्न करता है ;
इससे अच्छा कोई नहीं आ सकता।

(0..1/0.0).each{|i|puts"kw9ygp0".to_i(36)>>i%6*6&63}

Comments

सभी रूबी कोड ऐसा लगता है कि यह सिर्फ त्रुटि और मरना चाहिए; यह मुझे इस दिन के लिए झटका देता है कि इसमें से कोई भी चलाता है!

— अलेक्जेंड्रकन्नन

Answer 21

C ( 54 50 वर्ण)

मैं एक गोल्फ जवाब पोस्ट कर रहा हूं क्योंकि गोल्फिंग कम से कम मजेदार है।

main(a){while(printf("%d\n","gAELMT"[a++%6]-61));}

Comments

यदि आप गोल्फ कर रहे हैं, तो आप (यकीनन) ड्रॉप कर सकते हैं a=0;। इसका एकमात्र प्रभाव यह होगा कि आप अनुक्रम को 4 (शायद 8) के अलावा कहीं और शुरू कर सकते हैं। फिर भी, यह अनुक्रम गड़बड़ कर देगा जब aoverflows। यह तकनीकी रूप से अपरिभाषित व्यवहार है, लेकिन संभावित परिणाम यह है कि आप आधे समय कचरा प्रिंट करेंगे।

— जेरी

या बस स्ट्रिंग को "gAELMT" :)

— orion

यकीन है, जब तक कोई आपके कार्यक्रम को तर्कों के साथ आमंत्रित नहीं करता है :) फिर भी आधे समय में कचरा प्रिंट करना, हालांकि।

— जेरी

यदि आप किसी ऐसे प्रोग्राम की दलीलें देते हैं, जिसकी आपको कोई जरूरत नहीं है, तो आप उसकी कीमत अदा करें :)

— orion

forअगर कोई आरंभीकरण नहीं है तो मदद नहीं करता है। for(;;)वर्णों की समान संख्या है while()। मैंने नियमों की व्याख्या की ताकि नई कहानियों का होना आवश्यक हो ... लेकिन मैं मुख्य के साथ पूंछ पुनरावृत्ति का उपयोग कर सकता था ...

— ओरियन

Answer 22

हास्केल

main = mapM_ (print . round . go) [0..]
  where
    go n = 22 - 19.2*cos t + 6*cos (2*t) - 5.3*cos (3*t) + 0.5*cos (5*t)
      where t = fromInteger (n `mod` 6) / 6 * pi

http://ideone.com/erQfcd

संपादित करें: मैं गुणांक उत्पन्न करने के लिए क्या उपयोग करता था: https://gist.github.com/ion1/9578025

संपादित करें: मुझे वास्तव में फुर्तीला कार्यक्रम पसंद आया और इसे लगाते हुए एक हास्केल बराबर लिखना समाप्त कर दिया। मैंने जादू की संख्या के लिए एक अलग आधार चुना।

import Data.Fixed
main = mapM_ print (go (369971733/5272566705 :: Rational))
  where go n = d : go m where (d,m) = divMod' (59*n) 1

http://ideone.com/kzL6AK

संपादित करें: मुझे उनका दूसरा कार्यक्रम भी पसंद आया और उन्होंने द्विघात अपरिमेय का एक हास्केल कार्यान्वयन लिखना शुरू किया ; ;-)। लाइब्रेरी और एग्रिफ के मैजिक नंबर का उपयोग करके, यह प्रोग्राम अनुक्रम को प्रिंट करेगा।

import qualified Data.Foldable as F
import Numeric.QuadraticIrrational

main = F.mapM_ print xs
  where (_, xs) = qiToContinuedFraction n
        n = qi (-16101175) 1 265298265333750 770375

यह है कि कैसे पुस्तकालय की मदद से मैजिक नंबर की तलाश की जा सकती है:

> continuedFractionToQI (0, Cyc [] 4 [8,15,16,23,42])
qi (-644047) 1 424477224534 30815

मुद्रित मूल्य संख्या के लिए खड़ा है (−644047 + 1 √424477224534)/30815। आपको केवल उन कारकों को ढूंढना है जो अभिव्यक्ति के मूल्य को नहीं बदलते हुए अंकों में अव्यवस्थित अंकों के अनुक्रम से छुटकारा पाते हैं।

Comments

साइट पर आपका स्वागत है =)

— दंगा

Answer 23

सी#

var magicSeed = -1803706451;
var lottery = new Random(magicSeed);
var hurleysNumbers = new List<int>();
for (int i = 0; i < 6; i++) hurleysNumbers.Add(lottery.Next(43));
while (true) Console.WriteLine(String.Join(",", hurleysNumbers));

मैं प्रशांत पर एक उड़ान में कुछ रेडियो स्टेशन को सुनने के बाद बीज पाया।

Comments

अंदर 4s और 8s हैं।

— ज़ाक

Answer 24

अजगर

import math

def periodic(x):
    three_cycle = abs(math.sin(math.pi * \
        (x/float(3) + (math.cos(float(2)/float(3)*x*math.pi)-1)/9)))
    two_cycle = abs(math.sin(math.pi * x / float(2)))
    six_cycle = three_cycle + 2*two_cycle
    return round(six_cycle, 2) # Correct for tiny floating point errors

def polynomial(x):
    numerator = (312+100)*(x**5) - 3000*x*(x**3) + (7775+100)*(x**3) - \
        (7955+1000)*(x**2) + (3997+1)*x + 120
    denominator = float(30)
    return float(numerator)/denominator

def print_lost_number(x):
    lost_number = polynomial(periodic(float(x)))
    print(int(lost_number)) # Get rid of ugly .0's at the end

i=0
while (1):
    print_lost_number(i)
    i += 1

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

पहला फ़ंक्शन जो मैंने बनाया था वह आवधिक था ()। यह एक फ़ंक्शन है जो ट्रिगर फ़ंक्शन के चक्रीय गुणों का उपयोग करके प्रत्येक छह इनपुट संख्याओं को दोहराता है। यह इस प्रकार चलता है:

periodic(0) = 0
periodic(1) = 5/2
periodic(2) = 1
periodic(3) = 2
periodic(4) = 1/2
periodic(5) = 3
periodic(6) = 0
...

फिर, मैं बहुपद () बनाता हूं। निम्नलिखित बहुपद का उपयोग करता है:

412x^5-3000x^4+7875x^3-8955x^2+3998x+120
----------------------------------------
                  30

(मेरे कोड में, कुछ गुणांकों को रकम के रूप में दर्शाया गया है क्योंकि उनमें खोए हुए अंक उनके अंकों में से एक के रूप में होते हैं।)

यह बहुपद आवधिक () के आउटपुट को उसकी उचित खोई हुई संख्या में परिवर्तित करता है, जैसे:

polynomial(0)   = 4
polynomial(5/2) = 8
polynomial(1)   = 15
polynomial(2)   = 16
polynomial(1/2) = 23
polynomial(3)   = 42

लगातार बढ़ती हुई i और इसे दोनों फंक्शन्स से गुजारते हुए, मुझे खोए हुए नंबरों को असीम रूप से दोहराते हुए मिलता है।

(नोट: मैं फ्लोट का उपयोग करता हूं) कोड में बहुत कुछ है। ऐसा इसलिए है कि पायथन फ्लोटिंग-पॉइंट डिवीजन करता है, यानी 2/3 = 0 के बजाय।

Comments

ठीक करने के लिए आसान है, लेकिन आप अभी भी एक 4में है polynomial।

— जियोबिट्स

@Geobits वूप्स, ध्यान नहीं दिया। धन्यवाद।

— एंड्रयू सूटर

Answer 25

Emacs लिस्प 73 वर्ण

हमेशा के लिए पाश करने का सबसे अच्छा तरीका? एक चक्रीय सूची!

(let((a'(?\^D?\^H?\^O?\^P?\^W?*)))(setcdr(last a)a)(while(print(pop a))))

लेकिन रुकिए, और भी है!

? \ _ D ईओटी के लिए चार्ट सम्मिलित करने का सबसे अच्छा तरीका है, हालांकि अगर मैं सिर्फ एक फाइल जमा कर रहा हूं तो मुझे शाब्दिक "\ ^ डी" की आवश्यकता नहीं है मैं सिर्फ एक 'सम्मिलित कर सकता हूं?' एक वास्तविक ईओटी चरित्र के बाद, इस प्रकार आवश्यक वर्णों की वास्तविक संख्या को नीचे ले जाना: 63

संपादित करें

मैं "जेल" पर काम कर रहा हूं, जो अभी तक एक वास्तविक भाषा नहीं है, लेकिन मूल रूप से कोड गोल्फ के लिए एमएसीएस लिस्प मैक्रोज़ की श्रृंखला है। "जेल" में इसका समाधान होगा:

(m a(~o ?\^D?\^H?\^O?\^P?\^W?*)(@(<^(^ a))(...)))

और प्रतीक्षा के बिना:

(m a(~o ?\^D?\^H?\^O?\^P?\^W?*)(@(<^(^ a))))

अच्छा चरित्र प्रविष्टि के साथ 44 वर्ण। यदि यह वेब सबमिशन नहीं है तो 34 होगा।

Answer 26

जूलिया

कुछ समय तक बिना किसी संख्या के प्रयोग के अनुक्रम को व्यक्त करने के लिए मैंने एक गणितीय तरीका खोजा, (या इन्हें इस्तेमाल करने के लिए ट्रिकी तरीके):

L(n)=n==0?2:n==1?1:L(n-1)+L(n-2) #Lucas numbers.
O(n)=int(n*(n+1)*(n+2)/6)
S(n)=n in [O(i) for i=1:50]?0:1 #A014306
T(n)=begin k=ifloor(n/2);sum([L(i)*S(n+1-i) for i=1:k]) end #A025097

lost(n)=n>5?lost(n-1)+lost(n-3)+lost(n-5):(n+3)>5?T(n+3):-T(n+3) #A122115

[lost(i-2) for i=5:10]

आउटपुट:

6-element Array{Int64,1}:
  4
  8
 15
 16
 23
 42

Answer 27

सी ++

C ++ जैसी एक अच्छी स्वच्छ भाषा आपको अपने स्रोत को साफ-सुथरे और उच्च पठनीय तरीके से रखने की अनुमति दे सकती है, और न्यूनतम अस्पष्टता के साथ हाथ से नकल करने में आसान होने का फायदा है।

यहां समाधान केवल नंबर 1 का उपयोग करके पहुंच गया है।

#include <iostream>

typedef long int lI;
auto &VV = std::cout;
std::string vv = " ";

int main() {
  for(lI UU; UU --> UU;) {
    lI l1=1l+1l;lI 
    ll=1l << l1;VV 
    << ll << vv;lI 
    Il=ll*l1;VV << 
    Il << vv;VV <<
    ll*ll-1l << vv;
    lI II=ll*ll;VV 
    << II << vv;VV 
    <<(II += Il-1l)
    << vv;VV << l1
    * (II-l1)<< vv;
  }
}

टेस्ट: http://ideone.com/fuOdem

Answer 28

योजना (गुइल)

(let l ((x 179531901/2199535975))
  (let* ((b (* x 51)) (f (floor b)))
    (format #t "~a " f)
    (l (- b f))))

http://ideone.com/QBzuBC

यकीनन यह "अन्य आधारों में संख्याओं को कूटबद्ध नहीं करता है" नियम को तोड़ता है, लेकिन मुझे लगता है कि यह पर्याप्त अस्पष्ट है कि यह गिनती नहीं करता है। इस अस्पष्टता के प्रमाण के रूप में, आधार 51 में वे दो जादू नंबर हैं:

26:27:21:9:18 / 6:19:6:19:6:19

संपादित करें : एक ही चाल, अलग प्रतिनिधित्व। मुझे वास्तव में यह एक और पसंद है, क्योंकि यह एक मनमाने ढंग से चुने गए आधार पर निर्भर नहीं करता है। हालाँकि, इसे द्विघात अपरिमेय के लिए अनंत-सटीकता समर्थन के साथ एक योजना कार्यान्वयन की आवश्यकता होती है, जो (AFAIK) मौजूद नहीं है। आप इसे मैथमेटिका जैसी किसी चीज़ में लागू कर सकते हैं, हालाँकि।

(let l ((x (/ (+ -16101175 (sqrt 265298265333750)) 770375)))
  (let* ((b (/ 1 x)) (f (floor b)))
    (format #t "~a " f)
    (l (- b f))))

Comments

साइट पर आपका स्वागत है =)

— दंगा

+1 के लिए "यह द्विघात अपरिमेय के लिए अनंत-सटीकता समर्थन के साथ एक योजना कार्यान्वयन की आवश्यकता है, जो (AFAIK) मौजूद नहीं है।"

— लिंडन व्हाइट

Answer 29

पीएचपी

मैंने सोचा कि यह समय था जब किसी ने php जवाब दिया, वैसे भी यह सबसे अच्छा नहीं बल्कि एक मजेदार था

while(true)
{
    $lost = array(
    "Aaah",
    "Aaaaaaah",
    "Aaaaaaaaaaaaaah",
    "Aaaaaaaaaaaaaaah",
    "Aaaaaaaaaaaaaaaaaaaaaah",
    "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaah");
    foreach ($lost as $a)
    {
        echo strlen($a).'
        ';
    }
}

विमान के दुर्घटनाग्रस्त होते ही यात्रियों की चीख पुकार मच जाती है

Answer 30

पर्ल

#!/usr/bin/perl
use Math::Trig;

$alt = 2600;
$m   = 10 x 2;
$ip  = 1 - pi/100;
@candidates = (
    "Locke",
    "Hugo",
    "Sawyer",
    "Sayid Jarrah",
    "Jack Sh.",
    "Jin-Soo Kwon"
);

@lost = map {map{ $a+=ord; $a-=($a>$alt)?($r=$m,$m=-$ip*$m,$r):$z; }/./g; $a/100 }@candidates;
for(;;) {
    printf "%d\n",$_ for @lost;
}