Ukryj powitanie Brainf *** w innym kodzie

13

Celem jest napisanie programu (cokolwiek poza jawnym pieprzeniem mózgu), który wydrukuje najlepszą zasadę Barneya Stinsona :

Nowe jest zawsze lepsze.

gdy interpretowane normalnie, ale

Legen ... poczekaj na to ... pamiętny!

Przetwarzane za pomocą interpretera Brainfuck.

Niech wygra najpopularniejszy brat. Masz 72 godziny na legendarność.

popularity-contest  polyglot  brainfuck 
— Thomas Ayoub
źródło
Nie jestem pewien, czy code-golfjest to najlepszy tag dla tego wyzwania. IMHO popularity-contestbyłoby lepsze.
— Florent,
3
Czyj Barney? Fioletowy dinozaur? Fred's BFF?
1
@LowerClassOverflowian Jak poznałem postać Twojej Matki, zobacz edycję
— Thomas Ayoub
4
Czy ktoś może utworzyć tag „konkurs-brokat”?
— Pierre Arlaud,
1
@Florent, jeśli wyzwanie ma zostać wygrane przez najkrótszą odpowiedź, nie sądzę, abyś powrócił do konkursu popularności. Samoth, jeśli nie wiesz, w konkursie popularności zwycięzca wybierany jest przez wyborców - wygrywa odpowiedź z najwyższym głosem. Jeśli chcesz, aby Twój konkurs został wygrany przez odpowiedź z najkrótszym kodem, ponownie oznacz swoje pytanie jako golf-golf, a jeśli chcesz, aby był to konkurs popularności, edytuj swoje pytanie.
— user12205

Odpowiedzi:

11

DO#

Postanowiłem więc trochę bardziej ... kreatywnie z moim wpisem. Kod Brainfuck jest osadzony w C # jako różne operatory (nie w komentarzach ani w ciągach zakodowanych na sztywno), podczas gdy sam kod C # działa na podobnej zasadzie jak sposób, w jaki Brainfuck drukuje znaki (co oznacza, że ​​nie ma zakodowanych ciągów, a C # generuje każdy indywidualny znak jako liczba całkowita następnie rzutuje go na znak podczas drukowania).

Jestem pewien, że mógłbym uczynić to bardziej eleganckim, ale zajęło mi to wystarczająco dużo czasu, aby zakończyć.

Wszystko zostało przetestowane na tym interpretatorze JavaScript Brainfuck przez Cal Henderson i kompilatorze C # Visual Studo 2012 (ukierunkowanym na .NET Framework v4.0).

using System;

namespace Polyglot
{
    internal static class Program
    {
        private static void Main()
        {
            var a = new short[50];

            short _1 = 72;
            short _2 = 0;
            short _3 = 0;
            short _4 = 0;
            short _5 = 0;
            short _6 = 0;
            short _7 = 97;
            short _8 = 0;
            short _9 = 0;
            short _10 = 0;
            short _11 = 0;
            short _12 = 0;
            short _13 = 0;
            short _14 = 0;
            short _15 = 0;
            short _16 = 46;
            short _19 = 0;
            short _20 = 0;
            short _21 = 0;

            if( 0 >= 0 )
            {
                ++_1;
                ++_1;
                ++_1;
                ++_1;
            }

            a[ -1 < 0 ? 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 : 0 + 1 > 1 ? 0 : 0 ] = 9001;

            if( 7 < 42 )
            {
                ++_1;
                ++_1;
            }

            Console.Write( (char)_1 );

            _2 = 101;
            _1 += 1 + 1 + 1 + 1 + 1;

            _3 = 42 > 7 ? 110 + 9 : 1 + 1;

            a[ -1 < 0 ? 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 : 0 > 0 ? 0 : 0 ] = 9001;

            if( 1 < 2 )
                _4 = 32;

            Console.Write( (char)_2 );

            ++_1;
            _5 = 105;

            Console.Write( (char)_3 );

            --_1;

            _6 = 115;

            Console.Write( (char)_4 );

            ++_1;
            ++_1;
            ++_1;
            _1 += 1 + 1 + 5;

            Console.Write( (char)_5 );

            --_1;
            --_1;

            if( 42 > 41 )
            {
                ++_1;
                ++_1;
                ++_1;
            }

            a[ -1 < 0 ? 0 : 10 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 - 1 > 5 ? 0 : 0 ] = 9001;

            if( 42 < 9001 )
                Console.Write( (char)_6 );

            Console.Write( (char)_4 );
            Console.Write( (char)_7 );

            if( 12 > 11 && 11 > 10 )
            {
                _8 = 108;
                _9 = _3;
            }
            else
            {
                ++_1;
                ++_1;
                ++_1;
            }

            a[ -1 < 0 ? 1 + 1 + 1 + 1 + 1 + 1 : 1 > 2 ? 0 : 0 ] = 9001;

            if( _4 < _1 )
            {
                ++_1;
                Console.Write( (char)_8 );
            }
            else if( _4 > _19 && _2 > _20 )
            {
                ++_21;
                ++_21;
                ++_21;
                ++_21;
                ++_21;
                _21 += (short)( _21 + 36 );
            }

            a[ -7 < 9 ? 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 : 4 > 8 ? 9 : 9 ] = (short)( 12 < 10 ? -_4 : _9 );
            Console.Write( (char)_9 );

            if( _4 > _9 )
            {
                ++_1;
                ++_1;
                ++_1;
            }

            a[ -9 < 7 ? 10 - 1 - 1 - 1 - 1 : 6 > 7 ? 0 : 0 ] = _21;

            if( 1 < 0 )
                return;
            else
            {
                ++_1;
                Console.Write( (char)_7 );
            }

            _10 += 5 + 4 + 1 + 2 + 8 + 9 + 1 + 91;
            Console.Write( (char)_10 );

            if( 10 > _4 ) ++_21; else a[ -0 < 0 ? 5 + 6 + 1 + 2 + 3 + 9 : 1 > 2 ? 0 : 9 ] = 50;

            if( _21 <= _4 )
                _11 = 58 + 57;

            Console.Write( (char)_11 );

            if( _2 <= _8 )
                Console.Write( (char)_4 );
            else if( 1 >= 2 )
                return;
            else if( 42 >= _4 )
                _1 += ++_21;
            else
            {
                a[ -99 < --_1 ? --_1 - _1 : 44 > 12 ? 9 : 7 ] = (short)( _2 < _4 ? _21 : 6 );
                throw new Exception();
            }

            switch( _4 )
            {
                case 32:
                    var x = (char)( (short)( _4 + 66 ) );
                    Console.Write( x );
                    break;
                default: break;
            }

            _12 += (short)( ++_12 + ( ++_1 ) + 1 + 1 + 1 );
            Console.Write( (char)_12 );

            _13 += (short)( 39 + 38 + 39 );
            Console.Write( (char)_13 );

            if( _12 < _13 )
                Console.Write( (char)_13 );

            if( _13 >= _4 )
            {
                _14 = (short)( 500 - ( - ( 50 ) ) - ( --_1 ) - 90 - ( -4 ) - 267 );
                Console.Write( (char)_14 );
            }

            switch( _1 )
            {
                case 52:
                    _15 += (short)( ++_1 + ( ++_21 ) );
                    break;
                default:
                    _15 += (short)( 15 + ( ++_1 ) + 2 );
                    break;
            }

            Console.Write( (char)_15 );

            if( _16 <= 3521 && _21 < _4 )
                Console.WriteLine( (char)_16 );

            _16 = (short)( Int16.Parse( "54" ) % 2 );
            _20 = (short)( Int16.Parse( "99" ) / ( _1 > _4 ? 3 : 0 ) );
            _1 = (short)( 02.23 );

            if( _16 > 9 || _20 >= 52 )
                _1 += (short)( ( ++_1 ) + _21 );

            a[ -0 < 0 ? -52 - ( --_20 ) : 1 > 0 ? 1 : 2 ] = (short)( _12 < _19 ? Int16.Parse( "19" ) : 44 );
            _12 -= (short)f( --_19 / 19.467d );

            if( _12 > _14 )
                _19 += (short)( _19 + 1 + _3 + 5 );

            a[ -904 < 409 ? 4 + ( ++_4 ) + 4 : 49 > 50 ? 49 : 50 ] = (short)( 50 < 99 ? _4 + 669.2452 : 0 );

            if( 44 > ++_4 )
                a[ -9 < 6 ? 6 + ( ++_4 ) : 9 > 2 ? 44 : 8 ] = 3;
        }

        private static double f( double x )
        {
            return x < 12 ? x + 13.22 : x < 6 ? x + 90.45 : 5555; 
        }
    }
}

Oto oryginalny kod Brainfuck, który napisałem dla tego wyzwania:

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

Podczas uruchamiania kodu C # przez interpreter Brainfuck, otrzymujesz następujące polecenia (zwróć uwagę na dodanie nawiasów kwadratowych na początku, są one z deklaracji tablicy i nic nie robią, ponieważ komórka pod wskaźnikiem pamięci w tablica będzie już miała wartość 0):

[] > +++++ +++
[ - < +++++ ++++ > ]
< ++++ .
+++++
> ++
[ - < +++++ +++++ > ]
< . ++ . -- . +++++ ++++ .
----
> +++++ +
[ - < ----- ----- > ]
< ... >>
+++++ +
[ - < +++++ > ]
< ++ . >>
+++++ +++++ ++
[ - < +++++ +++++ > ] <
- . >
+++++ +
[ - < ---- > ] <
++ . +++++ +++ .
> ++
[ - < +++++ > ]
< + . < . >>
+++
[ - < ----- > ] <
+ . +++++ ++++ . +++ .
< . > ----- ---- . +++++ +++++ + .
<< ... > . >>
++++
[ - < ---- > ] < .
--- . >
++++
[ - < ++++ > ]
< + .
> ++
[ - < +++ > ]
< + . < + .
— Tony Ellis
źródło
6

Pogawędka

"adding adding all the time"
"1+1+1+1+1+1+1+1+1+1+1" "is not fine"
"more to come / going far" 
"+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1"
"all that work for a single char"

"happy me / a loop to start" 
"[>++>+++>++++>+++++<<<<-]"
"was it code or just a fart?"
"adding adding / thats not fine"
"+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1"

">>+" 'New is always better.' "shall I " print
">+.++.--.+++++++++.----------.<<----...<+++++++"
"the garbage here gives us no hint"
".>>+++++++++++.>---.++++++++" 

"hurray a change to stop the pain" 
".>---------.<<<<.>>" 
"the author now has in his brain"
"-----------------.>>-----.+++.<<<<.>>>.>++."
"We all agree the time is here"
"<<<...<.>>--.>--------.>--.+++++++.<<<<."
"to finish this and have a beer"

wpisz w obszarze roboczym i naciśnij „doIt” lub wyślij do BF. BF skradziony z innych plakatów - dzięki.

— blabla999
źródło
4

JavaScript / Brainfuck

Wersja bez golfa, ponieważ nie jest to konkurs golfowy:

var outputString='';
'+++++++@++++[>++@/+@@>@/+@+@++>++++++@/+>+@++@/+@@+++++@/>@+@+++++@/+++@+<@/<<<<-]>>>@-.>++.+@/+@@.--.>.<-@/.@<@<++...<-.@/>>>>+++++@++++.<-@/-@-.@+@/+@+@+++++@/.>-@--@/.<<<<.>>>@---.>---@/-@@-@/.@+@++.<<<@/<@.@>>>+++@/.@@>@/+@+@.<<<@/...<@.>>>--@/---.---.>--.+++++++.<<<<+.<'
  .split('/')
  .forEach(function(e) {
    var matched=e.match(/[^@]*@/g);
    if (matched) {
      var asciiCode=0;
      for(var i=0;i<matched.length;i++) {
        asciiCode=matched[i-0].length-1+10*asciiCode;
      }
      outputString+=String.fromCharCode(asciiCode);
    }
  });
  alert(outputString);

To była okazja dla mnie do nauki BF i było fajnie :)
Trudność polegała na tym, aby nigdy nie używać, ,ponieważ BF interpretuje to jako dane wejściowe użytkownika i upewnij się, że bajt ma wartość 0 przed użyciem []do uzyskania dostępu do elementów tablic.
Kodowanie JS jest dość proste, każdy ciąg znaków przed /kodowaniem znaku i każdy ciąg znaków przed @zdefiniowaniem kodu ASCII w systemie dziesiętnym. ( +++++++@++++[>++@= 78= N)

Możesz przetestować Brainfuck tutaj: http://copy.sh/brainfuck/

— Michael M.
źródło
3

Cubically ( TIO ) / BF ( TIO )

+5+1/1+5+3@6:2/1+5+5+1@6+2@6:5/1+3@6:5+1/1+5+5+1@6:5+2/1+5+5+2@6:5/1+3@6:5+2/1+5+5@6:5+5+2@6:2/1+5+53[@6>:5+2/1+5+5@6>:4/1+5+5+3@6+>:5+2/1+55+2@6:5/1+3@6>:5+3/1+55@6>:2/1+551@6<<<<<-]>:5+3./1+552-@66>+.:2/1+5+51.@6--.>:5+1/1+5+5+2@6:1/1+5@6+++++.>----...>+++++++.<<+++++++++.<----.++++++++.>---.>>.<<<---.>-----.+++.>>.<<<+++.>++.>...>.<<<-----.---.>--.+++++++.>>+.

(Zaktualizowano 8/4/17, aby uwzględnić zmiany językowe w Cubically)

Zasadniczo wykorzystuje to tyle znaków z programu BF, ile może w programie Cubical, a następnie przykleja resztę programu BF na jego końcu. Nie jest wymagane wymuszone zakończenie z &/ Ew programie Cubically.

— TehPers
źródło
2

Python / BrainF ** k, 362 znaków

Kod BrainF ** k wzięty z usuniętej odpowiedzi Clémenta Renauda.

Edycja - początkowy znak zerowy nie jest już drukowany.

t='++++++++++_+++++++|^+++++++|+[>++>+++%>++++>+++++<<<<-||]+++++++++++|*+++++++++++++@+>>+.>+||.++.|--.+++++++++.--|^--------.<<----..._<+++++|++.>|>+++++&++++++.>---.+=+++++++|.>---------.<<^<<.>>--||-----|--~-----|---.>>-----~.+++.<<<<.>|>>.*>++.<<<...<.>>--._>|--------|.>-^-.+++++++.<<<<!!!'
print ''.join((chr(93+len(x))if x else' ')for x in t.split('|'))

Wykorzystuje bardzo prostą sztuczkę - |znaki zostały dodane do programu BF, a odległości między nimi kodują ciąg wydrukowany w Pythonie. Kod Python jest w większości ignorowany przez BF.

— ugoren
źródło
Czy można wydrukować „0” na początku?
— VX
@VX, Być może nie jest. Kod BF jest kopiowany i zauważyłem, że .joindodano ., ale nie widziałem żadnej szkody (ponieważ \0jest niewidoczny). +Jest i .splitsą OK - usunąłem znaki od oryginału.
— ugoren
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.