Sortir le texte “Code Bowling”

54

Code-Bowling

Brunswick Bowling vous a embauché pour créer un programme simple permettant d'afficher le texte Code Bowlingsur ses moniteurs. Cette entreprise vaut un joli penny et vous sentez que vous pouvez les arnaquer pour un peu d'argent.

La description de poste indique clairement qu'ils paient sur une base de pointage et vous êtes persuadé que vous pouvez manipuler leur système de pointage à votre avantage et obtenir le plus gros chèque de paie possible de ces types. Pour ce faire, vous devrez insérer le plus de code possible dans votre programme / fonction, même si son système de notation est conçu pour vous empêcher de le faire.

Sortez vos tirelires, codons!


Défi

Le défi consiste simplement à sortir le texte Code Bowling, exactement comme il est écrit ici, avec le score le plus élevé possible. (Voir la section: Système de notation ci-dessous)

Les nouvelles lignes (début et fin de ligne) sont acceptables.

Votre code peut être un programme entier ou juste une fonction exécutable.


Règles

Obligatoire: Ce défi utilise Code-Bowling: Common Rules, Revision 1.0.0 ; Voir Meta pour plus de détails.

  1. Caractère: Ratio d'octets
    Dans Code-Bowling, un nombre de caractères est préférable à un nombre d'octets. La raison en est évidente: les caractères unicode multi-octets (par exemple) peuvent être utilisés à la place des caractères unicode à un octet pour donner un nombre d'octets plus élevé et permettre au bowling de savoir qui renomme le plus de variables avec des caractères unicode à octets élevés que qui crée le plus stratégiquement un code complexe significatif.

  2. Noms de variable / fonction / objet
    Tous les noms de variable (ou pointeurs d'objet, noms de fonction, etc.) doivent comporter 1 caractère. Le seul moment acceptable pour utiliser des noms de variables à 2 caractères est après utilisation de toutes les variables possibles à 1 caractère. Le seul moment acceptable pour utiliser des noms de variables à 3 caractères est une fois que toutes les variables à 2 caractères possibles ont été utilisées. Etc.

  3. Code non utilisé
    Tout le code doit être utilisé. Cela signifie que le programme ne doit pas toujours terminer correctement la tâche si un caractère individuel (ou un ou plusieurs jeux de caractères) est / sont supprimés. Bien entendu, un sous-ensemble du programme ne devrait pas être en mesure de mener à bien la tâche sans le reste du programme.

  4. Commentaires Les
    commentaires ne sont pas autorisés pour le décompte des caractères, à moins que ceux-ci ne soient utilisés par votre programme / fonction.


Système de notation:

  Défi Pangram:

Un pangramme est une phrase qui utilise chaque lettre au moins une fois. (Le renard brun rapide saute par-dessus le chien paresseux).

Ce type de défi a un système de score conçu dans lequel un pangram parfait atteindrait le score maximum théorique (bien que vous ne soyez pas obligé d'utiliser chaque personnage au moins une fois.) De plus, l'utilisation de tout caractère plus d'une fois entraînera une pénalité. Ce défi ne concerne pas uniquement les caractères alphabétiques.

  Mesure métrique:

  1. Chaque personnage utilisé augmente votre score de 1.
  2. L'utilisation répétée de tout caractère alphanumérique (az, AZ, 0-9) entraînera une déduction de 3 points par répétition (la première utilisation ne donne pas lieu à une déduction).
  3. L'utilisation répétée de la ponctuation de base ([!?.-,":';])- y compris les crochets - donnera lieu à une déduction de 2 points par répétition.
  4. L'utilisation répétée d'autres caractères ASCII {`~@#$%^&*_+=|\/><}- y compris les accolades - entraînera une déduction de 4 points par répétition.
  5. L'utilisation d'espaces, de tabulations et de nouvelles lignes entraîne une déduction de 1 point par utilisation. C'est-à-dire qu'ils ne comptent pas dans le total des personnages.
  6. Les caractères non mentionnés ci-dessus (caractères exotiques) entraînent une déduction de 1 point par utilisation. C'est-à-dire qu'ils ne comptent pas dans le total des personnages.

  Outil de notation:

Un widget de scoring automatisé a été créé et peut être trouvé ici .


Ceci est une variante . Le programme avec le score le plus élevé gagne! (Puisqu'il y a un score maximum de 94, celui qui l'atteint le premier (s'il peut être atteint) sera marqué comme la réponse acceptée, même si les autres sont libres de continuer à répondre pour le plaisir)

Albert Renshaw
la source
37
J'ai réussi à obtenir un score de -75k. Si c'était le score le plus bas, je le ferais étonnamment.
ATaco
1
@carusocomputing Essayez les têtes de colonne. Le score sera probablement toujours terrible. En outre, vous ne pouvez pas vraiment utiliser BF, car les non-commandes sont des commentaires et peuvent être supprimées.
mbomb007
1
La délimitation serait bénéfique car elle ne tient pas compte des caractères que vous utilisez, mais uniquement de l'ASCII combiné d'un jeu de caractères
MildlyMilquetoast
2
Le code le plus court serait un bon jeu décisif pour ce défi!
Stewie Griffin
2
Peut-être que quelqu'un peut résoudre ce problème en accordant des primes aux 94 autres
joueurs

Réponses:

36

Glypho , 94

Le fichier source est codé en CP437 .

␀␀!"☺☺#$☻♥♥☻♦♣♦♣%♠♠&•◘•◘'○○(◙♂◙♂♀♪♪♀♫☼♫☼►◄◄►↕↕)*‼¶¶‼§§+,▬↨↨▬↑↓↑↓→←→←∟∟-.↔▲▲↔/▼▼▼⌂Ç⌂Çüééüââ01ää23àååàçêçê4ëë5èïèïîî67ìÄÄì8ÅÅ9ÉÉ:;æÆÆæô<=ôöòòöûùûù>ÿÿÿÖÖ?@ÜÜAB¢££¢¥₧¥₧CƒƒDáíáíóóEFúññúѪѪGººHI¿¿J⌐¬⌐¬K½½½¼¼LM¡««¡N»»»░░OP▒▒QR▓││▓┤╡┤╡S╢╢T╖╕╖╕U╣╣V║╗║╗╝╜╜╝W╛╛╛┐X┐┐Y└└└┴┬┴┬├─├─Z┼┼┼╞╞[\╟╟]^╚╔╔╚╩╦╩╦_╠╠`═╬═╬╧╨╨╧╤╥╥╤a╙╙╙╘╘bc╒╒de╓╓fg╫╪╪╫┘┌┌┘█▄█▄▌hi▌▐j▐▐▀αα▀ßΓßΓπΣπΣkσσσµlµµτmnτΦΘΘΦΩδΩδo∞∞∞φpφφεεqr∩≡≡∩±±st≥≤≤≥u⌠⌠⌠⌡⌡vw÷xy÷≈°°≈∙∙z{·|}·√ⁿⁿ√~²²²

Essayez-le en ligne!

Explication

Glypho est très utile pour des défis comme celui-ci, car il ne se soucie pas du tout des personnages utilisés. Au lieu de cela, il regarde chaque bloc de 4 caractères et la commande utilisée est déterminée par le motif que ces quatre caractères créent:

0000 n
0001 i
0010 >
0011 \
0012 1
0100 <
0101 d
0102 [
0110 +
0111 o
0112 *
0120 -
0121 ]
0122 !
0123 e

Cela signifie que nous pouvons simplement résoudre le problème et insérer ensuite des caractères uniques dans chaque quartet avec les caractères imprimables et tous les caractères répétés avec certains des caractères "exotiques", qui sont ignorés par la notation. Glypho est suffisamment détaillé pour qu'une solution manuscrite normale contienne suffisamment de caractères uniques pour contenir les 94 caractères imprimables qu'il contient. En fait, j’ai fini par jouer jusqu’à atteindre exactement 94, juste pour pouvoir utiliser des caractères exotiques uniques pour ceux qui se répètent (espérons-le, pour rendre plus difficile la réduction du programme).

La forme abrégée du programme ci-dessus est la suivante:

11+d*d*d+d+1+1+dd1+o
d+11+d*d1+*1+-+do
11+d*d1+d**do
1+o
11+d*d*d+o
<o
ddo
11+d*d++o
111++d-<+ddo
<-+do
<1+1+o
1-+1-+o

Où chaque ligne imprime un des caractères.

J'ai utilisé ce script Retina pour le convertir en Glypho 0123. Ensuite, je viens de remplir les caractères à la place des chiffres.

En théorie, il serait peut-être possible de réduire cela davantage, si quelqu'un réussissait à jouer avec le programme de raccourci, puis à recombiner les personnages de manière à ce que les bons modèles apparaissent, mais je ne suis pas sûr de savoir comment prouver ou d'infirmer que c'est possible. . Si quelqu'un parvient à former une solution valide à partir d'un sous-ensemble de mon programme, merci de me le faire savoir afin que je puisse supprimer la réponse jusqu'à ce qu'elle soit corrigée. Jusque-là, je dois supposer que cela est valide.

Martin Ender
la source
Super truc! J'accepte cela pour l'instant car 94c'est le score maximum. Tout le monde est libre de continuer à soumettre des réponses pour le plaisir .
Albert Renshaw
Excellent travail, Martin! Si seulement j'avais été quelques heures plus vite ...: D
mbomb007
@ AlbertRenshaw Peut-être que le jeu décisif devrait être le nombre d'octets? : D
mbomb007
49

Python 3, 82 87 88

Merci à @JonathanAllan pour +1 point

print("g!#$%&'*n+,./012i34579;<l=>?@ADEwFGHIJKLoMNOPQRSBTUVWXYZ ^_`abchejkmqsuvdyz{|}~ \x6f       C"[::-8])

Essayez-le en ligne!

Rien de spécial, juste trancher et sauter des caractères. La chaîne est inversée, vous ne pouvez donc pas supprimer les caractères et imprimer la chaîne d'origine.

TidB
la source
2
Woah. qui est bon.
Matthew Roh
1
Très bonne réponse, mais pourquoi l'ordre mélangé? Ne serait-il pas plus simple (pour vous) de l’avoir dans l’ordre dans lequel ils sont naturellement ( HIJKLMN...) sauf pour chaque 8ème caractère bien sûr?
Stewie Griffin
@StewieGriffin Cela aurait été plus facile, oui. Je viens de parcourir des ensembles et je ne me souciais pas vraiment du tri.
TidB
Y a-t-il une raison pour laquelle vous avez rempli les autres personnages dans un ordre aussi étrange?
mbomb007
2
Vous êtes comme l'inspiration TidB! Ma nouvelle question :)
Stewie Griffin Le
17

> <> , 92 94

Oui, je l'ai fait!

est le caractère exotique\x11 avec la valeur décimale 17. Le programme se ferme avec une erreur après l’impression du résultat (c’est un dépassement de pile). Je devais gérer les miroirs et les commandes directionnelles que j’utilisais avec précaution, car je ne peux les utiliser qu’une seule fois.

   >"vCoUV␑3`h]Z_X
       /a[f+
#$%&'r(!
.0456~8?
:;<=@9l)
ABDEFcGe
HIJKL*
MNOPQ7
RSTWYd
bgijk1
mnqst-
uwxyz2
{|}  ,
     \p^

Essayez-le en ligne

Le programme de base:

   >"vCoUV␑3`h]Z_X
       /a[f+
     r !
     ~ ?
     9 )
     c e
     *
     7
     d
     1
     -
     2
     ,
     \p^

Explication:

Poussez la chaîne vCoUV␑3`h]Z_X >(wraps d'exécution). Déplacer vers le bas. Inversez la pile et retirez le v.

Poussez 9et c(12). Multipliez pour obtenir 108( l). Poussez 7. Appuyez sur d(13), soustrayez 1, divisez par 2pour obtenir 6. Mettez là (x, y) de (13,6), qui est en dessous de la e. J'aurais pu le faire de manière plus courte, mais ceci est allongé, ce qui me permet de mettre plus de caractères ASCII.

Montez dans une boucle. Poussez la longueur de la pile avec l. Si le nombre de caractères est supérieur à 14, créez une nouvelle pile avec les 10 meilleurs éléments, ajoutez 15, puis reflétez l'exécution, puis montez et sortez. Ceci est utilisé pour empêcher les espaces en trop et >d'être imprimés à la fin, ainsi que pour transformer la chaîne d'aspect aléatoire en ce qui doit être imprimé. Continuer en boucle.

Si l'une des lignes est plus courte (en supprimant un caractère), le programme ne fonctionnera plus, soit parce que les parties verticales du programme ne s'alignent plus, soit parce que la chaîne à imprimer n'est plus correcte. Tenter de supprimer un caractère situé devant chaque ligne modifiera la profondeur de la pile et l'emplacement de la l, ce qui causera également des problèmes.

Poisson

mbomb007
la source
94! Agréable! Haha
Albert Renshaw
2
Quand j'ai commencé à faire la première version, je savais que je pouvais en réutiliser. Ensuite, je me suis débarrassé du "et lavec pas mal de travail. Une fois que j’ai atteint 92 ans, j’étais persuadé qu’il devait y avoir un moyen de supprimer le dernier o. Il a cependant fallu un peu d'effort. Vous pouvez dire par l'historique de révision.
mbomb007
16

Octave, 20 21 22 25 27 33

Le mieux que j'ai réussi jusqu'ici est

g=@()disp(horzcat([67 9583 -412],'e B',"nvkhmf"+!0));

Cela crée une fonction anonyme fqui ne prend aucune entrée. Vous pouvez l'appeler f(). Je dirais que le point-virgule à la fin est nécessaire, afin d'éviter l'impression du corps de la fonction.

Il est possible que cela puisse être amélioré en combinant evalet printf, mais j'ai essayé et échoué encore et encore.

Cela utilise tous les chiffres une fois, en expliquant le fait qu'Octave effectue une mod(x,256)opération lors de la conversion implicite de nombres en caractères. Cela signifie que nous pouvons utiliser des nombres négatifs, ainsi que des nombres situés en dehors de la 32-126plage normale . Les numéros suivants tout résultat dans la lettre ilorsqu'il est converti en caractères: ... -2455 -2199 -1943 ... 105 361 .... Au lieu d'utiliser 'owling'finalement, nous utilisons "nvkhmf"et ajoutons 1. Cela crée un vecteur d'entiers qui sont implicitement convertis en caractères. Au lieu de 1, nous utilisons !0(ou not(false). En outre, nous utilisons "au lieu de 'éviter deux points de pénalité.

Nous devons trouver l'ensemble des nombres qui donne le score le plus bas. La chaîne Code Bowlingrésulte dans la matrice suivante, lorsque nous soustrayons et ajoutons -10 * 256 - 10 * 256.

  -2493  -2449  -2460  -2459  -2528  -2494  -2449  -2441  -2452  -2455  -2450  -2457
  -2237  -2193  -2204  -2203  -2272  -2238  -2193  -2185  -2196  -2199  -2194  -2201
  -1981  -1937  -1948  -1947  -2016  -1982  -1937  -1929  -1940  -1943  -1938  -1945
  -1725  -1681  -1692  -1691  -1760  -1726  -1681  -1673  -1684  -1687  -1682  -1689
  -1469  -1425  -1436  -1435  -1504  -1470  -1425  -1417  -1428  -1431  -1426  -1433
  -1213  -1169  -1180  -1179  -1248  -1214  -1169  -1161  -1172  -1175  -1170  -1177
   -957   -913   -924   -923   -992   -958   -913   -905   -916   -919   -914   -921
   -701   -657   -668   -667   -736   -702   -657   -649   -660   -663   -658   -665
   -445   -401   -412   -411   -480   -446   -401   -393   -404   -407   -402   -409
   -189   -145   -156   -155   -224   -190   -145   -137   -148   -151   -146   -153
     67    111    100    101     32     66    111    119    108    105    110    103
    323    367    356    357    288    322    367    375    364    361    366    359
    579    623    612    613    544    578    623    631    620    617    622    615
    835    879    868    869    800    834    879    887    876    873    878    871
   1091   1135   1124   1125   1056   1090   1135   1143   1132   1129   1134   1127
   1347   1391   1380   1381   1312   1346   1391   1399   1388   1385   1390   1383
   1603   1647   1636   1637   1568   1602   1647   1655   1644   1641   1646   1639
   1859   1903   1892   1893   1824   1858   1903   1911   1900   1897   1902   1895
   2115   2159   2148   2149   2080   2114   2159   2167   2156   2153   2158   2151
   2371   2415   2404   2405   2336   2370   2415   2423   2412   2409   2414   2407
   2627   2671   2660   2661   2592   2626   2671   2679   2668   2665   2670   2663

Donc, les ['',2627 2415 2148 1893 -2528 66 -1169 -1161 2668 105 -146 103]résultats dans ans = Code Bowling. Le défi consiste alors à trouver l'ensemble des chiffres et des caractères qui réduisent le plus le score. Bien sûr, utiliser tous les chiffres est bon, mais les doublons sont mauvais. Comme tous les chiffres sont utilisés, et non sont utilisés deux fois, il s'agit du meilleur mélange possible. En outre, nous arrivons à utiliser -, résultant en un point.

On pourrait prétendre qu’elle peut être réduite à la ligne inférieure (31 points), mais alors ce ne serait plus une "fonction exécutable" et aurait donc une fonctionnalité différente.

disp(horzcat([67 9583 -412],'e B',"nvkhmf"+!0))
Stewie Griffin
la source
Avez-vous essayé function q();disp(...)aussi? À part le i(), ils ne se chevauchent pas bien.
Sanchises
@Sanchises je peux vérifier. Mais cotdans horzcatet nfdans la chaîne réduira le score de manière drastique. Ce serait peut-être mieux si je supprime horzcatet crée la chaîne d'une autre manière, mais je ne peux pas non plus l'utiliser +!0. Pour être honnête, je serais surpris que cela augmente le score. Cela ne fait que 7 caractères de plus que la réponse actuelle et j'obtiendrai une pénalité de 7 octets, en plus de celles que j'ai mentionnées.
Stewie Griffin
1
Oui, je ne pouvais pas obtenir un score plus élevé function, mais je me suis dit que vous auriez peut-être déjà essayé et que je perdrais mon temps (au lieu de, vous savez, passer mon temps utilement sur PPCG)
Sanchises
12

QBasic, 34

C'est du code non formaté (oui pour l'insensibilité à la casse). Vous pouvez l'exécuter dans QB64 ou sur archive.org ( sachez toutefois que ce dernier formatera le code au fur et à mesure que vous le tapez). Je pense avoir réussi à respecter toutes les règles.

CLS
PrINT "C
LOcatE 1, 2 : ? CHR$(957-846); "de Bowling

Le CLSest nécessaire: sans cela, l’ Cimpression n’est pas garantie dans le coin supérieur gauche de l’écran, là où il s’alignera ode Bowling. Le LOcatEnécessaire: sans cela, ode Bowlingsera imprimé sur la ligne ci-dessous C. Je ne crois pas qu'il y ait un sous-ensemble du programme (à l'exception des espaces) qui puisse être supprimé et conserve le même résultat.

DLosc
la source
1
Pouvez-vous partager un lien vers un interprète en ligne? Je ne peux pas exécuter ceci sur repl.it. Je reçoisParse failed: Syntax error at 3:36: Token(Bowling)
Stewie Griffin
1
@StewieGriffin Edité en quelques options.
DLosc
1
@StewieGriffin, cela tire parti d'une bizarrerie dans les implémentations Microsoft de Basic où le guillemet de fermeture d'une chaîne est facultatif si cette chaîne s'étend jusqu'à la fin de la ligne. Je m'attends à ce que la plupart des interprètes non-Microsoft s'opposent aux citations manquantes.
Mark
Apparemment, QBasic a une très forte association d'odeurs pour moi.
Pas que Charles
1
@DLosc Ça sent le livre dont je me suis inspiré et la salle informatique de ma maison en grandissant. Je n'en avais aucune idée. C’est ce LOCATE 1, 2qui l’a fait
Pas que Charles
12

C, 27 29

+2 points grâce à @ceilingcat!

f(){char q<:]="Code B\157wling";puts(q);%>
Betseg
la source
2
Proposer au char q<:]lieu de char q[]et au puts(q);%>lieu deputs(q);}
ceilingcat
Suggestion: 1.utiliser des fonctions distinctes pour afficher chaque segment de la chaîne, puis les exécuter toutes dans la fonction f 2. La magie de l'utilisation de structures pour rendre le code excessivement long
Matthew Roh
1
@MatthewRoh Je pense que vous trouverez peut-être que le système de notation punit cela assez durement
Albert Renshaw
1
@ AlbertRenshaw Ce sont des digraphes
ceilingcat
15
Haha, la première fois que je vois un+2 points thanks to ...
Kritixi Lithos
9

Haskell , score 21 38 46 47 21 70

putStr$toEnum(length"!#%&'*+,-./012345789;<=>?@ADGHIJKLMNOPQRTUVWXYZ[]^_`abcfjkqsvyz{|}~"):"ode B\x6Fwling"

Essayez-le en ligne! L'idée est d'obtenir le début Cen construisant une chaîne de longueur 67 qui contient tous les caractères non utilisés par ailleurs et en convertissant la longueur de cette chaîne en un caractère. J'ai commencé avec putStr$toEnum(length""):"ode B\x6Fwling"( '\x6F'c'est hexadécimal pour '\111'lequel les rendements 'o') et calculé tous les caractères imprimables ASCII non contenus dans le programme:

!#%&'*+,-./012345789;<=>?@ACDGHIJKLMNOPQRTUVWXYZ[]^_`abcfjkqsvyz{|}~

Incidemment, il reste exactement 67 caractères ASCII imprimables qui peuvent être insérés dans la chaîne et Clui - même qui ne peuvent pas figurer dans la chaîne car le programme serait alors réductible à putStr"Code B\x6Fwling".


Solution précédente: (score 21)

f|x<-'C'=mapM putStr[(:)x"ode Bowling"]

Définit une fonction fqui ne prend aucune entrée et imprime la chaîne. Essayez-le en ligne!

Laikoni
la source
1
Cela peut être réduit
Leo
@Leo belle prise! Cette approche fonctionne-t-elle également pour ma version mise à jour avec 95dans la chaîne et la soustraction 4621? (Je n'ai pas le temps de le vérifier moi-même pour le moment, mais
j'y jetterai un
1
Gotcha . Cela m'a pris plus de temps que prévu, vu la simplicité du résultat :)
Leo
8

JavaScript, 19

prompt('C\157de B\x6fwlin'+"g")

Pas un très bon score.

ASCII seulement
la source
z(){var x=alert('Code \nBowling');}
sagiksp
@AlbertRenshaw, le point-virgule peut être supprimé
ASCII uniquement
1
@sagiksp Ne fonctionne pas, n'a pas functionauparavantf
ASCII seulement
1
Damnit oétait inutilisé
ASCII seulement
1
19:prompt('C\157de B\x6fwlin'+"g")
Albert Renshaw
8

Jelly , 94

“!#"$&('*)+-/,13.0456:79<;>=@B?ADFHJLNCPRTEVXZ\G^IKMQ`SWbY[]d_acfhjegliknmprotquvxwy{z}¹|³⁵⁷~°⁹⁻”O%2s8UḄỌ

Essayez-le en ligne!

105 personnages uniques, 11 exotiques ( “¹³⁵⁷°⁹⁻”ḄỌ).

Comment?

Forme la chaîne à partir d'ASCII inversé sur 8 bits, chaque bit étant codé à l'aide du LSB de la valeur Unicode d'un caractère.

“...”O%2s8UḄỌ - Main link: no arguments
“...”         - the string enclosed            !  #  "  $  &  (  '  *  )  +  -  /  ,  1  3  .  0  4  5  6  :  7  9  <  ;  >  =  @  B  ?  A  D  F  H  J  L  N  C  P  R  T  E  V  X  Z  \  G  ^  I  K  M  Q  `  S  W  b  Y  [  ]   d  _  a  c   f   h   j   e   g   l   i   k   n   m   p   r   o   t   q   u   v   x   w   y   {   z   }   ¹   |   ³    ⁵    ⁷   ~   °    ⁹    ⁻
     O        - cast to ordinal (vectorises) [33,35,34,36,38,40,39,42,41,43,45,47,44,49,51,46,48,52,53,54,58,55,57,60,59,62,61,64,66,63,65,68,70,72,74,76,78,67,80,82,84,69,86,88,90,92,71,94,73,75,77,81,96,83,87,98,89,91,93,100,95,97,99,102,104,106,101,103,108,105,107,110,109,112,114,111,116,113,117,118,120,119,121,123,122,125,185,124,179,8309,8311,126,176,8313,8315]
      %2      - mod 2 (vectorises)           [ 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1,  0, 1, 1, 1,  0,  0,  0,  1,  1,  0,  1,  1,  0,  1,  0,  0,  1,  0,  1,  1,  0,  0,  1,  1,  1,  0,  1,  1,  0,  1,   1,   1,  0,  0,   1,   1]
        s8    - split into chunks of 8       [[1,1,0,0,0,0,1,0], [1,1,1,1,0,1,1,0], [0,0,1,0,0,1,1,0], [1,0,1,0,0,1,1,0], [0,0,0,0,0,1,0,0], [0,1,0,0,0,0,1,0], [1,1,1,1,0,1,1,0], [1,1,1,0,1,1,1,0], [0,0,1,1,0,1,1,0], [1,0,0,1,0,1,1,0], [0,1,1,1,0,1,1,0], [1,1,1,0,0,1,1]]
          U   - upend (vectorises)           [[0,1,0,0,0,0,1,1], [0,1,1,0,1,1,1,1], [0,1,1,0,0,1,0,0], [0,1,1,0,0,1,0,1], [0,0,1,0,0,0,0,0], [0,1,0,0,0,0,1,0], [0,1,1,0,1,1,1,1], [0,1,1,1,0,1,1,1], [0,1,1,0,1,1,0,0], [0,1,1,0,1,0,0,1], [0,1,1,0,1,1,1,0], [1,1,0,0,1,1,1]]
           Ḅ  - binary to int (vectorises)   [67, 111, 100, 101, 32, 66, 111, 119, 108, 105, 110, 103]
            Ọ - to character (vectorises)    ['C', 'o', 'd', 'e', ' ', 'B', 'o', 'w', 'l', 'i', 'n', 'g']
              - implicit print               Code Bowling
Jonathan Allan
la source
1
La gelée est plus longue que d'autres, comment est-ce possible?
Christopher
1
@DownChristopher C'est en fait plus court que la réponse python. La réponse en python a cependant une répétition.
Fəˈnɛtɪk
@DownChristopher est-ce que je détecte un sarcasme?
Jonathan Allan
@JonathanAllan non Ouais, je trouve toujours drôle que la gelée soit assez longue ici
Christopher
6

Röda , 33 ans

{["ode B\x6fwling"]|push chr(3*4+57-2).._}

Essayez-le en ligne!

J'ai essayé de suivre toutes les règles. Cela fonctionne en poussant d'abord la chaîne ode Bowling!dans le flux, puis en insérant C= 3 * 4 + 57-2 au premier plan.

Fergusq
la source
6

Cardinal 20

23 caractères non blancs
% #> / NI "CodeB8 ^ o) wl, ing

-3 pour répété "o"

   I
 >\/N
%# "CodeB
 8^o
 ) w
   l
 , i
   n
   g

Chemins de pointeur:

Étape 1: le
pointeur créé à% va à droite

Étape 2: Le
pointeur se sépare en # pour monter, à droite et en bas (P1, P2, P3)

Étape 3 :
P1 envoyé directement par>
P2 Aller à droite
P3 Définir attendre 3 étapes à 8h

Étape 4:
P1 réfléchi par \. \ changé en /
P2 Définit le mode d'impression par "
P3 Attend 2 ticks à 8

Étape 5:
P1 En descendant
P2 Imprimer C
P3 Attendre 1 tick à 8

Étape 6:
P1 Envoyé par ^
P2 Imprimer o
P3 Terminer attendre, continuer, extraire la valeur ASCII de "" (32) à partir de)

Étape 7: P1 En haut
P2 Imprimer d
P3 En bas

Étape 8: P1 reflète le droit de \ modifié en /
P2 Print e
P3 Caractère d’impression avec une valeur ASCII = 32 à partir de, opération

Étape 9:
P1 Reflété par / qui est changé en \
P2 Imprimer B
P3 Fin de champ atteinte et arrête

Étape 10:
P1 réfléchi par I
P2 Fin de champ atteinte et arrêts

Étape 11:
P1 Reflète juste par / qui a été changé en \. Retour à /

Étape 12:
P1 réfléchi à gauche par N

Étape 13:
P1 réfléchi par /

Étape 14:
P1 Définissez le mode d'impression par "

Étape 15:
Impression P1 o

Étape 16:
Impression P1 avec w

Étape 17:
Impression P1 l

Étape 18:
Impression P1 i

Étape 19:
Impression P1 n

Étape 20:
Impression P1 g

Étape 21:
P1 Atteint la fin du champ et s’arrête.

Essayez-le en ligne

fəˈnɛtɪk
la source
5

C, 73

Merci à @Laikoni!

F(){printf("Code B\157wli%cg",48+strlen("!#$&'*-../2369:<=>?@ADEGHIJKLMNOPQRSTUVWXYZ[]^_`abhjkmquvxyz|~"));}

Essayez-le en ligne!

C,  31   33  35

F(){printf("Code B\157wli%cg",96|0xD+3*4/8);}

Merci à @ceilingcat et @DLosc pour deux points supplémentaires et à @ Ørjan Johansen pour deux autres points!

Essayez-le en ligne!

Steadybox
la source
1
@ceilingcat Ensuite, vous pouvez supprimer le 8-code et conserver un code valide. 0xA-4+8devrait fonctionner, cependant.
DLosc
1
Serait 0xA+32/8travailler? (Sans que quelque chose soit amovible, c'est ça.)
Ørjan Johansen Le
@ ØrjanJohansen Je pense que c'est le cas. Aucun de +32, +3, +2, +3/8, +2/8, /8ou +8produit la sortie droite. Merci!
Steadybox
Oh, ou 0xD+4*8/32. Non attendez, cela raccourcirait pour 0xD+4/3ne pas le faire.
Ørjan Johansen
1
En utilisant la même approche que ma réponse Haskell, on obtient un score de 74, si ce n’est pas réductible de quelque façon que ce soit: essayez-le en ligne!
Laikoni
3

Lot, 19 caractères

@echO(Cod%TMP:~5,1% Bowling

Commençant par Windows Vista, TMPcommence par C:\Users\et constitue donc %TMP:~5,1%une manière verbeuse d’écrire e, même s’il faut imposer une %pénalité double à -4.

Neil
la source
3

Brainfuck: -204

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

Bien, score épouvantable, mais c'était amusant à écrire.

  • 122 caractères
  • alnum répété: -0 ()
  • ponctuation répétée: -134 (- [---]. ----------- ..-- [---] -. [-] .- [---] ..-- ---------. --- ..-------.)
  • répété autre: -192 (+++++++> +> + <> ++++> + <> +> ++ <>> + <> +++++++++++++ ++++)
  • caractères d'espacement: -0 ()
  • personnages exotiques: -0 ()
Haydn Dias
la source
Brainfuck remporte-t-il un défi PPCG? ; P
Draco18s
@ Draco18s probablement pas hahaha pleurer.
Haydn Dias
1
"Amusant à écrire", vous voulez dire "Code Bowling" dans un générateur de texte ?
Jo King
3

Java 8, 2 3 5 13 17 18 19 20 21 24 77 78 points

+53 score (24 → 77) grâce à @Laikoni .

v->(char)"!#$%&'*,/0234689:;<=?@ADEFGHIJKLMNOPQRSTUVWXYZ[]^_`bfjkmpqsuxyz{|}~".length()+"\157de Bowling"

104 caractères
- alnum répété: -15 ( helng)
- ponctuation répétée: -10 ( "()"")
- autre ASCII répété: aucun
- caractères d'espacement: -1
SCORE: 78

Essayez-le en ligne.


Vieux 24 octets répondent:

v->"C\157de Bowlin"+(char)103;

30 caractères
- alnum répété: -3 ( 1)
- ponctuation répétée: -2 ( ")
- autre ASCII répété: aucun
- caractères d'espacement: -1
SCORE: 24

Essayez-le en ligne.

Kevin Cruijssen
la source
Utiliser une évasion octale dans le texte augmenterait votre score de 6 au lieu des 2 obtenu pour votre évasion Unicode (avoir les deux est pire cependant). En outre, concaténer le premier ou le dernier caractère augmentera votre score de 1. Enfin, imaginez que vous feriez mieux de choisir un lambda plutôt qu'une fonction nommée.
Neil
@Neil Weird, je l'avais déjà proposé il y Object x(){return"C\157de Bowling";}a quelques heures pour 17 points .. Apparemment, je ne l'ai pas encore modifié / sauvegardé dans ma soumission ..: S Quant au lambda, j'utilise Java 7, qui ne fonctionne pas ont encore des lambdas. Je pourrais cependant ajouter une réponse Java 8 avec lambda.
Kevin Cruijssen
Oups, désolé, je n'ai pas remarqué le 7. (Mais n'oubliez pas la concaténation.)
Neil
1
En utilisant la même approche que ma réponse Haskell donne cette version avec un score de 77: Essayez-le en ligne! .
Laikoni
@Laikoni Merci! +53 marquer grâce à vous. Et comme les réponses à Java 8 sont généralement résolues sans le point-virgule final, je pourrais supprimer ce point-virgule final et remplacer le caractère répété.,, par ,;+1. C'est drôle comme la chaîne qui utilise tous les fichiers ASCII imprimables disponibles est EXACTEMENT 97 caractères pour le code de caractère C. :)
Kevin Cruijssen le
2

empilés , 42

(67:43,1 ab)2 9*pf sum 8/0\|>+chr'de Bowling',EPS#`

Essayez-le en ligne!

Laisse la sortie sur la pile. Voici la ventilation:

length: 51
repeated alnum:        -0 ()
repeated punct:        -4 (',)
repeated other:        -0 ()
whitespace characters: -5 (     )
exotic characters:     -0 ()
total score: 42

Je pourrais probablement le faire plus haut, mais il est à 42 soo ....

Un autre concurrent, 40:

(67:43,sum)9 pf 2%MIN 0\|>+chr'de Bowling',EPS#`

J'ai utilisé ce script pour le marquer.

Conor O'Brien
la source
2

le mal , -81

Mieux que Brainfuck!

aeeaeuwkaaeeuwygaeaeclaaxjlwalusbdgueuewguwpweewpuuuwuuuwpuweew

Explication

aeeaeuw //Write 'C'
k       //Set P[0] to 'C'
aaeeuw  //Write 'O'
y       //Set W[0] to 'O'
gaeae   //Set Accumulator to 'D'
claa    //Create new Wheel cell at index 0, swap with Accumulator, add 2
xj      //Set alternate marker mode and drop marker
lwa     //Write value of W[0], add 1
lu      //Put it back, subtract 1 from Accumulator
sb      //Go to 'j' if Accumulator != 0
d       //Delete W[0]
        //The above loop writes 'D' and 'E'
gueuew  //Write ' '
guw     //Write 'B'
pw      //Write 'o'
eew     //Write 'w'
puuuw   //Write 'l'
uuuw    //Write 'i'
puw     //Write 'n'
eew     //Write 'g'

Soumis parce que personne ne fait rien dans le mal mais c'est assez amusant.

But:

Longueur = 63

a*8  = -24
e*12 = -36
g*2  = -6
l*2  = -6
p*2  = -6
u*12  = -36
w*10  = -30

Essayez-le en ligne!

EDIT: TiO semble gérer de manière incorrecte la création et la suppression de nouvelles cellules Wheel - J'ai déposé un rapport de bogue sur le sujet. Cela ne fonctionnera pas correctement là-bas, mais je l'ai exécuté sur mon propre interprète et cela fonctionne et vous pouvez vous fier à moi pour que je ne m'inquiète pas pour ça;)

charliefox2
la source
2

Perl: 29 , 33

$_=OWLING;printf%s,"C\157de".chr(30+8/4).B.lc

But:

- 46 characters long
- repeated alnum:       -6 (rc)
- repeated punctuation: -6 ("..)
- repeated other:       -0 ()
- whitespace characters:  -1 (
)
- exotic characters:  -0 ()

Total score: 33
Toto
la source
2

05AB1E , 94 points

”X1234bcde5fghijk68l9<mn>,o.p|q\/{})r(_-+s=tu*vwxyzAB&YDEFG^HI%$ZK#L@!MNO~PQR`ST':UVW[0];"”€a7ôJCç€?

Essayez-le en ligne!


- 100 characters long
- repeated alnum:       -0 ()
- repeated punctuation: -0 ()
- repeated other:       -0 ()
- whitespace characters:  -0 ()
- exotic characters:  -6 (””€ôç€)

Total score: 94

Convertit essentiellement (l'ASCII binaire de Code Bowling):

['1000011', '1101111', '1100100', '1100101', '0100000', '1000010', '1101111', '1110111', '1101100', '1101001', '1101110', '1100111']

Dans une chaîne de 1 et de 0, chaque 1 est remplacé par une lettre de l'alphabet et chaque 0 par un espace, un symbole ou un chiffre.

”X1234bcde5fghijk68l9<mn>,o.p|q\/{})r(_-+s=tu*vwxyzAB&YDEFG^HI%$ZK#L@!MNO~PQR`ST':UVW[0];"”

Est la chaîne, où 1 sont des lettres et 0 sont des symboles, des chiffres ou toute autre chose. Nous parcourons ensuite, en voyant lesquels sont alphabétiques, en poussant 1 pour alphabétique 0 pour non alphabétique. Nous divisons ensuite en groupes de 7, reconvertissons en ASCII et imprimons chaque caractère.

Urne Magique De Pieuvre
la source
2

T-SQL, 65 18 32! points

PRINT char(78-9605*43%12) + 'ode Bowling'

Inspiré par une astuce de la réponse QBasic de Dlosc , j'ai trouvé un moyen d'inclure les 10 chiffres et la plupart des opérateurs mathématiques ( %reste / modulo, manquant seulement /), principalement par essais et erreurs. Je ne pense pas qu'il soit possible d'obtenir un 67 en supprimant une combinaison de chiffres / symboles, mais vous pouvez essayer.

Version 2 (18 points, trivial):

DECLARE @ char(12)='Code Bowling'PRINT @

Pas un très bon score, mais c’est ce que ma première version a simplifié (merci, MickyT). Tout le reste que j'ai essayé (encodage et décodage de hex64, sélection d'éléments individuels dans une chaîne, conversion de valeurs ASCII, etc.) comportait trop de caractères répétés (en particulier des ECRsymboles (),@) qui le conduisaient au négatif.

Version 1 (65 points, invalide):

DECLARE @ char(123)=
'Code Bowling FGHJKMOQSUVWXYZbjkmpqsuvxyz045789 [!?.-":;]{`~#$%^&*_+|\><}'
PRINT left(@,LEN(@)/6)

J'ai utilisé la longueur de la chaîne pour déterminer le nombre de caractères que j'utilise du côté gauche. Par conséquent, si vous supprimez un seul caractère de la chaîne, le résultat de la division entière sera abaissé à 11, en sortie uniquement Code Bowlin.

BradC
la source
Pas sûr, mais je pense que cela peut être réduit aux DECLARE @ char(12)='Code Bowling'PRINT @règles.
MickyT
@MickyT Cela peut-il invalider ma réponse? Quelqu'un dans le chat a dit qu'il ne devait supporter que la suppression de simples caractères aléatoires, pas de longues portions arbitraires, étaient-ils incorrects?
BradC
Je le laisserais ici pour le moment, ça fait toujours plaisir de voir une réponse t-SQL
MickyT
@MickyT Je vais le laisser mais rayer le score. Le mieux que je puisse faire sinon, c'est un maigre 18 points: P
BradC
2

; # , score -1163, non compétitif

Je ne pense pas que ce serait beaucoup de concurrence même si cela pouvait rivaliser.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Essayez-le en ligne! Remarque: TIO n'a pas; # d'interprète, seulement; # +.

Khuldraeseth na'Barya
la source
1

CJam , score 47

"'#?GyQ2wE(s6&␟JI!gF$u*Aq;0p4BvOKkHLhM"3/{:i~-z+c}%

Espérons que cela ne pose aucun problème ...

Utilise un caractère exotique (séparateur d'unité, ASCII 31, représenté par ) et un caractère répété ( "). Je pense que cela pourrait être encore plus long, mais je vais le laisser tel quel pour le moment.

Essayez-le en ligne!

Le programme fonctionne en prenant cette longue chaîne et en la divisant en sous-chaînes de longueur 3. Chaque sous-chaîne est ensuite mappée sur le bloc, ce qui convertit ses caractères en leurs valeurs ASCII, vide les valeurs de la pile, prend la différence absolue des deux secondes, ajoute le résultat avec le premier, puis reconvertit le résultat final en ASCII. personnage.

Chat d'affaires
la source
1

CJam, score 93

"g!#$&'()n*+/0134i5689:;<l=>?@ADEwFGHIJKLoMNOPQRSBTUVWXYZ [\]^_`aebcfhjkmdqrstuvxpyz{|}  C"7~%2,.-

Essayez-le en ligne

Inspiré de la réponse Python de TidB .
Je ne sais pas s’il est possible d’éviter la répétition des guillemets.

Explication:

La chaîne contient "Cpde Bowling" en sens inverse, tous les 8 caractères.
7~%extraits "Cpde Bowling" ( 7~= -8)
2,.-décrémente le caractère p ( 2,= [0 1])

Aditsu
la source
@ Laikoni si vous vouliez dire que j'ai enfreint la règle du code inutilisé, il devrait être corrigé maintenant
Aditsu
@ Laikoni oui, mais si vous supprimez un seul caractère de son code, il ne fonctionnera pas correctement. Par conséquent, comme tout le code est utilisé, il est valide.
Magic Octopus Urn le
@carusocomputing Les règles mentionnent clairement que le code ne devrait pas fonctionner "si un caractère individuel (ou un ou plusieurs jeux de caractères) est / sont supprimés", donc je ne pense pas que votre interprétation soit valable. Quoi qu'il en soit, aditsu a déjà résolu le problème, donc tout va bien maintenant.
Laikoni
1

PHP, 33 points

C'était assez difficile à trouver.

Le score pourrait être amélioré à l'avenir.

<?echo IHASZODECG9F^"
'%6z\r+2/.W!";

La nouvelle ligne est supposée être une nouvelle ligne de style Linux! Le style Windows et le style Mac ancien ne fonctionneront pas correctement.

Ismael Miguel
la source
1

Ruby, 75

Approximativement un port de la réponse Python, mais Ruby n’a pas cette fonction step cool, alors j’utilise gsubplutôt. J'ai aussi décidé de m'amuser un peu avec les personnages exotiques en lançant des phrases dans Google Translate

Essayez-le en ligne!

print"Cachjkmq\x6fvyzADEFdGHIJKLMeNOPQRST UVWXYZ0B234589[o!?-:;]`w~@\#$%^&l*_+=|><i コードゴルフn 代碼保齡球 gκωδικός".gsub /(.).{7}/,'\1'
Valeur d'encre
la source
1

USML, 12 ou 9 points (non en compétition)

"Code\tBowling'

Essayez-le en ligne!

Cette réponse trompe un peu en abusant du rendu HTML. La chaîne réellement créée par ceci est "Code\tBowling ". Des points sont perdus pour avoir répété le caractère "o".

Pour une réponse non trompeuse:

"Code Bowling

USML en est encore à ses débuts et n’est pas encore en mesure d’augmenter la taille du programme.

MarkSill
la source
" USML en est encore à ses débuts et n'est pas encore capable d'augmenter la taille du programme. ". Qu'en est-il de cela pour 10 points "Code&'Bowling(* Remarque: remplacez-le &par un saut de ligne, il ne me laissera pas les taper dans les commentaires)
Albert Renshaw
Vous pouvez également ajouter une barre oblique inverse `` devant l'une des lettres et la chaîne restera affichée car le compilateur l'ignorera ou échappera au caractère. Cela donne le score (en compétition) jusqu'à 11 maintenant!
Albert Renshaw
Vous pouvez ensuite ajouter un saut de ligne et une minuscule sà la ligne suivante (obtenir une sous-chaîne de rien, donc ne pas modifier la sortie du tout) pour obtenir un score concurrent de 12, identique à votre score non concurrent, à l'exception d'un score réel. soumission valide: D
Albert Renshaw le
Enfait, voici une réponse en 16 points dans USML, je posterai le hastebin car il est difficile de taper du code multiligne dans les commentaires: hastebin.com/icuguviyax.tex
Albert Renshaw le
Je suis un idiot et j'ai oublié les règles à mon propre défi lol, un sous-ensemble du code ci-dessus compléterait le défi, disqualifiant ma réponse; oups!
Albert Renshaw
1

Cubix , 85

Codeha1spqumtr;$"gnilwoB"Sv"ADEFH%IJK2f!OPUzQ0V3XY&*[-|L:]\T`~#x>MR56cGk'?W<()b4j}.{Z_^/978@

Essayez-le en ligne!

Cubifié avec des caractères insignifiants remplacés par.

        C o d e
        . . . .
        . . u . 
        . . ; . 
" g n i l w o B " S v " . . . .
. . . . . . . ! . . U . . . . .
. . . . . . . L . . \ . . . . .
> . R . . . . . . . W < . . . .
        . . . {
        . . ^ /
        . . . @
        . . . .

Je pense avoir rendu le chemin assez fragile pour que le retrait de personnages le casse.

Regarde le courir

- 92 characters long
- repeated alnum:       -3 (o)
- repeated punctuation: -4 ("")
- repeated other:       -0 ()
- whitespace characters:  -0 ()
- exotic characters:  -0 ()

Total score: 85
MickyT
la source
0

VB.net, 68

cONSOLE.WRITE("Code BowlingADEFGHJKQUVXYZfhjkmpqyz`!@#$%^&*9876543~][{}\|';:<>?+=-_".subStrinG(0,12))

Un test rapide mettant à profit l'insensibilité à la casse et le manque de "système" de VB.

chrixbittinx
la source
1
Je ne connais pas VB.net, mais cela ne peut-il pas être réduit cONSOLE.WRITE("Code Bowling")?
Laikoni
1
Oui, ça peut. Par la poste,: Tous les codes doivent être utilisés. Cela signifie que le programme ne doit pas toujours terminer correctement la tâche si un caractère individuel (ou un ou plusieurs jeux de caractères) est / sont supprimés. Naturellement, un sous-ensemble du programme ne devrait pas être en mesure de mener à bien la tâche sans le reste du programme. "Le score devrait être 17, je crois.
charliefox2
@ charliefox2 Merci. Je n'ai pas lu cela - ça devait être trop excitant d'utiliser VB!
Chrixbittinx
1
Hey, 17 écrase toujours mon score de -81!
charliefox2
0

Coquille: note 17

#!/bin/bash
echo "CODE BoWLING" | tr D-X d-x
  • 44 caractères
  • alnum répété: -12 (bhoD)
  • ponctuation répétée: -4 ("-)
  • répété autre: -4 (/)
  • caractères d'espacement: -7 ()
  • personnages exotiques: -0 ()

Score total: 17

Perette
la source
0

Acc !! , 171 caractères

119
Write _-52
Write _-8
Count i while i-2 {
	Write _-19+i
}
32
Write _
_+34
Write _
_+45
Write _
_+8
Write _
_-11
Write _
Count i while i-2 {
	Write 105+i*5
}
_-5
Write _

Essayez-le en ligne!

Acc !! fonctionne bien pour ce défi car les espaces sont nécessaires et les boucles sont coûteuses. Je me suis servi de l’ accumulateur ici, mais mal, pour augmenter les caractères. Voici un bref aperçu de la page:

AccumulatorToute expression autonome est évaluée et attribuée à l'accumulateur (qui est accessible en tant que _). Ainsi, par exemple, 3 est une déclaration qui définit l'accumulateur sur 3; _ + 1 incrémente l'accumulateur; et _ * N lit un caractère et multiplie l'accumulateur par son charcode. (N obtient l'entrée)

Write <charcode> Renvoie un seul caractère avec la valeur ASCII / Unicode donnée sur stdout. Le charcode peut être n'importe quelle expression.

Les boucles en Acc, du moins pour le golf, sont pénibles. Ils ont besoin d'accolades et tous les espaces sont nécessaires. Sinon, c'est assez explicite.

FantaC
la source
Il s’agit d’un défi de quilles et non de golf. Vous êtes donc censé maximiser votre score. De plus, sa notation est inhabituelle. En utilisant l'outil d'évaluation ci-dessus, votre code obtient un score négatif.
Ørjan Johansen
1
@ ØrjanJohansen On dirait qu'ils tentent de maximiser le score (en raison de "j'ai utilisé l' accumulateur ici, mais mal, pour augmenter les caractères"), mais ils ne l'ont tout simplement pas marqué correctement.
LyricLy
@ ØrjanJohansen Ah oui, il semble que j'ai complètement raté la section des scores. Je
mettrai à