Votre tâche consiste à inverser l'ordre dans lequel certains printssont exécutés.

Spécifications:
Votre code sera sous cette forme:

//some lines of code
/*code*/ print "Line1" /*code*/
/*code*/ print "Line2" /*code*/
/*code*/ print "Line3" /*code*/
/*code*/ print "Line4" /*code*/
//some lines of code

Vous devrez print(ou echo, ou write, ou équivalent) ces chaînes du quatrième au premier.

• Vous décidez quelles lignes de votre programme doivent printles chaînes, mais elles doivent être adjacentes ;

• Chaque ligne ne peut en contenir qu'une seule printet ne peut dépasser 60 octets de long.

• Comme il s’agit d’un concours de popularité , soyez créatif et évitez d’écrire simplement un gotooufor(i){if(i=4)print"Line1";if(i=3)...}

• La réponse la plus votée en 2 semaines a gagné.

• Votre sortie DOIT être Line4 Line3 Line2 Line1 OR Line4Line3Line2Line1 ou Line4\nLine3\nLine2\nLine1 (où \nest une nouvelle ligne), et elle doit être générée uniquement en les exécutant à l' printsenvers.

Bonne codage!

MISE À JOUR: Le concours est terminé! Merci à tous :)

Commodore 64 BASIC

40 print "Line 1"
30 print "Line 2"
20 print "Line 3"
10 print "Line 4"

PHP

Abus de préséance ... :-)

!print "Line1\n".
!print "Line2\n".
!print "Line3\n".
!print "Line4\n";

C

Un comportement indéfini est le type de comportement le plus excitant!

f(){}
main()
{
   f(printf("Line 1\n"), 
     printf("Line 2\n"), 
     printf("Line 3\n"), 
     printf("Line 4\n"));
}

La sortie réelle peut varier en fonction du compilateur, de l'éditeur de liens, du système d'exploitation et du processeur :)

Java

En utilisant la réflexion

public class ReversePrint {
    public static void main(String[]a) {
        System.out.println("Line1");
        System.out.println("Line2");
        System.out.println("Line3");
        System.out.println("Line4");
    }
    static {
        try{
            Field f=String.class.getDeclaredField("value");
            f.setAccessible(true);
            f.set("Line1","Line4".toCharArray());
            f.set("Line2","Line3".toCharArray());
            f.set("Line3","Line2 ".trim().toCharArray());
            f.set("Line4","Line1 ".trim().toCharArray());
        }catch(Exception e){}
    }
}

Sortie:

Line4
Line3
Line2
Line1

Une explication de pourquoi cela fonctionne peut être trouvée ici .

C (et sorte de Python)

Nouvelle version, utilisant une macro pour s'adapter parfaitement au format de la question. Suite au commentaire de Quincunx, j’ai ajouté returnpour le rendre plus agréable.

Cela fonctionne également en Python, mais l’impression se fait dans le bon ordre.

#define print"\n",printf(
#define return"\n"))));}
#define def main(){0?

def main():
    print "Line 1"
    print "Line 2"
    print "Line 3"
    print "Line 4"
    return

main();

Version originale - les deux sont pratiquement les mêmes, après substitution de macro:

main(){
    printf("Line 1\n",
    printf("Line 2\n",
    printf("Line 3\n",
    printf("Line 4\n",
    0))));
}

ES6 (en mode arrière;)

Wow, il semblerait que les concepteurs d'ECMAScript aient fait preuve d'une clairvoyance incroyable en intégrant le mode arrière dans la spécification:

// activate backwards mode:
'use backwardsˈ; \* mode backwards in now *\
code of lines some ⧵\
\*code*\ "Line1" print \*code*\
\*code*\ "Line2" print \*code*\
\*code*\ "Line3" print \*code*\
\*code*\ "Line4" print \*code*\
code of lines some ⧵\
⁏ˈforwards useˈ // back to ˈnormal'.

// So simple! No need to do anything this complicated:
split('"').reduce((L,o,l)=>(l%2?o:'')+L,'')

Résultat (évaluation, vraiment):

"Line4Line3Line2Line1"

Notez que c'est exactement de la forme demandée, avec seulement une légère rétro-information pour correspondre à la syntaxe du mode . Notez également que ce mode est pris en charge dans les versions récentes de Firefox au moment .

Note finale: En fait, il n'y a pas de mode arrière. Mais ceci est toujours un script valide qui tourne dans Firefox (copiez le tout). :RÉ

ES6 "mode lax"

BONUS : Voici une version mise à jour qui n'utilise pas le mode précédent, mais utilise le "mode laxiste" nouvellement spécifié, dans lequel le moteur JS essaiera simplement de deviner ce que le code est censé faire, quelle que soit la syntaxe spécifiée par JS ( fondamentalement l'antithèse du mode strict):

// activate "lax" mode:
`use laxˋ; // also works: ˋuse relaxˋ, ˋuse guessingˋ, ˋuse whatevsˋ, etc.
//some lines of code
/*code*/ print "Line1" /*code*/
/*code*/ print "Line2" /*code*/
/*code*/ print "Line3" /*code*/
/*code*/ print "Line4" /*code*/
//some lines of code
ˋuse normalˋ; // same as ˋuse default`.

// Again, compare to inferior, illegible "traditional" ES6:
split('"').reduce((L,o,l)=>(l%2?o:'')+L,'')

Veuillez noter que le " mode lax " est actuellement disponible uniquement dans Firefox> = 34.; P

C

main()
{
  int i = 0;
  for(; i == 0; printf("Line 1\n"))
    for(; i == 0; printf("Line 2\n"))
      for(; i == 0; printf("Line 3\n"))
        for(; i == 0; printf("Line 4\n"))
          i = 1;
}

Rubis

print 'Line1' unless
print 'Line2' unless
print 'Line3' unless
print 'Line4'

Edit: Alternativement,

def method_missing(meth,*)
  puts meth.to_s.sub('print'){}
end

printLine1(
printLine2(
printLine3(
printLine4)))

PHP

Je sais, c'est de la folie ...

goto d;
a: print "Line1\n"; goto end;
b: print "Line2\n"; goto a;
c: print "Line3\n"; goto b;
d: print "Line4\n"; goto c;
end: exit;

Haskell

Ceci est presque idiomatique en Haskell, car le programme ressemble maintenant à une composition de fonctions de droite à gauche. Si la fonction n'était pas imprimée, mais que quelque chose renverrait une valeur (utile), la déclaration de l'opérateur ne serait pas nécessaire et le code serait quelque chose que vous verriez dans les bibliothèques.

a << b = (const a =<< b)

main = putStrLn "Line1"
    << putStrLn "Line2"
    << putStrLn "Line3"
    << putStrLn "Line4"

Perl

use threads;

$a=threads->create(sub {sleep(5); print("Line1\n");});
$b=threads->create(sub {sleep(4); print("Line2\n");});
$c=threads->create(sub {sleep(3); print("Line3\n");});
$d=threads->create(sub {sleep(2); print("Line4\n");});

$a->join();
$b->join();
$c->join();
$d->join();

HTML + CSS

<p>Line 1</p>
<p>Line 2</p>
<p>Line 3</p>
<p>Line 4</p>

CSS:

body {margin-top:7em}
p + p {margin-top:-4em}

Voir jsFiddle .

Edit:
Pour mieux se conformer aux règles, voici une variante en XML, qui utilise réellement print.

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet href="style.css"?>
<root>
  <print>Line 1</print>
  <print>Line 2</print>
  <print>Line 3</print>
  <print>Line 4</print>
</root>

où style.css devrait être

* {display:block; margin-top:3em}
print + print {margin-top:-3em}

HTML sans CSS

Et pour le plaisir, en voici un sans CSS.

<table>
<tfoot><tr><td><table><tfoot><tr><td>Line 1</tr></tfoot>
<tbody><tr><td>                      Line 2</table></tfoot>
<tbody><tr><td><table><tfoot><tr><td>Line 3</tr></tfoot>
<tbody><tr><td>                      Line 4</table></tbody>
</table>

Violon .

C ++

#include <iostream>
#define Q(x,y) x ## y
#define P(x,y) Q(x, y)
#define print S P(s, __LINE__) =
struct S { const char *s; S(const char *s): s(s) {} ~S() { std::cout << s << std::endl; } };
int main() {
    print "Line1";
    print "Line2";
    print "Line3";
    print "Line4";
}

(Les variables locales sont détruites dans l'ordre inverse de la déclaration.)

C ++ 11

#include <iostream>
int main() {
    struct S { void (*f)(); S(void (*f)()): f(f) {} ~S() { f(); } } s[] = {
        {[](){ std::cout << "Line1" << std::endl; }},
        {[](){ std::cout << "Line2" << std::endl; }},
        {[](){ std::cout << "Line3" << std::endl; }},
        {[](){ std::cout << "Line4" << std::endl; }},
    };
}

(Le même principe, mais utilisez plutôt lambdas et un membre de données de tableau.)

Haskell

main = sequence_ $ reverse [
    putStr "Line1",
    putStr "Line2",
    putStr "Line3",
    putStr "Line4"]

Javascript

setTimeout(function(){console.log("Line 1");},900);
setTimeout(function(){console.log("Line 2");},800);
setTimeout(function(){console.log("Line 3");},700);
setTimeout(function(){console.log("Line 4");},600);

C

Essayer de défier les astuces de la question de la manière la plus créative possible:

#include <stdio.h>
#define print if (i == __LINE__) puts
static unsigned i;
int main(void) {
  while (--i) {
    print("Line 1");
    print("Line 2");
    print("Line 3");
    print("Line 4");
  }
  return 0;
}

BF

Suppose que les cellules sont emballées.

++++[->+
----[> (line 1) .[-]<]++++
---[> (line 2) .[-]<]+++
--[> (line 3) .[-]<]++
-[> (line 4) .[-]<]+
<]

Pourquoi ça marche

Les première et dernière lignes composent une boucle qui se répète quatre fois (counter = cell0).

Dans la boucle, il existe une variable de compteur ( cell1) qui est augmentée à chaque exécution.

Chaque ligne vérifie si elle diminue de quatre, trois, deux ou un égal à zéro. Par conséquent, lors de la première exécution, le compteur est égal à un et la dernière ligne est exécutée, lors de la deuxième exécution, la troisième ligne est exécutée, etc.

La (line 1)montre où vous devez faire le texte qui est imprimé. Les flèches dans les boucles allouées cell2à cette fin. Le [-]nettoie cell2après que vous l'utilisez.

Frapper

En mémoire du vénérable SleepSort et SleepAdd , je vous présente ... SleepReverse :

#!/bin/bash

function print(){(sleep $((4-$1));echo "Line $1";)&}

print 1
print 2
print 3
print 4

Java

import java.io.PrintStream;
import java.util.concurrent.FutureTask;

public class Print {
  public static void main(String[] args) {
    new FutureTask<PrintStream>(new Runnable() {
      public void run() {
        new FutureTask<PrintStream>(new Runnable() {
          public void run() {
            new FutureTask<PrintStream>(new Runnable() {
              public void run() {
                System.out.append("Line1"); }
            }, System.out.append("Line2")).run(); }
        }, System.out.append("Line3")).run(); }
    }, System.out.append("Line4")).run();
  }
}

Tout est dans le bon timing ... ;-)

Python 3

import atexit

atexit.register(print,"Line1")
atexit.register(print,"Line2")
atexit.register(print,"Line3")
atexit.register(print,"Line4")

Frapper

Voici le script à double face:

#!/bin/bash
s=1
if [ $s -ne 0 ]; then tac $0 | bash; exit; fi
s=0
echo "Line1"
echo "Line2"
echo "Line3"
echo "Line4"

Common Lisp № 1

Il est facile d'écrire une ngorpmacro qui exécute ses formulaires dans l'ordre inverse:

(macrolet ((ngorp (&body ydob) `(progn ,@(reverse ydob))))
  (ngorp
   (write-line "Line 1")
   (write-line "Line 2")
   (write-line "Line 3")
   (write-line "Line 4")))

Line 4
Line 3
Line 2
Line 1

Common Lisp № 2

En voici un qui prend le problème très littéralement; le code de la question apparaît dans le programme sans modification:

(macrolet ((execute-prints-backwards (&body body)
             `(progn 
                ,@(nreverse (mapcar (lambda (string)
                                      (list 'write-line string))
                                    (remove-if-not 'stringp body))))))
  (execute-prints-backwards

//some lines of code
/*code*/ print "Line1" /*code*/
/*code*/ print "Line2" /*code*/
/*code*/ print "Line3" /*code*/
/*code*/ print "Line4" /*code*/
//some lines of code

  ))

Line4
Line3
Line2
Line1

PHP

Une autre evalvariante:

$lines=array_slice(file(__FILE__),-4); // get last 4 lines of current file
eval(implode('',array_reverse($lines)));exit; // eval lines reversed and exit
print "Line1\n";
print "Line2\n";
print "Line3\n";
print "Line4\n";

F#

let inline (?) f g x = g x; f x

(printfn "Line1%s") ?
 (printfn "Line2%s") ?
  (printfn "Line3%s") ?
   (printfn "Line4%s") ""

Vient de créer un opérateur personnalisé qui exécute les fonctions dans l’ordre inverse.

Go (Golang)

package main

import "fmt"

func main() {
    defer fmt.Println("Line 1")
    defer fmt.Println("Line 2")
    defer fmt.Println("Line 3")
    defer fmt.Println("Line 4")
}

Essayez-le: http://play.golang.org/p/fjsJLwOFn2

Python3

print("Line1",
print("Line2",
print("Line3",
print("Line4") or '') or '') or '')

Peut être plus court de 6 octets en supprimant tous les espaces de la dernière ligne.

Javascript

[
  "console.log('Line1')",
  "console.log('Line2')",
  "console.log('Line3')",
  "console.log('Line4')"
].reverse().forEach(function(e){eval(e)})

C ++ 11

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<std::function<void()>> functors;
    functors.push_back([] { std::cout << "Line1"; });
    functors.push_back([] { std::cout << "Line2"; });
    functors.push_back([] { std::cout << "Line3"; });
    functors.push_back([] { std::cout << "Line4"; });
    std::reverse(functors.begin(),functors.end());
    std::for_each (functors.begin(), functors.end(), [](std::function<void()> f) {f();});
    return 0;
}

Lot

echo off

call :revers ^
echo.line1 ^
echo.line2 ^
echo.line3 ^
echo.line4

:revers
if not "%2"=="" call :revers %2 %3 %4 %5 %6 %7 %8 %9
%1

C #

Au lieu d'appeler directement la méthode Run, je crée une méthode dynamique qui contient une copie du bytecode IL de Run, à la différence près que les opérandes d'opcode de chaîne de chargement sont échangés. Ce qui entraîne la nouvelle méthode pour afficher les chaînes dans l'ordre inverse.

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;

namespace TestApp
{
    class Program
    {
        public static void Run()
        {
            Console.WriteLine("Line 1");
            Console.WriteLine("Line 2");
            Console.WriteLine("Line 3");
            Console.WriteLine("Line 4");
        }


        static void Main(string[] args)
        {
            var method = typeof(Program).GetMethod("Run");
            var il = method.GetMethodBody().GetILAsByteArray();
            var loadStringOperands = new Stack<int>();
            for (int i = 0; i < il.Length; i++)
            {
                if (il[i] == OpCodes.Ldstr.Value)
                {
                    loadStringOperands.Push(BitConverter.ToInt32(il, i + 1));
                    i += 4;
                }
            }

            var run = new DynamicMethod("Run", typeof(void), null);
            var gen = run.GetILGenerator(il.Length);
            for (int i = 0; i < il.Length; i++)
            {
                if (il[i] == OpCodes.Ldstr.Value)
                {
                    var str = method.Module.ResolveString(loadStringOperands.Pop());
                    gen.Emit(OpCodes.Ldstr, str);
                    i += 4;
                }
                else if (il[i] == OpCodes.Call.Value)
                {
                    var mInfo = method.Module.ResolveMethod(BitConverter.ToInt32(il, i + 1)) as MethodInfo;
                    gen.Emit(OpCodes.Call, mInfo);
                    i += 4;
                }
                else if (il[i] == OpCodes.Ret.Value)
                {
                    gen.Emit(OpCodes.Ret);
                }
            }

            run.Invoke(null, null);
        }
    }
}

Python

encore une autre solution en utilisant eval()

a = [
"print('Line1')",
"print('Line2')",
"print('Line3')",
"print('Line4')"]

for line in reversed(a):
    eval(line)

ce n'est pas très complexe, mais facile à comprendre.