C'est Calvin . J'essaie juste d'obtenir 20 répétitions pour que cet utilisateur puisse clavarder dans la salle de discussion PPCG Minecraft Server .

Ecrivez un programme ou une fonction qui prend un entier positif.

Si l'entier est pair (2, 4, 6, ...), imprimez ou renvoyez cette chaîne d'art ASCII exacte:

                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |

Si l'entier est impair (1, 3, 5, ...), imprimez ou renvoyez cette chaîne d'art ASCII exacte:

                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

Vous pouvez supposer que l'entrée est toujours un entier positif.

Dans les deux cas de sortie, il peut éventuellement exister un nombre quelconque d'espaces de fin jusqu'au bord droit du "T" de chaque ligne et / ou un seul retour à la ligne de fin. Notez qu'il y a deux colonnes d'espaces entre chaque lettre.

Le code le plus court en octets gagne.

JavaScript (ES6), 343 336 289 267 265 260 octets

Juste pour le plaisir ... :) (Merci à Xufox d'avoir coupé 46 octets et de m'avoir encouragé à en supprimer 37 autres.)

n=>`887141${n%2?`
98/202/05/4|3/29 1 /2|5|
 92/92/30 / 0--2|5|--/492/3|--3|
29/29/40/2013912|1|59/4|12_|_`:`3185121_
2/92/9409205/405/94|5|
 /29/2930 9 0--2|5|--94/193|--3|
/892029013912|392/492|5|`}`.replace(/\d/g,x=>+x?x<2?'__':x<9?' '.repeat(x):'\\':'|  |')

Appelé comme a(4)ou similaire. Essayez-le ici:

a=n=>`887141${n%2?`
98/202/05/4|3/29 1 /2|5|
 92/92/30 / 0--2|5|--/492/3|--3|
29/29/40/2013912|1|59/4|12_|_`:`3185121_
2/92/9409205/405/94|5|
 /29/2930 9 0--2|5|--94/193|--3|
/892029013912|392/492|5|`}`.replace(/\d/g,x=>+x?x<2?'__':x<9?' '.repeat(x):'\\':'|  |')
document.getElementById("a").innerHTML = "<pre>"+a(2)+"</pre>";
document.getElementById("b").innerHTML = "<pre>"+a(3)+"</pre>";

<p id="a"></p>
<p id="b"></p>

J'ai condensé les espaces blancs en chaînes de chiffres allant de 2à 8(par exemple 887= 23 espaces). Chaque chiffre est ensuite remplacé par le nombre d'espaces correspondant. 0représente | |et 1représente __. En tout, ce programme a 170 octets de moins que les deux chaînes combinées (203 + 227 = 430), alors je suis heureux. :)

Edit: En quelque sorte, il a exactement la même longueur que la seule autre entrée à ce stade .... o_o

Edit 2: sauvé un peu d' espace en changeant n%2<1?pour n%2?et échanger les cordes. Nous avons également profité du fait que les débuts des deux chaînes sont les mêmes pour réduire encore 5 octets.

Edit 3: |2| semblait apparaître énormément, donc simplifié chaque occurrence en xéconomisant 7 octets. Les suggestions de Xufox coupent encore 40 octets.

Edit 4: La suggestion de Xufox de remplacer \nles sauts de ligne réels a été payante, supprimant 6 octets du total. Passer xà 0et __à 1(insérer un rire diabolique ici), puis combiner tous les éléments (insérer le pluriel de Regex ici), comme il l’a fait dans son entrée, économise 16 octets supplémentaires.

Edit 5: Depuis que j'ai choisi d’utiliser les standards ES6, j’ai utilisé une interpolation de chaîne de modèle personnalisée pour supprimer 2 octets finaux.

Matlab, 343 341

a=' -/\_|';
if mod(input(''),2)
x='003C00E00E000L0005N5000I000005550I0000I0055N4UVYO26R4004400400U005300UUXO060O060003C00C30CO00IO00UUUS060S5B54000';else
x='0I2000L0000L000E05H50C0000000555000C00C00H554UVYO26R4004400400U000250WUU006O006O0I2002I00O0I0O0C0UUU006S05BT0004';end
disp(a(reshape(dec2base(base2dec(reshape(x,[],7),36),6),4,[])-47))

Le numéro d'entrée est fourni par stdin.

Échantillon échantillon:

>> a=' -/\_|';
if mod(input(''),2)
x='003C00E00E000L0005N5000I000005550I0000I0055N4UVYO26R4004400400U005300UUXO060O060003C00C30CO00IO00UUUS060S5B54000';else
x='0I2000L0000L000E05H50C0000000555000C00C00H554UVYO26R4004400400U000250WUU006O006O0I2002I00O0I0O0C0UUU006S05BT0004';end
disp(a(reshape(dec2base(base2dec(reshape(x,[],7),36),6),4,[])-47))
1
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     | 

CJam, 158 149 145 138 octets

li2%"A+×rµ^ÅÆÿ»£ºoU#ü T^U^ÝZe<ÄÊKÞÒ£^ÛWWø5Úí§¹T^Úêer^^°^Ã}Ã^A0R2"281b7b"/
 -_\|"f=N/S3**_"_ ":T/TW%*4/zW%1m>N*1>"\/"_W%er"^W^]5OU"{i_32>T=t}/\4/zN*?

Ce qui précède utilise la notation caret, car le code contient des caractères non imprimables.

Essayez-le en ligne dans l' interprète CJam .

Si le permalien ne fonctionne pas dans votre navigateur, vous pouvez copier le code de cette pâte .

Exemple d'exécution

$ LANG=en_US
$ xxd -ps -r > minecraft.cjam <<< 6c69322522412bd772b585c6ffbba3ba6f5523fc2054159d5a653cc4ca4bded2a39b5757f835daeda7b9549aea65721eb0837dc30130523222323831623762222f0a202d5f5c7c22663d4e2f53332a2a5f225f20223a542f5457252a342f7a5725316d3e4e2a313e225c2f225f5725657222171d354f55227b695f33323e543d747d2f5c342f7a4e2a3f
$ cjam minecraft.cjam <<< 2; echo
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     | 
$ cjam minecraft.cjam <<< 1; echo
                       __    __                        
\        /  |  |  /|  |     /    |   /  \ __ /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

Idée

Au lieu d’encoder directement la chaîne MINECRAFT (complétée pour obtenir une longueur de ligne constante), nous encoderons une version "zippée" de celle-ci, dans laquelle les lignes et les colonnes ont été transposées.

Après avoir compressé et éliminé les sauts de ligne, cette chaîne (appelons-la R ) doit être codée:

   /  /  /   \    \   /  /   \    \    \         |||         ||| \    \    \ |||         |||_ -__ -_          |  / \_  __  _         |||_ - _ -  |\    \           /  /  /_  \_   \    \         |||_ - _ -         _   _|||_   

Il y a beaucoup de lignes d'espaces, nous allons donc remplacer chaque occurrence d'un triplet d'espace par un saut de ligne.

Cette feuille nous avec sept personnages différents ( \n -/\_|), donc nous assignent chacun d'eux un nombre compris entre 0 à 6 et examiner les chiffres du tableau résultant d'un indice de base 7, que nous avons ensuite encoder comme une chaîne d'octets.

Le décodage fonctionne en inversant les étapes précédentes.

La chaîne en miroir peut être construite à partir de celle d'origine.

Si nous inversons l'ordre des quatre lignes et échangeons les solidus, nous obtenons ce qui suit:

\        /  |  |  /|  |__   /__  |   /  \    /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \__/   |--   | 
  \/  \/    |  |/  |  |     \    |  |     \/    |     | 
                       __    __   __             __  ___

D'une certaine manière similaire, mais nous devrons clairement faire pivoter les lignes pour amener la ligne du bas vers le haut:

                       __    __   __             __  ___
\        /  |  |  /|  |__   /__  |   /  \    /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \__/   |--   | 
  \/  \/    |  |/  |  |     \    |  |     \/    |     | 

Ce serait le cas s'il n'y avait pas ces soulignements embêtants.

Si nous lisons la chaîne d'origine de haut en bas et ignorons les sauts de ligne (obtenant ainsi R ) et remplaçons chaque trait de soulignement suivi d'un espace par un espace suivi d'un trait de soulignement avant de décaler les lignes, le résultat est le suivant:

                         _     _                      _ 
\        /  |  |  /|  |_    /_   |   /  \ __ /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

Beaucoup mieux! Tout ce qui reste à faire est de supprimer le premier espace de la première rangée (décalage de tous les traits de soulignement dans la première rangée d' un caractère à gauche), le déplacement des traits de soulignement déplacé dans E et C une ligne vers le haut et à rejeter le soulignement sur T .

Code

li2%           e# Read an integer from STDIN and push its parity.

"A+×rµ^ÅÆÿ»£ºoU#ü T^U^ÝZe<ÄÊKÞÒ£^ÛWWø5Úí§¹T^Úêer^^°^Ã}Ã^A0R2"

281b7b         e# Convert the byte string from base 281 to base 7.
"/\n -_\\|"f=  e# Replace each digit by its corresponding character.
N/S3**         e# Turn linefeeds into three spaces.
_              e# Copy the resulting string.
"_ ":T         e# Define T.
/TW%*          e# Replace occurrences of T with T reversed.
4/z            e# Split into chunks of length 4 and zip.
W%1m>          e# Reverse and rotate the rows.
N*             e# Join the rows, separating by linefeeds.
1>             e# Discard the first character.
"\/"_W%er      e# Swap the soliduses.
"^W^]5OU"      e# Push the string that corresponds to [23 29 53 79 85].
{              e# For each character:
  i            e#   Push its code point.
   _32>        e#   Push 1 iff the code point is larger than 32.
       T=      e#   Select the element at that index from T = "_ ".
         t     e#   Replace the element at the code point's index with that char.
}/             e#
\              e# Swap the partially generated MINECARFT string on top.
4/z            e# Split into chunks of length 4 and zip.
N*             e# Join the rows, separating by linefeeds.
?              e# Select the first string iff the input was odd.

Pyth - 182 octets

Utilise l'approche de codage de base. Comme l'indexation est modulaire en Pyth, je n'ai même pas à faire quoi que ce soit, il suffit de le mettre dans le bon ordre et de l'utiliser @Q. En prime, cela fonctionne également avec des nombres négatifs.

@mjbcs@L"_| /\\-"jCd6 56,"EWbòH\x00B)þK٣ĭIOõìæ«FFãbÐÄBØ\«¼,vã<RN>­º:w÷ò¾<éifP9e|ÉWf!FÔèà""EWbòH\x00B)þOHÿ$@ËþçX'D[¾«Â?°´=&£üá ¹»ázH×Æz3äkÕg{`!|ðY!ðGV"Q

Je n'avais essayé que d'encoder le premier, puis de basculer et de changer les barres obliques, mais la première et la dernière ligne étaient trop difficiles.

Je pourrais économiser 6 octets en plaçant de vrais octets nuls dans le code, mais c'est trop compliqué.

Essayez-le en ligne ici .

Cela semble vraiment mauvais en ligne car la boîte de sortie est trop petite et enveloppante. Je recommande de jouer avec la console de développement et de changer le col-md-5en a col-md-7.

JavaScript (ES6), 312, 285, 281, 272, 270, 263, 262, 260

Pour les éditions précédentes, voir l' historique d'édition .

Edit 5: Lors de la conversion, j'ai changé le numéro associé à -(maintenant 0) et à l’espace (maintenant 1). Dans le bloc résultant, les nombres 1, 2 et 3 n'étaient plus autant utilisés. Cela m'a permis d'utiliser un tableau avec les nombres manquants.

Edit 6: Amélioré le littéral de tableau. J'avais déjà essayé cela auparavant, mais je l'utilisais comme chaîne 777et non 77comme un nombre et je ne remarquais que maintenant que j'avais raté ça.

Éditer 7: Le «code de golf» est une fonction, telle que spécifiée par la question et il n’est pas nécessaire f=de respecter cette spécification. Ainsi, le supprimer, économisant deux octets.

Runnable dans Firefox 39:

// Testing:

f=

// Golfed code:

n=>[...`11111113ss17ss1pp11117pp3ppp
97dj3dj7822j78z213e17z3v8397gm78212
7f3kf3k1z27k7z20021200k17fppk1z001z
d7983987j2287jz2ss1lss2aabj3d7987j2aa3aza`.replace(/[123]/g,x=>[,777,'77z',77][x])].map(a=>isNaN(i=parseInt(a,36))?a:'- /\\_|'[n%2?i%6:~~(i/6)]).join``

// Testing:

;document.body.appendChild(document.createElement('pre')).innerHTML=f(0);
document.body.appendChild(document.createElement('pre')).innerHTML=f(1);
document.body.appendChild(document.createElement('pre')).innerHTML=f(2);
document.body.appendChild(document.createElement('pre')).innerHTML=f(35);

Il est basé sur le système de numération de base 6 et chaque caractère ASCII représente un nombre:

"-": 0
" ": 1
"/": 2
"\": 3
"_": 4
"|": 5

Ensuite, j'ai combiné la représentation numérique de chaque chaîne ASCII. Par exemple: lorsque la première chaîne ASCII contient un /à une position et que l’ autre contient une \à la même position , cette position devient la 32base 6 ( 20en décimal). Si vous convertissez cela en base 36 (pour obtenir un numéro en base 36 pour deux nombres en base 6), vous obtenez k.

Tout cela a été fait à l’avance et la fonction annule fondamentalement ce processus.

Maintenant, les deux réponses JavaScript ont une autre réponse chacune, qui a le même nombre d'octets…

PS: Comme note personnelle et comme référence aux autres, voici le code que j'ai utilisé:

// 1. ASCII here
a=`|\\-/ _`;

// 2. ASCII here
b=`/|\\_ -`;

// Note: the ASCII strings’ backslashes have to be escaped!

[...a]
  .map((c,i)=>parseInt((c+b[i])
    .replace(/-/g,'0')
    .replace(/ /g,'1')
    .replace(/\//g,'2')
    .replace(/\\/g,'3')
    .replace(/_/g,'4')
    .replace(/\|/g,'5'),6))
  .map(c=>isNaN(c)
    ?`
`
    :c.toString(36))
  .join``
// Returns "wn3g7o", which is then put into the function as the block at the top.

CJam, 136 octets

"^ASÓ8¥È÷^K¯¾/^HÕ2^ÄË1jÒÝ^D^Á0îl;)HR§û|^Ê^Þ^ÇÝÅ^ßNlz^TfÑ^Øj>À^à 4#bH\¿^Äî·íì^E^A~(¿ø³(ú´,^È(¡j>è?#'»vçPïju87)×"
265b8b[S9*'|3*+S2*]"/-_\| "+f=s4/56/ri=zN*

Ce qui précède utilise la notation caret, car le code contient des caractères non imprimables.

Le saut de ligne est uniquement destiné à la "lisibilité". Essayez-le en ligne dans l' interprète CJam .

Si le permalien ne fonctionne pas dans votre navigateur, vous pouvez copier le code de cette pâte .

Exemple d'exécution

$ LANG=en_US
$ xxd -ps -r > minecraft.cjam <<< 220153d338a5c8f70bafbe2f08d53284cb316ad2dd048130ee6c3b294852a7fb7c8a9e87ddc59f4e6c7a1466d1986a3ec08320342362485cbf84eeb7edec05017e28bff8b328fab42c8828a16a3ee83f2327bb76e750ef6a75383729d7223236356238625b53392a277c332a2b53322a5d222f2d5f5c7c20222b663d73342f35362f72693d7a4e2a
$ cjam minecraft.cjam <<< 2; echo
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     | 
$ cjam minecraft.cjam <<< 1; echo
                       __    __                        
\        /  |  |  /|  |     /    |   /  \ __ /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

Idée

Cette approche présente certaines similitudes avec celle de mon autre réponse , mais elle est beaucoup plus simple et (plutôt décevante) un peu plus courte.

Nous cherchons un moyen d'encoder la chaîne suivante:

                       __    __   __             __  ___                       __    __                         
  /\  /\    |  |\  |  |     /    |  |     /\    |     | \        /  |  |  /|  |     /    |   /  \ __ /  |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |  \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     |   \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

Après avoir rempli chaque ligne (pour obtenir une longueur de ligne constante), zippé (transposition de lignes et de colonnes) et supprimé les sauts de ligne, cette chaîne doit être codée:

   /  /  /   \    \   /  /   \    \    \         |||         ||| \    \    \ |||         |||_ -__ -_          |  / \_  __  _         |||_ - _ -  |\    \           /  /  /_  \_   \    \         |||_ - _ -         _   _|||_    \    \    \   /  /   \    \   /  /  /           |||         |||   /  /  /   |||         |||_ -__ -_          |  / \_  __  _         |||  -_  -_  /| /           \    \  _ \ _ /  /  /           |||  -_  -_           _ |||   _

Nous allons remplacer chaque sous - chaîne " |||"avec un 0 , chaque sous - chaîne " "avec un 1 et les caractères de "/-_\| "avec deux à sept , en formant une matrice de base de 8 chiffres, qui peuvent être codés comme une chaîne d'octets.

Le décodage fonctionne en inversant les étapes précédentes.

Code

"^ASÓ8¥È÷^K¯¾/^HÕ2^ÄË1jÒÝ^D^Á0îl;)HR§û|^Ê^Þ^ÇÝÅ^ßNlz^TfÑ^Øj>À^à 4#bH\¿^Äî·íì^E^A~(¿ø³(ú´,^È(¡j>è?#'»vçPïju87)×"

265b8b        e# Convert from base 265 to base 8.
[S9*'|3*+S2*] e# Push ["         |||" "  "].
"/-_\| "+     e# Concatenate to push ["         |||" "  " '/' '-' '_' '\' '|' ' '].
f=            e# Select the elements that correspond to the base 8 digits.
s4/           e# Flatten and chop into chunks of length 4 (columns).
56/           e# Chop into two subarrays of 56 columns.
ri            e# Read an integer from STDIN.
=             e# Select the corresponding subarray.
              e# Arrays wrap around, so [A B]0= eq. [A B]2= and [A B]1= eq. [A B]3=.
zN*           e# Zip and join the rows, separating by linefeeds.

Raquette, 443 434 386 octets

(require file/gunzip net/base64)(define(f n)(define o(open-output-bytes))(gunzip-through-ports(open-input-bytes(base64-decode #"H4sIAK8Lt1UAA22Q3Q3AIAiE352CBcwtRHLpHg7f8lubahRUDuVD5DjItrH9REgOEWgskfVMDeca1GWcSmN2WFBtlUTdzdmSOT0BpEpGnjxUAf2RmvPq1OyKGF6N5V1nvgYcWjeod/Hj8JotBRtH0qM48OeoWrBxJH23KL/dOMh4IDXe8MUbT1AqtKkBAAA="))o)(list-ref(string-split(get-output-string o)"a")(modulo n 2)))

Juste pour le plaisir.

(require file/gunzip net/base64)
(define (f n)
  (define o (open-output-bytes))
  (gunzip-through-ports
   (open-input-bytes
    (base64-decode #"H4sIAK8Lt1UAA22Q3Q3AIAiE352CBcwtRHLpHg7f8lubahRUDuVD5DjItrH9REgOEWgskfVMDeca1GWcSmN2WFBtlUTdzdmSOT0BpEpGnjxUAf2RmvPq1OyKGF6N5V1nvgYcWjeod/Hj8JotBRtH0qM48OeoWrBxJH23KL/dOMh4IDXe8MUbT1AqtKkBAAA="))
   o)
  (list-ref (string-split (get-output-string o) "a") (modulo n 2)))

NB: il se peut que vous ayez besoin de la #lang racketligne DrRacket.

05AB1E , 179 177 176 octets

"
 -/\_|"•ÿ%Ò´Åçδ’Üå·Äm…½µƵδø5)ǝ®∊∊Ý®þCĀ₆áÝoþ²ši¤Æ%ßû¤%¦Ï≠θĀ5¾₃ʒŸQ>Šn°η8±8d¸6':…é’b…÷‡ö©«&‡huѦ%λÁZÊJÌ₅ú∞°»ó₄ι«ÓW´×ƒ×ùqiò2D1āwθóÆ˲’
Tι#и∊²ý‚KʒFæΩZºÿÏ";ηiʒæøвøïž‚è°ć½∊•7вèJ2äIè

Essayez-le en ligne.

Explication:

•ÿ%Ò´Åçδ’Üå·Äm…½µƵδø5)ǝ®∊∊Ý®þCĀ₆áÝoþ²ši¤Æ%ßû¤%¦Ï≠θĀ5¾₃ʒŸQ>Šn°η8±8d¸6':…é’b…÷‡ö©«&‡huѦ%λÁZÊJÌ₅ú∞°»ó₄ι«ÓW´×ƒ×ùqiò2D1āwθóÆ˲’
Tι#и∊²ý‚KʒFæΩZºÿÏ";ηiʒæøвøïž‚è°ć½∊•

est le nombre compressé :

669530978249988431396781816197276307266403407188962925862194299697873953319419752813246251351417090709766331736351616127424760949905163941809417778114834562736028512279028673309866195447599979612590918985644583407413903825059942009898007791080822453262749380245316127735585410697701790387188175543639634091138422651942833048832372950797322005040161476426127678479662921265139425

Essayez-le en ligne.

7в la convertit en Base-7 sous forme de liste, nous obtenons donc la liste des chiffres:

[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,1,1,5,5,1,1,1,5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,5,5,5,0,1,1,3,4,1,1,3,4,1,1,1,1,6,1,1,6,4,1,1,6,1,1,6,1,1,1,1,1,3,1,1,1,1,6,1,1,6,1,1,1,1,1,3,4,1,1,1,1,6,1,1,1,1,1,6,0,1,3,1,1,4,3,1,1,4,1,1,1,6,1,1,6,1,4,1,6,1,1,6,2,2,1,1,6,1,1,1,1,1,6,2,2,4,1,1,1,1,3,5,5,4,1,1,1,6,2,2,1,1,1,6,0,3,1,1,1,1,1,1,1,1,4,1,1,6,1,1,6,1,1,4,6,1,1,6,5,5,1,1,1,4,5,5,1,1,6,1,1,1,4,1,1,3,1,1,1,1,4,1,1,6,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,1,1,5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,4,1,1,1,1,1,1,1,1,3,1,1,6,1,1,6,1,1,3,6,1,1,6,1,1,1,1,1,3,1,1,1,1,6,1,1,1,3,1,1,4,1,5,5,1,3,1,1,6,1,1,1,1,1,6,0,1,4,1,1,3,4,1,1,3,1,1,1,6,1,1,6,1,3,1,6,1,1,6,2,2,1,1,6,1,1,1,1,1,6,2,2,3,1,1,1,1,4,1,1,3,1,1,1,6,2,2,1,1,1,6,0,1,1,4,3,1,1,4,3,1,1,1,1,6,1,1,6,3,1,1,6,1,1,6,5,5,1,1,1,4,5,5,1,1,6,5,5,6,1,1,1,1,1,4,3,1,1,1,1,6,5,5,1,1,5,6,5]

Essayez-le en ligne.

èindexe chaque chiffre de la chaîne "\n-/\_|", Jpuis joint la liste complète, ce qui nous donne ce qui suit:

                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |                       __    __                        
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

Essayez-le en ligne.

2ädivise la chaîne en deux parties.
Ièprend l’entrée et l’indexe (avec bouclage automatique) pour obtenir l’une des deux parties, qui est alors sortie de manière implicite.

Un gros merci au compresseur ASCII de @MagicOctopusUrn qui a été utilisé pour générer le nombre compressé et la translittération en Base-7. Essayez-le en ligne. (Après quoi la translittération a été jouée en inversant la chaîne et le numéro sur la pile, en utilisant вau lieu de Bpour en faire une liste de chiffres et en indexant la chaîne avec è.

C, 251 octets

k(w){char*f="_-/\\|]^^^\0<&*&)&3&(&&WX&J&*&\0t_&/&3&\0`);35)I5M\0a).@7).8-;./.-\0j()(0(1+4()(*+4+4()(04+",*o=f+4,m[229]="",i=7,c=10,p;for(memset(m,32,228);i;c=*f++^(w%2&i--/2==2)*115)for(p=0;*++o;m[(w%2?4-i/6-p/57:p/57)*57+p%57]=c)p+=*o-37;printf(m);}

C'est une fonction kqui reçoit un paramètre et imprime le message stdout.

Une version plus lisible:

k(w)
{
    char*f="\n_-/\\|", // characters to fill in
        *o= " "// for each character, the list of positions to put it in, difference-encoded
        "]%%^^^\0"                  // for '\n' (newline)
        "<&*&)&3&(&&WX&J&*&\0"      // for '_' (underscore)
        "t_&/&3&\0"                 // for '-' (minus)
        "`);35)I5M\0"               // for '/' or '\' (slashes)
        "a).@7).8-;./.-\0"          // for '\' or '/' (slashes)
        "j()(0(1+4()(*+4+4()(04+",  // for '|' (vertical bar)
        m[229]="",  // message to generate
        i, // index of character, running 7...1
        c, // current character to fill in
        p, // where to place the character
        y; // y-coordinate of the character

    memset(m,32,228); // fill the message with spaces
    for(i=7;--i;)
    {
        c=*f++;
        c^=~w%2|i/2^1?0:115; // flip the direction of slashes, if needed
        for(p=0;*++o;)
        {
            p+=*o-37; // jump to next position
            y=p/57; // extract the y-coordinate
            y=w%2?4-i/5-y:y; // flip the y-coordinate, if needed
            m[y*57+p%57]=c; // place the character
        }
    }
    printf(m); // print the message
}

Tout d'abord, il prépare un message vide (rempli d'espaces). Pour chaque personnage (par exemple |ou- ), il a une liste de positions dans lesquelles placer ce caractère.

Pour chaque position, si la version à l'envers doit être imprimée, la position est inversée. C'est-à-dire que sa coordonnée verticale yest remplacée par 4-you 3-y(selon que le caractère est un trait de soulignement). En outre, les directions des barres obliques sont inversées - ceci est effectué par un XORavec 115.

Cette structure de contrôle est également utilisée pour placer les caractères de nouvelle ligne - il semble plus efficace d'ajouter 4 coordonnées de plus à la liste que d'écrire une boucle explicite.

Il y a quelques problèmes mineurs avec ce système. Tout d’abord, la dernière lettre T est un peu différente dans la version retournée:

___ 
 |    |
 |    |
 |   _|_

Pour le sortir correctement, le code doit placer les |caractères après les _caractères.

De plus, afin de m'assurer que la chaîne de contrôle ne contient que des caractères ASCII, je l'ai codée:

• Il enregistre les différences entre les positions au lieu des positions elles-mêmes - cela réduit la plage
• Les numéros de la chaîne se sont 37ajoutés pour les déplacer dans la plage ASCII 32 ... 127. Je pourrais ajouter un nombre plus petit, mais 37évite les caractères comme "et \, qui doivent être échappés dans les littéraux de chaîne.
• Deux des nombres étaient supérieurs à 127 - par exemple, le premier -caractère apparaît à la position 137. Pour expliquer cela, j'ai ajouté un -caractère artificiel à une autre position (79), qui est ensuite écrasée - le caractère |apparaît également à la position 79.

Une autre chose amusante était que je ne pouvais pas utiliser la putssortie de la chaîne - cela produirait un retour à la ligne supplémentaire. Alors j'ai utiliséprintf place.

De plus, le nombre 57apparaît 4 fois dans le code golfé - l'expression apparemment longue (w%2?4-i/6-p/57:p/57)*57+p%57permet d'éliminer la variable y, ce qui raccourcit le code.

Perl, 292 259 246 octets

$_="Svv __SS__S nnSv nnSnnn
i kjSkj hw|j h|wS /SwrhSi pq hwS |
 mSlmSlS |S| l |S|--wS |--lSSmnnlS |--S |
k ihSih jw|h j|S|__S g__S|oosjSk ih jS|ooSo|o";s/v/SSSSS/g;s/w/S|S/g;s/S/  /g;<>&1?y"g-s"\\/\\  /\\ ___ |":y"g-s"\\  \\/\\/_ /\\| ";print $_

Il tire parti du fait que les deux chaînes sont généralement similaires (par exemple, l'intégralité d'IE et de C) et fait en sorte que la chaîne ne comporte pas de caractères affichés différemment selon la version affichée. Par exemple, m signifie "une barre oblique pour la chaîne de droite, une barre oblique dans la chaîne à l'envers". Il effectue une substitution de translittération pour afficher le caractère correct. Les espaces sont également codés en longueur d'exécution en utilisant des substitutions de chaînes.

multiligne:

$_="Svv __SS__S nnSv nnSnnn
i kjSkj hS|S|j h|S|SS /SS|SrhSi pq hS|SS |
 mSlmSlS |S| l |S|--S|SS |--lSSmnnlS |--S |
k ihSih jS|S|h j|S|__S g__S|oosjSk ih jS|ooSo|o";
s/v/SSSSS/g;
s/w/S|S/g;
s/S/  /g;
<>&1?
    y"g-s"\\/\\  /\\ ___ |"
:
    y"g-s"\\  \\/\\/_ /\\| ";
print $_

Idée:

Étant donné que la sortie ne contient que 22 colonnes uniques, il devrait être possible de la stocker sous la forme 22 * ​​4 = 88 caractères avec une plage de 0 à 17 (tous les caractères "à double sens" possibles), ainsi qu'une recherche de 56 caractères. table avec une entrée dans la plage 0-21 par colonne. En théorie, cela pourrait être codé avec moins de 100 octets, mais il est difficile d'en faire un gain net à cause du code plus compliqué pour le décoder.

CJAM, 206

Les deux images ASCII sont codées en base 216, un octet = 3 caractères.

" _\/|-":A;S7*"!D!D"+:B;qi2%{B"h  °°¤8 2 °2,J° °"",4# °³8=Ô° Ó\"# Ó °""\"z °Â89D-D·° z ·!¶"}{B"'    '!J"+"#h °¼88 2 °°  ° °""2/\" °²8=Ô° Óh#L Ó °""  h°°9D-D°,2 h° °"}?]{{i32-__36/A=@6/6%A=@6%A=}/N}/

Testez le ici

Powershell, 275 253 248 octets

param($n)$d='8 \83484/7/484302 92984308 92918--118--128||6//0\16116129558| \/ |8 /02083\6/10018/6\302 955776_71 9_7_'
'8\,__,777,/6 /,\6/6\,_8 -- _,88,888,  ,||||||'-split','|%{$d=$d-replace+$i++,$_}
0..3|%{$l=$_;-join$d[(0..55|%{$_*8+$l*2+$n%2})]}

Script de test:

$f = {

param($n)$d='8 \83484/7/484302 92984308 92918--118--128||6//0\16116129558| \/ |8 /02083\6/10018/6\302 955776_71 9_7_'
'8\,__,777,/6 /,\6/6\,_8 -- _,88,888,  ,||||||'-split','|%{$d=$d-replace+$i++,$_}
0..3|%{$l=$_;-join$d[(0..55|%{$_*8+$l*2+$n%2})]}

}

&$f 2
&$f 1

Sortie:

                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

Les idées principales

La méthode de compression est la méthode étendue de CJam par Dennis ♦:

1. Créez une chaîne avant la compression:
   • caractères de la première colonne des deux arts ASCII, puis
   • caractères de la deuxième colonne, puis
   • caractères de la troisième colonne et ainsi de suite ...
2. Compressez à l'aide de 10 remplacements consécutifs (10, car Powershell peut utiliser les chiffres 0..9 comme chaînes, ce qui raccourcit l'algorithme de décompression. Les remplacements trouvés par force brute.)

Le script de compression:

$src =
"                       __    __   __             __  ___", # line1, art1
"                       __    __                         ", # line1, art2
"  /\  /\    |  |\  |  |     /    |  |     /\    |     | ", # line2, art1
"\        /  |  |  /|  |     /    |   /  \ __ /  |     | ", # line2, art2
" /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | ", # line3, art1
" \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | ", # line3, art2
"/        \  |  |  \|  |__   \__  |   \  /    \  |     | ", # line4, art1
"  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_"  # line4, art2

$z=-join(0..$src[0].Length|%{
    $p=$_
    $src|%{$_[$p]}
})
$z

La chaîne de compression avant est:

   \  /     /\    /    \  \    /    \/      /\    /    \  \    /    \/     /  \                   ||||||                  ||||||  \    /    \/     /  \   ||||||          ||||||__  --____  --__                    ||    //  \\__    ____    __                  ||||||_   -- __   -- _  | \/ |   /  \                    \  /     /\  /__  \  \__  /    \/     /  \                   ||||||_   -- __   -- _                _      __ ||||||_      _

SAS, 442 octets

%macro a(b);&b=tranwrd(&b,put(i,1.),repeat('A0'x,i));%mend;%macro b(z);length a b c d$99;if mod(&z,2)then do;a='992__3__';b='\7/1|1|1/|1|4/3|2/1\0__0/1|4|';c='0\1/\1/2|1|0/0|1|--1|4|--/3\1/2|--2|';d='1\/1\/3|1|/1|1|__2\__1|__|4\/3|__1_|_';end;else do;a='992__3__2__65__1___';b='1/\1/\3|1|\1|1|4/3|1|4/\3|4|';c='0/1\/1\2|1|0\0|1|--1|4|--\3/__\2|--2|';d='/7\1|1|1\|1|__2\__1|2\1/3\1|4|';end;do i=0to 9;%a(a)%a(b)%a(c)%a(d)end;put a/b/c/d;%mend;`

Non-golfé:

%macro a(b);
  &b=tranwrd(&b,put(i,1.),repeat('A0'x,i));
%mend;

%macro b(z);
length a b c d$99;
if mod(&z,2)then do;
  a='992__3__';
  b='\7/1|1|1/|1|4/3|2/1\0__0/1|4|';
  c='0\1/\1/2|1|0/0|1|--1|4|--/3\1/2|--2|';
  d='1\/1\/3|1|/1|1|__2\__1|__|4\/3|__1_|_';
end;
else do;
  a='992__3__2__65__1___';
  b='1/\1/\3|1|\1|1|4/3|1|4/\3|4|';
  c='0/1\/1\2|1|0\0|1|--1|4|--\3/__\2|--2|';
  d='/7\1|1|1\|1|__2\__1|2\1/3\1|4|';
end;
do i=0to 9;
  %a(a)
  %a(b)
  %a(c)
  %a(d)
end;
put a/b/c/d;
%mend;

Tests:

data a;
  %b(1)
  %b(2)
  %b(0)
  %b(35)
run;
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

Pourrait peut-être économiser un peu de code en les plaçant dans des blocs d'entrée, mais cela ajoute la restriction que la macro ne peut être qu'une fois par date, ce qui, à mon avis, enfreint l'esprit de l'écrire en tant que macro. (Et je soupçonne que l'ajout d'une invite pour obtenir une entrée dans le datastep ajoute plus de caractères).

bash, 247 octets

(($1%2)) && c=tail || c=head
base64 -d <<<H4sIAF/3uFUCA31Q2w3AIAj8ZwoWMLcQyS3i8JWXtWlTI6BwPA7Vz0Nunc9HhKSowlJU57qWJjBoZ/4a41o8aC4NsTBjbMgYkQDStCIrDz3AbmRuYjpzPTOGG5P9/gmKtQddFy8eMbOn4Khb7NE88ObRs+DgUez3iqrtwYPMAoWJhU/KBeJFPOCqAQAA | zcat | $c -n4

Les chaînes sont concaténées et gzipées.

PHP, 225 octets

Laide, solution de force brute.

echo str_split(gzinflate(base64_decode('dZDdDcAgCITfnYIFzC1Ecos4fOW3Nm2NgsohfIp8DrJtbB8RkkMEGktk7anhXIO6jFNpzA4Lqq2SqLs5WzKnJ4BUycjOQzXQhdScd6dmV8Rwa7rqP9/QukE9ixeGt2wpODASHoWBN0a1ggMj4fuHsuyBQcYDqfH/XrwA')),224)[$argv[1]%2];

J'ai compressé puis base64 encodé les chaînes concaténées à afficher. Le code décode, décompresse et scinde en 224 caractères. La première chaîne contient 224 caractères sans nouvelle ligne, la seconde 201 (pas de nouvelle ligne après celle-ci). La parité de l'argument de ligne de commande ( $argv[1]%2) est utilisée comme index dans le tableau généré par str_split().

Haskell, 138 octets

m x=do
 h<-readFile"a"
 return$take 225.drop(225*mod x 2)<$>find((==h).hash.pack)(replicateM 425"/\\|_- ")

C'est un peu un bidouillage. J'applique bruyamment le hash SHA256 de la concatination des deux textes minecraft, puis je les sépare et je choisis le texte approprié en fonction du paramètre x. Ceci est bien sûr très peu pratique et ne peut pas être calculé en temps réel, et il peut même y avoir des collisions en cours de route pour tout ce que je sais.

Étant donné que Haskell ne peut pas avoir la représentation ASCII de ce hachage dans une chaîne, je la lis à partir d'un fichier appelé "a", et a donc ajouté 32 octets à ma partition.

• readFile and pack provient de Data.ByteString.Char8
• le hachage provient de Crypto.Hash.SHA256

Explication:

replicateM 425"/\\|_- "

Crée une liste de chaque combinaison des lettres "/ \ | _-" sur 425 lettres (la longueur des deux textes minecraft combinés)

find((==h).hash.pack)

Choisissez le premier qui correspond au hachage

take 225.drop(225*mod x 2)

Le premier texte compte 225 lettres, l’autre 200.

Javascript (ES6), 403 296 octets

(Déplacé de ma réponse précédente ) Essayer une nouvelle méthode:

n=>`55555559Å9Å${n%2?`55555558556776}}5Y75Y¥Æ75786¡YAA[7ćA5Fï5¡YFéA8Y§5}\x83AEÅKÅ\x99}5§5\x999\x95`:`Q5555Q9Ý>6¡77¡}}5Y7756¡75768Y¡AA£7ćA5Fû5u¡FéAY55¡}}­EÅKÅ}G;5¡}5}`}`.replace(r=/./g,x=>(163+x.charCodeAt()).toString(6).slice(1)).replace(r,x=>' /|\\_-'[x]).match(/.{56}/g).join`
`

Notez qu'il y a quelques caractères non imprimables; ceux-ci ont été remplacés par par exemple\x83 .

Le codage lui-même est environ 40 octets plus court que l’autre, mais le processus de décodage est plus élaboré. J'ai utilisé le système base 216 que d'autres ont utilisé pour coder le texte. Pour référence, voici le code que j'ai utilisé:

// normal MINECRAFT
a='00000000000000000000000440000440004400000000000004400444'+
  '00130013000020023002002000001000020020000013000020000020'+
  '01003100300020020302002550020000025530000144300025500020'+
  '100000000300200200320024400034400200030010000300200000200';

// upside-down MINECRAFT
// un-comment this one to run it
/*
a='00000000000000000000000440000440000000000000000000000000'+
  '30000000010020020012002000001000020001003044010020000020'+
  '03001300100020020102002550020000025510000300100025500020'+
  '003100310000200210020024400034400244200000310000244004240';
*/

console.log(a.replace(/.../g,x=>String.fromCharCode(parseInt(b[i],6)+53)));

Cela prend essentiellement le texte ASCII (pré-converti en base 6) et le triple sur lui-même, en le changeant en base 216. 53 est ensuite ajouté pour supprimer la plupart des caractères non imprimables.

Suggestions bienvenues!

Voici le code original de 403 octets:

a=n=>{y=[' ','/','|','\\','_','-'],x=`55555559Å9Å${n%2?`55555555¡55Y}}eA5;5};GÝY}5}¡k;77;} 757Ĉ5G;7ć75§H5AB77Ý8ÝEÑ5H5EÅÕ`:`Q5555Q9Ý6¡k5}\u008FAA5;5}}5k5}5}Y§G77G} 757Ċ5?×7ć7;55GAAI7Ý8ÝA865GA5A`}`;b=x.split('').map(x=>x.charCodeAt(0)-53);for(c=[],i=b.length;i--;){c[i]=b[i].toString(6);while(c[i].length<3)c[i]='0'+c[i]}d=c.join('').replace(/\d/g,x=>y[x]).split('');d[56]=d[112]=d[168]=`
`;return d.join('')};

En utilisant une forboucle, unwhile boucle, quatre variables qui ont été utilisées une seule fois et une tonne d'algorithmes longs pour des choses simples. Boy, ai-je amélioré ...

Python, 312 octets

def y(b):
 x=int(['4vwhclv10tuk4z18gf73aimn6zvwkrhxekphfn1lxocj9ezchd1cd1cv97p3f6k12s8hcjznnm5iq3om4vgxvugp3makgu4n3f6qxvdrtl4c0lva12hwt','8uzwdylhtrf6oqnwnck8pfxu25m5844tuo2700v3zoeuvossx1b47rnwyrmqodau3feu3spi9jydhyxvntv48vojx9iq9af78wufzn1'][b%2],36);x<<=69;s="";t=" /\\-|_\n"
 while x:s+=t[x&7];x>>=3
 print s

La fonction imprime la sortie avec un int

C, 321 octets

Encodé la répétition et l'index de caractères dans une chaîne.

main(n,v,p,c)char**v,*p,*c;{c=" _/\\|-\n";for(p=atoi(v[1])%2?"8@8iXivs8rhththrthtPrXt`rhspiprhtPtvpshrshr`thtprpthtmhtPtmrXshr`tm`tvhsrhsrXthtrhthti`sihtitPsrXtihqtq":"8@8iXi`i8PihavhrshrsXthtshthtPrXthtPrsXtPtvprhsrhs`thtpspthtmhtPtmsXris`tm`tvr8shththsthti`siht`shrXshtPtw";*p;p++)for(n=*p/8^15;n--;)putchar(c[*p&7]);}

Python 3, 486 533 612

r=str.replace;m,p=r(r(r('''YYYYY   __YA AYY   A___
  /\  /\YX\  X Y/YX Y/\Y| Y|
 /  \/  \   X \ X--  | Y|--\Y/__\   |--   |
/YY\  X  \XA \A|   \  /Y\  | Y| ''','X','|  |'),'Y','    '),'A','__  '),print;
if int(input())%2==0:p(m)
else:
 q,i,u=m.split('\n')[::-1],0,[[23,24,29,30],[42,43],[],[23,24,29,30,34,35,53,49,50,55]];q.insert(0,q.pop())
 while i<len(q):
  x=list(r(q[i],'_',' '))+[' ']
  for a in u[i]:x[a]='_'
  p(r(r(r(r(''.join(x),'___',''),"\\",'t'),'/',"\\"),'t','/'))
  i+=1

PHP , 263 octets

<?=strtr('3333 20220'.['2 0332 020_
2/\2/\211\113/2113/\212 1
 /2\/2\ 11 \ |1412 14\22/0\ 14 1
/32 \112\|102 \012 \2/22\12 1',
'
\32 /112/|13/212 /2\ 0 /12 1
 \2/\2/ 11 / |1412 14/22\2/ 14 1
2\/2\/211/1102 \010|3\/2102_|_'][$argn&1],[__,"  |","  ","     ","--"]);

Essayez-le en ligne!

Ruby, 290 octets

$><<(gets.to_i%2<1?"xCeCdCnCcC_
c/Bc/Be|ABAAf/e|Af/Be|f|
b/cB/cBd|AbBb|A--Af|--Be/CBd|--d|
/iBAAcB|ACdBCAdBc/eBAf|":"xCeC
Bi/AAc/|Af/e|d/cBbCb/Af|
bBc/Bc/d|Ab/b|A--Af|--/eBc/d|--d|
cB/cB/e|A/AACdBCAC|fB/e|Cc_|_").gsub(?C,'__').tr(?B,?\\).gsub(?A,'c|').gsub(/[a-z]/){|e|' '*(e.ord-97)}

Probablement une entrée faible et améliorable. Fondamentalement, une compression très simple (faite à la main) dans laquelle les lettres minuscules signifient que de nombreux espaces (en fait, ord (ch) - espaces «A») et des lettres majuscules ne sont que quelques termes courants permettant d’économiser quelques octets.

SOGL V0.12 , 72 71 octets

═j;ΗD^⌡⁾yō⁶⅜┐≡¼τ~≡š┘,┼◄‚4øDqψ∫‛²′Ζdκ↓±ģ░○∙ΘΝ◄ōΞ06║⁶╗i-η}┌^JY³‘''n.2%?№↕

Essayez-le ici!

La mise en miroir verticale des LFOS fonctionnait parfaitement pour cela.

Toile , 70 octets

Ｃ＜aT［≤＾５ｔ‽◂6Ｚｒ!ｖ↓［ｕ0F∙ＯＦ－╫＃ｔ┬ａ*７ＺfK1!&)y＠½（＋M⇵ＰV-¼G:Ｕju╋╷(╫:N‟‾)ｎ⁸２％？↕

Essayez-le ici!