"hello world"를 정수로 표현하는 수학 함수 작성

예를 들어 16 진수의 68656c6c6f20776f726c64"hello world"는 "hello world"를 나타내는 숫자를 생성하는 수학 프로그램을 작성하는 것입니다.

다음은 파이썬을 사용하여 가능한 솔루션의 예입니다.

print(2*2*3*59*61*97*416510539*72330832279)==int("68656c6c6f20776f726c64", 16)

거듭 제곱, 계열, 계승 및 기타 수학 연산과 같은 모든 유형의 수학 방정식을 사용할 수 있습니다.

규칙:

• "hello world"를 정수로 인코딩 / 표현하는 고유 한 방법을 선택할 수 있습니다. 해시 함수도 허용됩니다

• 수학적 라이브러리 (예 : numpy, GMP)가 허용됩니다.

• 의도는 수학 부분에 집중하는 것입니다

파이썬 2.7

난수 생성기의 남용은 Python 2.7에서 작동하지만 생성기가 시드 알고리즘을 변경 한 것으로 보이므로 Python 3.x에서는 작동하지 않습니다.

>>> import random
>>> n=[(15,30,15,25,15,0,-15,-25,-15,-30,-15),(107,35,34,26,22,0,71,188,94,64,81)]
>>> random.seed(4711)
>>> m = zip("MERRY CHRISTMAS",*n)
>>> print(''.join(map(lambda x:chr(ord(x[0])+random.randint(x[1],x[2])),m)))

hello world

나는 그것을 인쇄하는 것보다 더 잘 할 것이다. 나는 그것을 여러 번 인쇄 할 것이다!

유리수

1767707668033969 / 3656158440062975

다음 base-36 확장을 리턴합니다.

0.helloworldhelloworldhelloworldhelloworldhelloworld...

사용해보십시오! (울프 람 알파)

또는보다 잠정적 인 메시지를 원하면 다음을 시도하십시오.

2399843759207982499621172523113947162810942763812298565948669
/ 1357602166130257152481187563160405662935023615

어느 것이 (36에서 다시) 반환 :

helloworld.helpimtrappedinanumberfactoryhelpimtrappedinanumberfactoryhelpimtrappedinanumberfactory...

프로그램이 정수로만 작동했다면 소수 부분은 보이지 않습니다.

파이썬 (완료되지 않았습니다 ... 아직!) 완료되었습니다! :디

number = ((sum(b'This text will end up converting to the text "hello world" by a bunch of math.') *
sum(b'For example, multiplication will be used to increase the number so that it may reach the required result.') *
sum(b'Wow, double multiplication! The required result number is extremely big so I have to use lots of math to get there.') *
sum(b'TRIPLE multiplication?!?!?! Wow!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Did I put too many exclamation points?') *
sum(b'I think maybe I might have put too many exclamation points, oops. :(') *
sum(b'This is taking a long time...') *
sum(b'A very, very, very long time...')) // 2)

number -= (sum(b'Okay, the number is a bit too high. Blah. This is extremely hard.') *
sum(b'I need to reduce it. I will just keep multiplying again! Yay! That seems effective!') *
sum(b'I don\'t know what to write now... I used up all my creativity in the previous number.') *
sum(b'So. Uhhh, how has your day been? Was it good? I wonder how many people are still reading.') *
sum(b'Gah! There is nothing to type about anymore! I will just type randomness then.') *
sum(b'Do you like pie? I like pie. Refrigerator. The chicken ate the potato. Llamas are not tasty.'))

number -= (sum(b'Blah, I am still a tiny bit too high!') *
sum(b'This is very frustrating!') * sum(b'Argh!!!!!!!') *
sum(b'I have even less creative ideas now since I have written two paragraphs already.') *
sum(b'Well, I suppose they\'re not paragraphs. They\'re just blocks of code.') *
sum(b'The only reason I made that remark was to increase this number to subtract, so that I reach my target.'))

number -= (sum(b'I am an extremely miniscule amount over the target!!!') *
sum(b'I am so close!!! So close!!') *
sum(b'I must make it!!! I will!!!') *
sum(b'I shall NEVER give up!!!') *
sum(b'Okay, ummm... maybe not exactly "never"...') *
sum(b'I mean, this is REALLY hard...'))

number -= (sum(b'I am so close. This is just ridiculous.') *
sum(b'Just ridiculous. And that\'s awesome :D') *
sum(b'Why am I doing this?!?') *
sum(b'The answer\'s probably "becase I can."') *
sum(b'Notice how most of the text in this program is meaningless.'))

number -= (sum(b'How have I been above my target this whole time? That is very odd.') *
sum(b'I wonder how much time I could have saved if I removed a few characters in the first block.') *
sum(b'I wish I did that. That would have made it so much easier.... But oh well.') *
sum(b'Well, I am really really really really really really close now!'))

number -= (sum(b'I am so close!') *
sum(b'I will never give up now! Not after all this!') *
sum(b'I wonder if I will ever get exactly on the target. What if I do, and then discover a typo? :O') *
sum(b'So close!'))

number -= (sum(b'Wow; this is the eighth block. That\'s a lot of blocks!') *
sum(b'I only have a little more to go! I must finish! I will!') *
sum(b'It is starting to get harder thinking of things to type than it is getting to the target...'))

number -= (sum(b'These strings are short') *
sum(b'So the number to subtract is less') *
sum(b'Hi'))

number += (sum(b'Finally adding') *
sum(b'That\'s new') *
sum(b':D'))

number -= (sum(b'I am back to subtraction, and also longer strings.') *
sum(b'But this time I only get two strings!'))

number -= (sum(b'I have switched over to adding the strings, not multiplying them!') +
sum(b'I am really really close! So close that I can\'t even multiply two strings to subtract anymore!') +
sum(b'This is very exciting; I\'ve nearly made it! Only a few more strings to add...') +
sum(b'I ran out of ideas for what to type again... I will just type exactly what I am thinking, which is what I am doing now actually.') +
sum(b'But now the only thing I am thinking about is getting to the target, and there is not much about that to type...') +
sum(b'I am only a few thousand away!!!!!!!!!!!!'))

number += 8 # NOOOOOOOOOOOOOOOOOOOOOOOOOOOOO

print(number)

출력 126207244316550804821666916(예와 동일 0x68656c6c6f20776f726c64)

"hello world"를 정수로 인코딩 / 표현하는 고유 한 방법을 선택할 수 있습니다.

그럼 ...

PHP

<?=1?>

여기서 1은 "hello world"를 나타냅니다.

계산기 글꼴 / FreePascal

게시에 문제가 생길 수 있지만 어쨌든 할 것입니다 :-)

1. 7734/100000을 계산하십시오. 선행 0을 파란색으로 변경하고 다른 숫자를 계산기 글꼴로 변경하십시오. 거꾸로 뒤집습니다. 파란색 O는 세계를 나타냅니다.

너무 게으르다면 어떻습니까?

uses graph;
var gd, gm : integer;
var n,m:integer;

begin
  gd := D4bit;
  gm := m640x480;
  initgraph(gd,gm,'');
  setcolor(black);

  For n:=0 to 5  do for m:=0 to 3 do begin;
    setfillstyle(solidfill,(abs(n*2-1)));

    if(($967EEF shr (20-n*4+m)) and 1) = 1
      then sector(50+n*80,100,90*m,90*(m+1),40,60);

    if(($EDF7E9 shr (20-n*4+m)) and 1) = 1
      then sector(50+n*80,300,90*m,90*(m+1),40,60);
    end;

  readln;
  closegraph;
end.

숫자는 0-5이고, 색상은 abs (2n-1)에 의해 결정됩니다. 원당 하나의 16 진수, 사분면은 가장 아래에서 오른쪽으로 시계 방향으로 가장 중요한 비트에서 아래쪽으로 채색됩니다. 신비한 상수 967EEF와 EDF7E9 16 진수.

프리 파스칼이 복제 할 수 있도록 TurboPascal에 넣은 다음 프리미티브와 볼랜드에게 특별한 감사를드립니다.

절차 섹터 (x : SmallInt; y : SmallInt; StAngle : Word; EndAngle : Word; XRadius : Word; YRadius : Word); 섹터는 시작 각도에서 시작하여 각도 정지에서 끝나는 중심 (X, Y) 및 반지름 XRadius 및 YRadius로 타원의 섹터를 그리고 채 웁니다.

루비와 파이썬

기본 36 수학을 사용하여 Ruby & Python에서 정수 표현에 매우 쉽게 도달합니다.

루비

%w(hello world).map{|n|n.to_i(36)}

결과:

[29234652, 54903217]

또는 일반적인 기능으로 표현됩니다.

def f(words); words.split.map{|n|n.to_i(36)}; end

예:

f("hello world")
=> [29234652, 54903217]

파이썬

def f(words): return map(lambda n: int(n,36), words.split())

예:

>>> f("hello world")
[29234652, 54903217]

신중하게 조작 된 PHP :

$x=18306744;
$w=($z=($y=30)/3)/2;
echo base_convert($x, $z, $y+$z/$w),chr($y+$z/$w).base_convert($x*($y/$z)-$w*41*83,$z,$y+$y/$w);

R6RS 체계

#!r6rs
(import (rnrs))
(define (hello-world)
  (bitwise-xor (fold-left (lambda (acc d) 
                        (+ (* acc 256) 
                           (+ (bitwise-and 255 acc) d)))
                      104
                      '(-3 7 0 3 8 0 -8 3 -6 -8))
               (bitwise-arithmetic-shift 87 40)))

출력 # x68656c6c6f20776f726c64 (10 진수) :

126207244316550804821666916

내 원래 구현은 다음과 같습니다.

라켓 (스키마 방언)

(define (hello-world)
  (bitwise-xor (foldl (lambda (d acc) 
                        (+ (* acc 256) 
                           (+ (bitwise-and 255 acc) d)))
                      104
                      '(-3 7 0 3 8 0 -8 3 -6 -8))
               (arithmetic-shift 87 40)))

자바 스크립트

function stringTheory(theory) {
  var proof = 0;
  var principles = theory.split(/[ ,.'-]/);
  for (var i = 0; i < principles.length; i++) {
      var formula = '';
      for (var j = 0; j < principles[i].length; j++) {
        formula += principles[i].charCodeAt(j).toString(10);
      }
      proof += +formula;
  }
  return proof;
}

console.log(
/* \2 and \3 are start of text and end of text characters */ 
stringTheory('\2 Yo it\'s 4327 - Go to space, look back, and see the dot of a small blue rock you once sat on amid the vast empty void - KA-BOOM - you are in awe of it. "Ah" - so tiny in this vast space yet you are even more so. A mere atom in an ocean of stars, the earth a speck of dust to the sun\'s ping-pong ball. One day you shall go back and as your toes touch the soft soil once more, the cool wind in your hair as you cast your gaze upon the moon, a mere rock just like this one, and bask in it\'s warm glow - Ah. Only then can you know the scale of it all, what luck you have to call this place home.  And with this new ken, a love you\'ve kept for all of time but had not seen - for it is clear to you now. You lay open your arms and fill the air with your song - (aah) ~o Good-bye space and ... o? \3') + 42
);

무슨 일이야?

우리는이 문자열을 가지고 조금 적용합니다 stringTheory()(실제로 미래에서 전송됩니다).

'\2 Yo it\'s 4327 - Go to space, look back, and see the dot of a small blue rock you once sat on amid the vast empty void - KA-BOOM - you are in awe of it. "Ah" - so tiny in this vast space yet you are even more so. A mere atom in an ocean of stars, the earth a speck of dust to the sun\'s ping-pong ball. One day you shall go back and as your toes touch the soft soil once more, the cool wind in your hair as you cast your gaze upon the moon, a mere rock just like this one, and bask in it\'s warm glow - Ah. Only then can you know the scale of it all, what luck you have to call this place home. And with this new ken, a love you\'ve kept for all of time but had not seen - for it is clear to you now. You lay open your arms and fill the air with your song - (aah) ~o Good-bye space and ... o? \3'

먼저 문장 부호를 나누고 단어를 만듭니다. 그런 다음 문자를 10 진수 ASCII 코드로 변환하여 일련의 숫자를 만듭니다. 인접한 문자는 인접한 숫자 aa가됩니다 (예 :) 9797.

그런 다음 숫자가 합산됩니다. 우리가 다시 얻는 191212222216169것은 완전히 쓸모없는 숫자이며, 우주에 떠 다니는 수조 개의 암석처럼 의미가 없습니다. 이 세상을 특별하게 만드는 것은 무엇입니까? 왜 인생인가. 이 숫자 에 생명 의 의미를 부여함으로써 +=42우리는 얻는다 191212222216211.

그런데 왜?

이것은 무엇을 의미 하는가? stringTheory("Hello world")물론 그것이 의미 하는 이유 .

파이썬

from math import fsum
c=[104.,-4412.705557362921,12008.518259002305,-13041.051140948179,7566.060243625142,-2619.91695720304,567.427662301322,-77.52280096313,6.48776455347,-0.303552138602,0.006079144624]
def f(x):
    return fsum([c[i]*x**i for i in range(len(c))])
s=""
for i in range(11):
    s+=chr(int(round(f(i))))
print s

루비

모든 문자열은 정수에 매핑됩니다.

# encode string to integer
def str_to_int(s)
  i = 0
  s.chars.each do |c|
    i = i << 7 | c.ord
  end
  i
end

역함수 :

# decode integer to string
def int_to_str(i)
  s = ''
  while i > 0 do 
    s = (i & 0x7f).chr + s
    i = i >> 7
  end
  s
end

예 :

str_to_int("ABC")
=> 1073475
int_to_str(1073475)
=> "ABC"

str_to_int("hello world")
=> 123720932638399026476644
int_to_str(123720932638399026476644)
=> "hello world"

씨#

모든 문자열 (hello world 또는 다른 것)을 16 진수 문자열로 변환하는 방법

string Encode(string text)
{
   string hexValue = String.Empty;
   foreach(char c in text)
      hexValue += String.Format("{0:X}", (int)c);
   return hexValue;
}

16 진 문자열을 문자열로 변환하는 방법

string Decode(string hexValue)
{
   string text = String.Empty;
   for (int i = 0; i < hexValue.Length; i += 2)
   {
     int value = Convert.ToInt32(hexValue.Substring(i, 2), 16);
     text += (char)value;
   }
   return text;
}

여기 완전한 C # 프로그램이 있습니다

using System;

namespace ConsoleApplication1
{
    class Program
    {       

        static string Encode(string text)
        {
            string hexValue = String.Empty;
            foreach(char c in text)
                hexValue += String.Format("{0:X}", (int)c);
            return hexValue;
        }

        static string Decode(string hexValue)
        {
            string text = String.Empty;

            for (int i = 0; i < hexValue.Length; i += 2)
            {
                int value = Convert.ToInt32(hexValue.Substring(i, 2), 16);
                text += (char)value;
            }

            return text;
        }

        static void Main(string[] args)
        {  
            string Text1 = "Hello World!";
            Console.WriteLine("Before Encoding: " + Text1 + "\n");

            string Hex = Encode(Text1);
            Console.WriteLine("After endoding: " + Hex + "\n");

            string Text2 = Decode(Hex);
            Console.WriteLine("After decoding: " + Text2 + "\n");
        }
    }
}

그리고 여기에 출력이 있습니다.

파이썬

def D(A):
    try:
        return sum(D(x)**2 for x in A)
    except TypeError:
        return A
print hex(D([[[[33,22,3,1],[20,13,2],5],[[31,19,1],[11,5,3],1]],[[[26,13],[18,14,6,4],1],[[12,10],[10,3,1],2],4],28]))

대상 수를 최대 네 개의 제곱으로 재귀 적으로 분해합니다. 내 기본 사례는 <100입니다. 분해를 계산하기 위해 http://www.alpertron.com.ar/FSQUARES.HTM 을 사용했습니다.

(아마도 <= 1의 기본 사례는 흥미 로웠을 것입니다 ...)

파이썬

def church(i):
    if i > 0:
        return 'f(' + church(i-1) + ')'
    else:
        return 'x'

def church_string(bs):
    import base64
    return church(int(base64.b16encode(bs), 16))

print(church_string(b'hello world'))

결과는 정말 숫자입니다, 맹세합니다!

숫자가 적은 C 재미, 특별한 것은 없습니다.

int main()
{
    int a , b, c;
    double i = 0, f = 0;

    for (; i < 1; i += .00000012785666)
        f += cos(i);
    c = f;
    a = f * 276.393089;
    b = a + f * 7.4358109;

    printf("%.4s%.4s%.4s\n", &a, &b, &c);
}

데모

(+ 110145154154157040127157162154144 0)