Schreiben Sie eine mathematische Funktion, die zu einer ganzzahligen Darstellung der "Hallo Welt" führt.

Zum Beispiel ist "Hallo Welt" in hex 68656c6c6f20776f726c64so, dass das Ziel darin besteht, ein mathematisches Programm zu schreiben, das zu einer Zahl führt, die "Hallo Welt" darstellt.

Hier ist ein Beispiel für eine mögliche Lösung mit Python:

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

Jede Art von mathematischen Gleichungen kann verwendet werden, wie z. B. Potenzen, Reihen, Fakultäten und andere mathematische Operationen.

Die Regeln:

• Sie können Ihren eigenen Weg wählen, um "Hallo Welt" als Ganzzahl zu kodieren / darzustellen. Hash-Funktionen sind ebenfalls zulässig

• Mathematische Bibliotheken (zB numpy, GMP) sind erlaubt.

• Die Absicht ist, sich auf den mathematischen Teil zu konzentrieren

Python 2.7

Ein gewisser Missbrauch des Zufallszahlengenerators funktioniert unter Python 2.7, jedoch nicht unter Python 3.x, da der Generator den Seeding-Algorithmus geändert zu haben scheint.

>>> 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

Ich werde es besser machen als nur zu drucken, ich werde es unendlich oft drucken!

Die rationale Zahl

1767707668033969 / 3656158440062975

Gibt die folgende Base-36-Erweiterung zurück:

0.helloworldhelloworldhelloworldhelloworldhelloworld...

Versuch es! (Wolfram Alpha)

Oder wenn Sie eine unterschwelligere Botschaft wünschen, versuchen Sie:

2399843759207982499621172523113947162810942763812298565948669
/ 1357602166130257152481187563160405662935023615

Was zurückkehrt (wieder in Basis 36):

helloworld.helpimtrappedinanumberfactoryhelpimtrappedinanumberfactoryhelpimtrappedinanumberfactory...

Wenn Ihr Programm nur mit ganzen Zahlen arbeiten würde, würden Sie den Bruchteil nie sehen.

Python (noch nicht fertig ...!) Fertig! : D.

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)

Ausgaben 126207244316550804821666916(entspricht Ihrem Beispiel 0x68656c6c6f20776f726c64)

Sie können Ihren eigenen Weg wählen, um "Hallo Welt" als Ganzzahl zu kodieren / darzustellen.

Na dann...

PHP

<?=1?>

wo 1 "Hallo Welt" darstellt, weil ich es gesagt habe.

Taschenrechner Font / FreePascal

Ich kann in Schwierigkeiten geraten, weil ich das gepostet habe, aber ich werde es trotzdem tun :-)

1. Berechnen Sie 7734/100000. Ändern Sie die führende Null in Blau und die anderen Ziffern in Taschenrechnerschrift. Drehe es um. Das blaue O repräsentiert die Welt:

Wenn das zu faul ist, wie wäre es damit:

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.

Kreise mit der Nummer 0-5, Farbe bestimmt durch abs (2n-1). Eine hexadezimale Ziffer pro Kreis, Quadranten, die vom höchstwertigen Bit nach unten und im Uhrzeigersinn von unten rechts gefärbt sind. Durch die mystischen Konstanten 967EEF und EDF7E9 hex.

Besonderer Dank geht an das folgende Grundelement und an Borland, das es in TurboPascal eingefügt hat, damit FreePascal es klonen kann.

Prozedur Sektor (x: SmallInt; y: SmallInt; StAngle: Word; EndAngle: Word; XRadius: Word; YRadius: Word); Der Sektor zeichnet und füllt einen Sektor einer Ellipse mit Mittelpunkt (X, Y) und Radien XRadius und YRadius, beginnend mit dem Winkel Start und endend mit dem Winkel Stop.

Ruby & Python

Mit der Basis-36-Mathematik gelangen wir in Ruby & Python ganz einfach zu einer ganzzahligen Darstellung:

Rubin

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

Ergebnis:

[29234652, 54903217]

oder, ausgedrückt als allgemeine Funktion:

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

Beispiel:

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

Python

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

Beispiel:

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

Einige sorgfältig ausgearbeitete 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-Schema

#!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)))

Ausgaben # x68656c6c6f20776f726c64 (dezimal):

126207244316550804821666916

Meine ursprüngliche Implementierung war:

Schläger (Schemadialekt)

(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)))

JavaScript

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
);

Was ist los?

Wir nehmen diesen String und wenden ein wenig an stringTheory()(es ist eigentlich eine Übertragung aus der Zukunft):

'\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'

Zuerst teilen wir es an seiner Interpunktion auf, um Wörter zu bilden. Wir erstellen dann eine Reihe von Zahlen, indem wir die Zeichen in ihren dezimalen ASCII-Code konvertieren. Verbundene Buchstaben werden zu benachbarten Zahlen (zB aawerden 9797).

Die Zahlen werden dann summiert. Was wir zurückbekommen, ist 191212222216169eine völlig nutzlose Zahl, sie hat keine Bedeutung, ähnlich wie die Billiarden von Steinen, die untätig im Raum schweben. Was macht diese Welt so besonders? Warum ist es das Leben? Wenn wir dieser Zahl also den Sinn des Lebens geben, erhalten +=42 wir 191212222216211;

Aber warum?

Was bedeutet das? Warum es stringTheory("Hello world")natürlich bedeutet .

Python

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

Rubin

Jede Zeichenfolge wird einer Ganzzahl zugeordnet.

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

Die Umkehrfunktion:

# 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

Beispiele:

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

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

C #

Eine Methode zum Konvertieren einer beliebigen Zeichenfolge (Hallo Welt oder etwas anderes) in eine hexadezimale Zeichenfolge

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

Eine Methode zum Konvertieren einer hexadezimalen Zeichenfolge in eine Zeichenfolge

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;
}

Hier geht das komplette C # -Programm

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");
        }
    }
}

Und hier ist die Ausgabe.

Python

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]))

Zerlegt die Zielzahl rekursiv in Summen von höchstens vier Quadraten. Mein Basisfall ist <100. Ich habe http://www.alpertron.com.ar/FSQUARES.HTM verwendet , um die Zerlegungen zu berechnen.

(Vielleicht wäre ein Basisfall von <= 1 interessant gewesen ...)

Python

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'))

Das Ergebnis ist wirklich eine Zahl, ich schwöre!

Nur ein bisschen Spaß mit Zahlen, nichts Besonderes.

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);
}

Demo

(+ 110145154154157040127157162154144 0)